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