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->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
 106     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 107     link->conf.Attributes = CONF_ENABLE_IRQ;
 108     link->conf.IntType = INT_MEMORY_AND_IO;
 109
 110     return ide_config(link);
 111 } /* ide_attach */
 112
 113 /*======================================================================
 114
 115     This deletes a driver "instance".  The device is de-registered
 116     with Card Services.  If it has been released, all local data
 117     structures are freed.  Otherwise, the structures will be freed
 118     when the device is released.
 119
 120 ======================================================================*/
 121
 122 static void ide_detach(struct pcmcia_device *link)
 123 {
 124     ide_info_t *info = link->priv;
 125     ide_hwif_t *hwif = info->host->ports[0];
 126     unsigned long data_addr, ctl_addr;
 127
 128     dev_dbg(&link->dev, "ide_detach(0x%p)\n", link);
 129
 130     data_addr = hwif->io_ports.data_addr;
 131     ctl_addr  = hwif->io_ports.ctl_addr;
 132
 133     ide_release(link);
 134
 135     release_region(ctl_addr, 1);
 136     release_region(data_addr, 8);
 137
 138     kfree(info);
 139 } /* ide_detach */
 140
 141 static const struct ide_port_ops idecs_port_ops = {
 142         .quirkproc              = ide_undecoded_slave,
 143 };
 144
 145 static const struct ide_port_info idecs_port_info = {
 146         .port_ops               = &idecs_port_ops,
 147         .host_flags             = IDE_HFLAG_NO_DMA,
 148         .irq_flags              = IRQF_SHARED,
 149         .chipset                = ide_pci,
 150 };
 151
 152 static struct ide_host *idecs_register(unsigned long io, unsigned long ctl,
 153                                 unsigned long irq, struct pcmcia_device *handle)
 154 {
 155     struct ide_host *host;
 156     ide_hwif_t *hwif;
 157     int i, rc;
 158     struct ide_hw hw, *hws[] = { &hw };
 159
 160     if (!request_region(io, 8, DRV_NAME)) {
 161         printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
 162                         DRV_NAME, io, io + 7);
 163         return NULL;
 164     }
 165
 166     if (!request_region(ctl, 1, DRV_NAME)) {
 167         printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
 168                         DRV_NAME, ctl);
 169         release_region(io, 8);
 170         return NULL;
 171     }
 172
 173     memset(&hw, 0, sizeof(hw));
 174     ide_std_init_ports(&hw, io, ctl);
 175     hw.irq = irq;
 176     hw.dev = &handle->dev;
 177
 178     rc = ide_host_add(&idecs_port_info, hws, 1, &host);
 179     if (rc)
 180         goto out_release;
 181
 182     hwif = host->ports[0];
 183
 184     if (hwif->present)
 185         return host;
 186
 187     /* retry registration in case device is still spinning up */
 188     for (i = 0; i < 10; i++) {
 189         msleep(100);
 190         ide_port_scan(hwif);
 191         if (hwif->present)
 192             return host;
 193     }
 194
 195     return host;
 196
 197 out_release:
 198     release_region(ctl, 1);
 199     release_region(io, 8);
 200     return NULL;
 201 }
 202
 203 /*======================================================================
 204
 205     ide_config() is scheduled to run after a CARD_INSERTION event
 206     is received, to configure the PCMCIA socket, and to make the
 207     ide device available to the system.
 208
 209 ======================================================================*/
 210
 211 struct pcmcia_config_check {
 212         unsigned long ctl_base;
 213         int skip_vcc;
 214         int is_kme;
 215 };
 216
 217 static int pcmcia_check_one_config(struct pcmcia_device *pdev,
 218                                    cistpl_cftable_entry_t *cfg,
 219                                    cistpl_cftable_entry_t *dflt,
 220                                    unsigned int vcc,
 221                                    void *priv_data)
 222 {
 223         struct pcmcia_config_check *stk = priv_data;
 224
 225         /* Check for matching Vcc, unless we're desperate */
 226         if (!stk->skip_vcc) {
 227                 if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 228                         if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
 229                                 return -ENODEV;
 230                 } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 231                         if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
 232                                 return -ENODEV;
 233                 }
 234         }
 235
 236         if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
 237                 pdev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 238         else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
 239                 pdev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 240
 241         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
 242                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
 243                 pdev->conf.ConfigIndex = cfg->index;
 244                 pdev->io.BasePort1 = io->win[0].base;
 245                 pdev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
 246                 if (!(io->flags & CISTPL_IO_16BIT))
 247                         pdev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 248                 if (io->nwin == 2) {
 249                         pdev->io.NumPorts1 = 8;
 250                         pdev->io.BasePort2 = io->win[1].base;
 251                         pdev->io.NumPorts2 = (stk->is_kme) ? 2 : 1;
 252                         if (pcmcia_request_io(pdev, &pdev->io) != 0)
 253                                 return -ENODEV;
 254                         stk->ctl_base = pdev->io.BasePort2;
 255                 } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
 256                         pdev->io.NumPorts1 = io->win[0].len;
 257                         pdev->io.NumPorts2 = 0;
 258                         if (pcmcia_request_io(pdev, &pdev->io) != 0)
 259                                 return -ENODEV;
 260                         stk->ctl_base = pdev->io.BasePort1 + 0x0e;
 261                 } else
 262                         return -ENODEV;
 263                 /* If we've got this far, we're done */
 264                 return 0;
 265         }
 266         return -ENODEV;
 267 }
 268
 269 static int ide_config(struct pcmcia_device *link)
 270 {
 271     ide_info_t *info = link->priv;
 272     struct pcmcia_config_check *stk = NULL;
 273     int ret = 0, is_kme = 0;
 274     unsigned long io_base, ctl_base;
 275     struct ide_host *host;
 276
 277     dev_dbg(&link->dev, "ide_config(0x%p)\n", link);
 278
 279     is_kme = ((link->manf_id == MANFID_KME) &&
 280               ((link->card_id == PRODID_KME_KXLC005_A) ||
 281                (link->card_id == PRODID_KME_KXLC005_B)));
 282
 283     stk = kzalloc(sizeof(*stk), GFP_KERNEL);
 284     if (!stk)
 285             goto err_mem;
 286     stk->is_kme = is_kme;
 287     stk->skip_vcc = io_base = ctl_base = 0;
 288
 289     if (pcmcia_loop_config(link, pcmcia_check_one_config, stk)) {
 290             stk->skip_vcc = 1;
 291             if (pcmcia_loop_config(link, pcmcia_check_one_config, stk))
 292                     goto failed; /* No suitable config found */
 293     }
 294     io_base = link->io.BasePort1;
 295     ctl_base = stk->ctl_base;
 296
 297     ret = pcmcia_request_irq(link, &link->irq);
 298     if (ret)
 299             goto failed;
 300     ret = pcmcia_request_configuration(link, &link->conf);
 301     if (ret)
 302             goto failed;
 303
 304     /* disable drive interrupts during IDE probe */
 305     outb(0x02, ctl_base);
 306
 307     /* special setup for KXLC005 card */
 308     if (is_kme)
 309         outb(0x81, ctl_base+1);
 310
 311      host = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
 312      if (host == NULL && link->io.NumPorts1 == 0x20) {
 313             outb(0x02, ctl_base + 0x10);
 314             host = idecs_register(io_base + 0x10, ctl_base + 0x10,
 315                                   link->irq.AssignedIRQ, link);
 316     }
 317
 318     if (host == NULL)
 319         goto failed;
 320
 321     info->ndev = 1;
 322     sprintf(info->node.dev_name, "hd%c", 'a' + host->ports[0]->index * 2);
 323     info->node.major = host->ports[0]->major;
 324     info->node.minor = 0;
 325     info->host = host;
 326     link->dev_node = &info->node;
 327     printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
 328            info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
 329
 330     kfree(stk);
 331     return 0;
 332
 333 err_mem:
 334     printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
 335     goto failed;
 336
 337 failed:
 338     kfree(stk);
 339     ide_release(link);
 340     return -ENODEV;
 341 } /* ide_config */
 342
 343 /*======================================================================
 344
 345     After a card is removed, ide_release() will unregister the net
 346     device, and release the PCMCIA configuration.  If the device is
 347     still open, this will be postponed until it is closed.
 348
 349 ======================================================================*/
 350
 351 static void ide_release(struct pcmcia_device *link)
 352 {
 353     ide_info_t *info = link->priv;
 354     struct ide_host *host = info->host;
 355
 356     dev_dbg(&link->dev, "ide_release(0x%p)\n", link);
 357
 358     if (info->ndev)
 359         /* FIXME: if this fails we need to queue the cleanup somehow
 360            -- need to investigate the required PCMCIA magic */
 361         ide_host_remove(host);
 362
 363     info->ndev = 0;
 364
 365     pcmcia_disable_device(link);
 366 } /* ide_release */
 367
 368
 369 /*======================================================================
 370
 371     The card status event handler.  Mostly, this schedules other
 372     stuff to run after an event is received.  A CARD_REMOVAL event
 373     also sets some flags to discourage the ide drivers from
 374     talking to the ports.
 375
 376 ======================================================================*/
 377
 378 static struct pcmcia_device_id ide_ids[] = {
 379         PCMCIA_DEVICE_FUNC_ID(4),
 380         PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),        /* Corsair */
 381         PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),        /* Hitachi */
 382         PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),        /* I-O Data CFA */
 383         PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),        /* Mitsubishi CFA */
 384         PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
 385         PCMCIA_DEVICE_MANF_CARD(0x0032, 0x2904),
 386         PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),        /* SanDisk CFA */
 387         PCMCIA_DEVICE_MANF_CARD(0x004f, 0x0000),        /* Kingston */
 388         PCMCIA_DEVICE_MANF_CARD(0x0097, 0x1620),        /* TI emulated */
 389         PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000),        /* Toshiba */
 390         PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
 391         PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000),        /* Samsung */
 392         PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000),        /* Hitachi */
 393         PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
 394         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100),        /* Viking CFA */
 395         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),        /* Lexar, Viking CFA */
 396         PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
 397         PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
 398         PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
 399         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
 400         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
 401         PCMCIA_DEVICE_PROD_ID12("CNF   ", "CD-ROM", 0x46d7db81, 0x66536591),
 402         PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
 403         PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
 404         PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
 405         PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
 406         PCMCIA_DEVICE_PROD_ID12("EXP   ", "CD-ROM", 0x0a5c52fd, 0x66536591),
 407         PCMCIA_DEVICE_PROD_ID12("EXP   ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
 408         PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
 409         PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
 410         PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
 411         PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
 412         PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
 413         PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
 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("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);