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 /*====================================================================*/
  55
  56 /* Module parameters */
  57
  58 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  59 MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
  60 MODULE_LICENSE("Dual MPL/GPL");
  61
  62 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  63
  64 #ifdef PCMCIA_DEBUG
  65 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
  66 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  67 static char *version =
  68 "ide-cs.c 1.3 2002/10/26 05:45:31 (David Hinds)";
  69 #else
  70 #define DEBUG(n, args...)
  71 #endif
  72
  73 /*====================================================================*/
  74
  75 static const char ide_major[] = {
  76     IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR,
  77     IDE4_MAJOR, IDE5_MAJOR
  78 };
  79
  80 typedef struct ide_info_t {
  81         struct pcmcia_device    *p_dev;
  82     int         ndev;
  83     dev_node_t  node;
  84     int         hd;
  85 } ide_info_t;
  86
  87 static void ide_release(struct pcmcia_device *);
  88 static int ide_config(struct pcmcia_device *);
  89
  90 static void ide_detach(struct pcmcia_device *p_dev);
  91
  92
  93
  94
  95 /*======================================================================
  96
  97     ide_attach() creates an "instance" of the driver, allocating
  98     local data structures for one device.  The device is registered
  99     with Card Services.
 100
 101 ======================================================================*/
 102
 103 static int ide_probe(struct pcmcia_device *link)
 104 {
 105     ide_info_t *info;
 106
 107     DEBUG(0, "ide_attach()\n");
 108
 109     /* Create new ide device */
 110     info = kzalloc(sizeof(*info), GFP_KERNEL);
 111     if (!info)
 112         return -ENOMEM;
 113
 114     info->p_dev = link;
 115     link->priv = info;
 116
 117     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 118     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
 119     link->io.IOAddrLines = 3;
 120     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
 121     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 122     link->conf.Attributes = CONF_ENABLE_IRQ;
 123     link->conf.IntType = INT_MEMORY_AND_IO;
 124
 125     return ide_config(link);
 126 } /* ide_attach */
 127
 128 /*======================================================================
 129
 130     This deletes a driver "instance".  The device is de-registered
 131     with Card Services.  If it has been released, all local data
 132     structures are freed.  Otherwise, the structures will be freed
 133     when the device is released.
 134
 135 ======================================================================*/
 136
 137 static void ide_detach(struct pcmcia_device *link)
 138 {
 139     DEBUG(0, "ide_detach(0x%p)\n", link);
 140
 141     ide_release(link);
 142
 143     kfree(link->priv);
 144 } /* ide_detach */
 145
 146 static int idecs_register(unsigned long io, unsigned long ctl, unsigned long irq, struct pcmcia_device *handle)
 147 {
 148     hw_regs_t hw;
 149     memset(&hw, 0, sizeof(hw));
 150     ide_init_hwif_ports(&hw, io, ctl, NULL);
 151     hw.irq = irq;
 152     hw.chipset = ide_pci;
 153     hw.dev = &handle->dev;
 154     return ide_register_hw(&hw, &ide_undecoded_slave, NULL);
 155 }
 156
 157 /*======================================================================
 158
 159     ide_config() is scheduled to run after a CARD_INSERTION event
 160     is received, to configure the PCMCIA socket, and to make the
 161     ide device available to the system.
 162
 163 ======================================================================*/
 164
 165 #define CS_CHECK(fn, ret) \
 166 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 167
 168 static int ide_config(struct pcmcia_device *link)
 169 {
 170     ide_info_t *info = link->priv;
 171     tuple_t tuple;
 172     struct {
 173         u_short         buf[128];
 174         cisparse_t      parse;
 175         config_info_t   conf;
 176         cistpl_cftable_entry_t dflt;
 177     } *stk = NULL;
 178     cistpl_cftable_entry_t *cfg;
 179     int i, pass, last_ret = 0, last_fn = 0, hd, is_kme = 0;
 180     unsigned long io_base, ctl_base;
 181
 182     DEBUG(0, "ide_config(0x%p)\n", link);
 183
 184     stk = kzalloc(sizeof(*stk), GFP_KERNEL);
 185     if (!stk) goto err_mem;
 186     cfg = &stk->parse.cftable_entry;
 187
 188     tuple.TupleData = (cisdata_t *)&stk->buf;
 189     tuple.TupleOffset = 0;
 190     tuple.TupleDataMax = 255;
 191     tuple.Attributes = 0;
 192
 193     is_kme = ((link->manf_id == MANFID_KME) &&
 194               ((link->card_id == PRODID_KME_KXLC005_A) ||
 195                (link->card_id == PRODID_KME_KXLC005_B)));
 196
 197     /* Not sure if this is right... look up the current Vcc */
 198     CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));
 199
 200     pass = io_base = ctl_base = 0;
 201     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 202     tuple.Attributes = 0;
 203     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 204     while (1) {
 205         if (pcmcia_get_tuple_data(link, &tuple) != 0) goto next_entry;
 206         if (pcmcia_parse_tuple(link, &tuple, &stk->parse) != 0) goto next_entry;
 207
 208         /* Check for matching Vcc, unless we're desperate */
 209         if (!pass) {
 210             if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 211                 if (stk->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
 212                     goto next_entry;
 213             } else if (stk->dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
 214                 if (stk->conf.Vcc != stk->dflt.vcc.param[CISTPL_POWER_VNOM] / 10000)
 215                     goto next_entry;
 216             }
 217         }
 218
 219         if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
 220             link->conf.Vpp =
 221                 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 222         else if (stk->dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
 223             link->conf.Vpp =
 224                 stk->dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
 225
 226         if ((cfg->io.nwin > 0) || (stk->dflt.io.nwin > 0)) {
 227             cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &stk->dflt.io;
 228             link->conf.ConfigIndex = cfg->index;
 229             link->io.BasePort1 = io->win[0].base;
 230             link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
 231             if (!(io->flags & CISTPL_IO_16BIT))
 232                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 233             if (io->nwin == 2) {
 234                 link->io.NumPorts1 = 8;
 235                 link->io.BasePort2 = io->win[1].base;
 236                 link->io.NumPorts2 = (is_kme) ? 2 : 1;
 237                 if (pcmcia_request_io(link, &link->io) != 0)
 238                         goto next_entry;
 239                 io_base = link->io.BasePort1;
 240                 ctl_base = link->io.BasePort2;
 241             } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
 242                 link->io.NumPorts1 = io->win[0].len;
 243                 link->io.NumPorts2 = 0;
 244                 if (pcmcia_request_io(link, &link->io) != 0)
 245                         goto next_entry;
 246                 io_base = link->io.BasePort1;
 247                 ctl_base = link->io.BasePort1 + 0x0e;
 248             } else goto next_entry;
 249             /* If we've got this far, we're done */
 250             break;
 251         }
 252
 253     next_entry:
 254         if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
 255             memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
 256         if (pass) {
 257             CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
 258         } else if (pcmcia_get_next_tuple(link, &tuple) != 0) {
 259             CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 260             memset(&stk->dflt, 0, sizeof(stk->dflt));
 261             pass++;
 262         }
 263     }
 264
 265     CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
 266     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
 267
 268     /* disable drive interrupts during IDE probe */
 269     outb(0x02, ctl_base);
 270
 271     /* special setup for KXLC005 card */
 272     if (is_kme)
 273         outb(0x81, ctl_base+1);
 274
 275     /* retry registration in case device is still spinning up */
 276     for (hd = -1, i = 0; i < 10; i++) {
 277         hd = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
 278         if (hd >= 0) break;
 279         if (link->io.NumPorts1 == 0x20) {
 280             outb(0x02, ctl_base + 0x10);
 281             hd = idecs_register(io_base + 0x10, ctl_base + 0x10,
 282                                 link->irq.AssignedIRQ, link);
 283             if (hd >= 0) {
 284                 io_base += 0x10;
 285                 ctl_base += 0x10;
 286                 break;
 287             }
 288         }
 289         msleep(100);
 290     }
 291
 292     if (hd < 0) {
 293         printk(KERN_NOTICE "ide-cs: ide_register() at 0x%3lx & 0x%3lx"
 294                ", irq %u failed\n", io_base, ctl_base,
 295                link->irq.AssignedIRQ);
 296         goto failed;
 297     }
 298
 299     info->ndev = 1;
 300     sprintf(info->node.dev_name, "hd%c", 'a' + (hd * 2));
 301     info->node.major = ide_major[hd];
 302     info->node.minor = 0;
 303     info->hd = hd;
 304     link->dev_node = &info->node;
 305     printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
 306            info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
 307
 308     kfree(stk);
 309     return 0;
 310
 311 err_mem:
 312     printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
 313     goto failed;
 314
 315 cs_failed:
 316     cs_error(link, last_fn, last_ret);
 317 failed:
 318     kfree(stk);
 319     ide_release(link);
 320     return -ENODEV;
 321 } /* ide_config */
 322
 323 /*======================================================================
 324
 325     After a card is removed, ide_release() will unregister the net
 326     device, and release the PCMCIA configuration.  If the device is
 327     still open, this will be postponed until it is closed.
 328
 329 ======================================================================*/
 330
 331 void ide_release(struct pcmcia_device *link)
 332 {
 333     ide_info_t *info = link->priv;
 334
 335     DEBUG(0, "ide_release(0x%p)\n", link);
 336
 337     if (info->ndev) {
 338         /* FIXME: if this fails we need to queue the cleanup somehow
 339            -- need to investigate the required PCMCIA magic */
 340         ide_unregister(info->hd);
 341     }
 342     info->ndev = 0;
 343
 344     pcmcia_disable_device(link);
 345 } /* ide_release */
 346
 347
 348 /*======================================================================
 349
 350     The card status event handler.  Mostly, this schedules other
 351     stuff to run after an event is received.  A CARD_REMOVAL event
 352     also sets some flags to discourage the ide drivers from
 353     talking to the ports.
 354
 355 ======================================================================*/
 356
 357 static struct pcmcia_device_id ide_ids[] = {
 358         PCMCIA_DEVICE_FUNC_ID(4),
 359         PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),        /* Corsair */
 360         PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),        /* Hitachi */
 361         PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),        /* I-O Data CFA */
 362         PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),        /* Mitsubishi CFA */
 363         PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
 364         PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),        /* SanDisk CFA */
 365         PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000),        /* Toshiba */
 366         PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
 367         PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000),        /* Samsung */
 368         PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000),        /* Hitachi */
 369         PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
 370         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100),        /* Viking CFA */
 371         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),        /* Lexar, Viking CFA */
 372         PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
 373         PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
 374         PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
 375         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
 376         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
 377         PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
 378         PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
 379         PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
 380         PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
 381         PCMCIA_DEVICE_PROD_ID12("EXP   ", "CD-ROM", 0x0a5c52fd, 0x66536591),
 382         PCMCIA_DEVICE_PROD_ID12("EXP   ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
 383         PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
 384         PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
 385         PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
 386         PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
 387         PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
 388         PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
 389         PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
 390         PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
 391         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
 392         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
 393         PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2      ", 0xe37be2b5, 0x8671043b),
 394         PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
 395         PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
 396         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
 397         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
 398         PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
 399         PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
 400         PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
 401         PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
 402         PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
 403         PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
 404         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
 405         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
 406         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
 407         PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
 408         PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
 409         PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
 410         PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
 411         PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
 412         PCMCIA_DEVICE_NULL,
 413 };
 414 MODULE_DEVICE_TABLE(pcmcia, ide_ids);
 415
 416 static struct pcmcia_driver ide_cs_driver = {
 417         .owner          = THIS_MODULE,
 418         .drv            = {
 419                 .name   = "ide-cs",
 420         },
 421         .probe          = ide_probe,
 422         .remove         = ide_detach,
 423         .id_table       = ide_ids,
 424 };
 425
 426 static int __init init_ide_cs(void)
 427 {
 428         return pcmcia_register_driver(&ide_cs_driver);
 429 }
 430
 431 static void __exit exit_ide_cs(void)
 432 {
 433         pcmcia_unregister_driver(&ide_cs_driver);
 434 }
 435
 436 late_initcall(init_ide_cs);
 437 module_exit(exit_ide_cs);