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