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