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