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