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