drivers/ide/legacy/ide-cs.c

   1 /*======================================================================
   2
   3     A driver for PCMCIA IDE/ATA disk cards
   4
   5     The contents of this file are subject to the Mozilla Public
   6     License Version 1.1 (the "License"); you may not use this file
   7     except in compliance with the License. You may obtain a copy of
   8     the License at http://www.mozilla.org/MPL/
   9
  10     Software distributed under the License is distributed on an "AS
  11     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  12     implied. See the License for the specific language governing
  13     rights and limitations under the License.
  14
  15     The initial developer of the original code is David A. Hinds
  16     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  17     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  18
  19     Alternatively, the contents of this file may be used under the
  20     terms of the GNU General Public License version 2 (the "GPL"), in
  21     which case the provisions of the GPL are applicable instead of the
  22     above.  If you wish to allow the use of your version of this file
  23     only under the terms of the GPL and not to allow others to use
  24     your version of this file under the MPL, indicate your decision
  25     by deleting the provisions above and replace them with the notice
  26     and other provisions required by the GPL.  If you do not delete
  27     the provisions above, a recipient may use your version of this
  28     file under either the MPL or the GPL.
  29
  30 ======================================================================*/
  31
  32 #include <linux/module.h>
  33 #include <linux/kernel.h>
  34 #include <linux/init.h>
  35 #include <linux/ptrace.h>
  36 #include <linux/slab.h>
  37 #include <linux/string.h>
  38 #include <linux/timer.h>
  39 #include <linux/ioport.h>
  40 #include <linux/ide.h>
  41 #include <linux/hdreg.h>
  42 #include <linux/major.h>
  43 #include <linux/delay.h>
  44 #include <asm/io.h>
  45 #include <asm/system.h>
  46
  47 #include <pcmcia/cs_types.h>
  48 #include <pcmcia/cs.h>
  49 #include <pcmcia/cistpl.h>
  50 #include <pcmcia/ds.h>
  51 #include <pcmcia/cisreg.h>
  52 #include <pcmcia/ciscode.h>
  53
  54 #define DRV_NAME "ide-cs"
  55
  56 /*====================================================================*/
  57
  58 /* Module parameters */
  59
  60 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  61 MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
  62 MODULE_LICENSE("Dual MPL/GPL");
  63
  64 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  65
  66 #ifdef CONFIG_PCMCIA_DEBUG
  67 INT_MODULE_PARM(pc_debug, 0);
  68 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  69 #else
  70 #define DEBUG(n, args...)
  71 #endif
  72
  73 /*====================================================================*/
  74
  75 typedef struct ide_info_t {
  76         struct pcmcia_device    *p_dev;
  77         ide_hwif_t              *hwif;
  78     int         ndev;
  79     dev_node_t  node;
  80 } ide_info_t;
  81
  82 static void ide_release(struct pcmcia_device *);
  83 static int ide_config(struct pcmcia_device *);
  84
  85 static void ide_detach(struct pcmcia_device *p_dev);
  86
  87
  88
  89
  90 /*======================================================================
  91
  92     ide_attach() creates an "instance" of the driver, allocating
  93     local data structures for one device.  The device is registered
  94     with Card Services.
  95
  96 ======================================================================*/
  97
  98 static int ide_probe(struct pcmcia_device *link)
  99 {
 100     ide_info_t *info;
 101
 102     DEBUG(0, "ide_attach()\n");
 103
 104     /* Create new ide device */
 105     info = kzalloc(sizeof(*info), GFP_KERNEL);
 106     if (!info)
 107         return -ENOMEM;
 108
 109     info->p_dev = link;
 110     link->priv = info;
 111
 112     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 113     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
 114     link->io.IOAddrLines = 3;
 115     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
 116     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 117     link->conf.Attributes = CONF_ENABLE_IRQ;
 118     link->conf.IntType = INT_MEMORY_AND_IO;
 119
 120     return ide_config(link);
 121 } /* ide_attach */
 122
 123 /*======================================================================
 124
 125     This deletes a driver "instance".  The device is de-registered
 126     with Card Services.  If it has been released, all local data
 127     structures are freed.  Otherwise, the structures will be freed
 128     when the device is released.
 129
 130 ======================================================================*/
 131
 132 static void ide_detach(struct pcmcia_device *link)
 133 {
 134     ide_info_t *info = link->priv;
 135     ide_hwif_t *hwif = info->hwif;
 136     unsigned long data_addr, ctl_addr;
 137
 138     DEBUG(0, "ide_detach(0x%p)\n", link);
 139
 140     data_addr = hwif->io_ports.data_addr;
 141     ctl_addr  = hwif->io_ports.ctl_addr;
 142
 143     ide_release(link);
 144
 145     release_region(ctl_addr, 1);
 146     release_region(data_addr, 8);
 147
 148     kfree(info);
 149 } /* ide_detach */
 150
 151 static const struct ide_port_ops idecs_port_ops = {
 152         .quirkproc              = ide_undecoded_slave,
 153 };
 154
 155 static ide_hwif_t *idecs_register(unsigned long io, unsigned long ctl,
 156                                 unsigned long irq, struct pcmcia_device *handle)
 157 {
 158     ide_hwif_t *hwif;
 159     hw_regs_t hw;
 160     int i;
 161     u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
 162
 163     if (!request_region(io, 8, DRV_NAME)) {
 164         printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
 165                         DRV_NAME, io, io + 7);
 166         return NULL;
 167     }
 168
 169     if (!request_region(ctl, 1, DRV_NAME)) {
 170         printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
 171                         DRV_NAME, ctl);
 172         release_region(io, 8);
 173         return NULL;
 174     }
 175
 176     memset(&hw, 0, sizeof(hw));
 177     ide_std_init_ports(&hw, io, ctl);
 178     hw.irq = irq;
 179     hw.chipset = ide_pci;
 180     hw.dev = &handle->dev;
 181
 182     hwif = ide_find_port();
 183     if (hwif == NULL)
 184         goto out_release;
 185
 186     i = hwif->index;
 187
 188     ide_init_port_data(hwif, i);
 189     ide_init_port_hw(hwif, &hw);
 190     hwif->port_ops = &idecs_port_ops;
 191
 192     idx[0] = i;
 193
 194     ide_device_add(idx, NULL);
 195
 196     if (hwif->present)
 197         return hwif;
 198
 199     /* retry registration in case device is still spinning up */
 200     for (i = 0; i < 10; i++) {
 201         msleep(100);
 202         ide_port_scan(hwif);
 203         if (hwif->present)
 204             return hwif;
 205     }
 206
 207     return hwif;
 208
 209 out_release:
 210     release_region(ctl, 1);
 211     release_region(io, 8);
 212     return NULL;
 213 }
 214
 215 /*======================================================================
 216
 217     ide_config() is scheduled to run after a CARD_INSERTION event
 218     is received, to configure the PCMCIA socket, and to make the
 219     ide device available to the system.
 220
 221 ======================================================================*/
 222
 223 #define CS_CHECK(fn, ret) \
 224 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 225
 226 static int ide_config(struct pcmcia_device *link)
 227 {
 228     ide_info_t *info = link->priv;
 229     tuple_t tuple;
 230     struct {
 231         u_short         buf[128];
 232         cisparse_t      parse;
 233         config_info_t   conf;
 234         cistpl_cftable_entry_t dflt;
 235     } *stk = NULL;
 236     cistpl_cftable_entry_t *cfg;
 237     int pass, last_ret = 0, last_fn = 0, is_kme = 0;
 238     unsigned long io_base, ctl_base;
 239     ide_hwif_t *hwif;
 240
 241     DEBUG(0, "ide_config(0x%p)\n", link);
 242
 243     stk = kzalloc(sizeof(*stk), GFP_KERNEL);
 244     if (!stk) goto err_mem;
 245     cfg = &stk->parse.cftable_entry;
 246
 247     tuple.TupleData = (cisdata_t *)&stk->buf;
 248     tuple.TupleOffset = 0;
 249     tuple.TupleDataMax = 255;
 250     tuple.Attributes = 0;
 251
 252     is_kme = ((link->manf_id == MANFID_KME) &&
 253               ((link->card_id == PRODID_KME_KXLC005_A) ||
 254                (link->card_id == PRODID_KME_KXLC005_B)));
 255
 256     /* Not sure if this is right... look up the current Vcc */
 257     CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));
 258
 259     pass = io_base = ctl_base = 0;
 260     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 261     tuple.Attributes = 0;
 262     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 263     while (1) {
 264         if (pcmcia_get_tuple_data(link, &tuple) != 0) goto next_entry;
 265         if (pcmcia_parse_tuple(link, &tuple, &stk->parse) != 0) goto next_entry;
 266
 267         /* Check for matching Vcc, unless we're desperate */
 268         if (!pass) {
 269             if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 270                 if (stk->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
 271                     goto next_entry;
 272             } else if (stk->dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
 273                 if (stk->conf.Vcc != stk->dflt.vcc.param[CISTPL_POWER_VNOM] / 10000)
 274                     goto next_entry;
 275             }
 276         }
 277
 278         if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
 279             link->conf.Vpp =
 280                 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 281         else if (stk->dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
 282             link->conf.Vpp =
 283                 stk->dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
 284
 285         if ((cfg->io.nwin > 0) || (stk->dflt.io.nwin > 0)) {
 286             cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &stk->dflt.io;
 287             link->conf.ConfigIndex = cfg->index;
 288             link->io.BasePort1 = io->win[0].base;
 289             link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
 290             if (!(io->flags & CISTPL_IO_16BIT))
 291                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 292             if (io->nwin == 2) {
 293                 link->io.NumPorts1 = 8;
 294                 link->io.BasePort2 = io->win[1].base;
 295                 link->io.NumPorts2 = (is_kme) ? 2 : 1;
 296                 if (pcmcia_request_io(link, &link->io) != 0)
 297                         goto next_entry;
 298                 io_base = link->io.BasePort1;
 299                 ctl_base = link->io.BasePort2;
 300             } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
 301                 link->io.NumPorts1 = io->win[0].len;
 302                 link->io.NumPorts2 = 0;
 303                 if (pcmcia_request_io(link, &link->io) != 0)
 304                         goto next_entry;
 305                 io_base = link->io.BasePort1;
 306                 ctl_base = link->io.BasePort1 + 0x0e;
 307             } else goto next_entry;
 308             /* If we've got this far, we're done */
 309             break;
 310         }
 311
 312     next_entry:
 313         if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
 314             memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
 315         if (pass) {
 316             CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
 317         } else if (pcmcia_get_next_tuple(link, &tuple) != 0) {
 318             CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 319             memset(&stk->dflt, 0, sizeof(stk->dflt));
 320             pass++;
 321         }
 322     }
 323
 324     CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
 325     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
 326
 327     /* disable drive interrupts during IDE probe */
 328     outb(0x02, ctl_base);
 329
 330     /* special setup for KXLC005 card */
 331     if (is_kme)
 332         outb(0x81, ctl_base+1);
 333
 334      hwif = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
 335      if (hwif == NULL && link->io.NumPorts1 == 0x20) {
 336             outb(0x02, ctl_base + 0x10);
 337             hwif = idecs_register(io_base + 0x10, ctl_base + 0x10,
 338                                   link->irq.AssignedIRQ, link);
 339     }
 340
 341     if (hwif == NULL)
 342         goto failed;
 343
 344     info->ndev = 1;
 345     sprintf(info->node.dev_name, "hd%c", 'a' + hwif->index * 2);
 346     info->node.major = hwif->major;
 347     info->node.minor = 0;
 348     info->hwif = hwif;
 349     link->dev_node = &info->node;
 350     printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
 351            info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
 352
 353     kfree(stk);
 354     return 0;
 355
 356 err_mem:
 357     printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
 358     goto failed;
 359
 360 cs_failed:
 361     cs_error(link, last_fn, last_ret);
 362 failed:
 363     kfree(stk);
 364     ide_release(link);
 365     return -ENODEV;
 366 } /* ide_config */
 367
 368 /*======================================================================
 369
 370     After a card is removed, ide_release() will unregister the net
 371     device, and release the PCMCIA configuration.  If the device is
 372     still open, this will be postponed until it is closed.
 373
 374 ======================================================================*/
 375
 376 static void ide_release(struct pcmcia_device *link)
 377 {
 378     ide_info_t *info = link->priv;
 379     ide_hwif_t *hwif = info->hwif;
 380
 381     DEBUG(0, "ide_release(0x%p)\n", link);
 382
 383     if (info->ndev) {
 384         /* FIXME: if this fails we need to queue the cleanup somehow
 385            -- need to investigate the required PCMCIA magic */
 386         ide_unregister(hwif);
 387     }
 388     info->ndev = 0;
 389
 390     pcmcia_disable_device(link);
 391 } /* ide_release */
 392
 393
 394 /*======================================================================
 395
 396     The card status event handler.  Mostly, this schedules other
 397     stuff to run after an event is received.  A CARD_REMOVAL event
 398     also sets some flags to discourage the ide drivers from
 399     talking to the ports.
 400
 401 ======================================================================*/
 402
 403 static struct pcmcia_device_id ide_ids[] = {
 404         PCMCIA_DEVICE_FUNC_ID(4),
 405         PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),        /* Corsair */
 406         PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),        /* Hitachi */
 407         PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),        /* I-O Data CFA */
 408         PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),        /* Mitsubishi CFA */
 409         PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
 410         PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),        /* SanDisk CFA */
 411         PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000),        /* Kingston */
 412         PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000),        /* Toshiba */
 413         PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
 414         PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000),        /* Samsung */
 415         PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000),        /* Hitachi */
 416         PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
 417         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100),        /* Viking CFA */
 418         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),        /* Lexar, Viking CFA */
 419         PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
 420         PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
 421         PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
 422         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
 423         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
 424         PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
 425         PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
 426         PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
 427         PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
 428         PCMCIA_DEVICE_PROD_ID12("EXP   ", "CD-ROM", 0x0a5c52fd, 0x66536591),
 429         PCMCIA_DEVICE_PROD_ID12("EXP   ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
 430         PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
 431         PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
 432         PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
 433         PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
 434         PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
 435         PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
 436         PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
 437         PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
 438         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
 439         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
 440         PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2      ", 0xe37be2b5, 0x8671043b),
 441         PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF300", 0x7ed2ad87, 0x7e9e78ee),
 442         PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
 443         PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
 444         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
 445         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
 446         PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
 447         PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
 448         PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
 449         PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
 450         PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
 451         PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
 452         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF45", 0x709b1bf1, 0xf68b6f32),
 453         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
 454         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
 455         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
 456         PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
 457         PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
 458         PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
 459         PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
 460         PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
 461         PCMCIA_DEVICE_NULL,
 462 };
 463 MODULE_DEVICE_TABLE(pcmcia, ide_ids);
 464
 465 static struct pcmcia_driver ide_cs_driver = {
 466         .owner          = THIS_MODULE,
 467         .drv            = {
 468                 .name   = "ide-cs",
 469         },
 470         .probe          = ide_probe,
 471         .remove         = ide_detach,
 472         .id_table       = ide_ids,
 473 };
 474
 475 static int __init init_ide_cs(void)
 476 {
 477         return pcmcia_register_driver(&ide_cs_driver);
 478 }
 479
 480 static void __exit exit_ide_cs(void)
 481 {
 482         pcmcia_unregister_driver(&ide_cs_driver);
 483 }
 484
 485 late_initcall(init_ide_cs);
 486 module_exit(exit_ide_cs);