Pileus Git - ~andy/linux/blob - drivers/ide/legacy/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/hdreg.h>
  42 #include <linux/major.h>
  43 #include <linux/delay.h>
  44 #include <asm/io.h>
  45 #include <asm/system.h>
  46
  47 #include <pcmcia/cs_types.h>
  48 #include <pcmcia/cs.h>
  49 #include <pcmcia/cistpl.h>
  50 #include <pcmcia/ds.h>
  51 #include <pcmcia/cisreg.h>
  52 #include <pcmcia/ciscode.h>
  53
  54 #define DRV_NAME "ide-cs"
  55
  56 /*====================================================================*/
  57
  58 /* Module parameters */
  59
  60 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  61 MODULE_DESCRIPTION("PCMCIA ATA/IDE card driver");
  62 MODULE_LICENSE("Dual MPL/GPL");
  63
  64 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  65
  66 #ifdef PCMCIA_DEBUG
  67 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
  68 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  69 static char *version =
  70 "ide-cs.c 1.3 2002/10/26 05:45:31 (David Hinds)";
  71 #else
  72 #define DEBUG(n, args...)
  73 #endif
  74
  75 /*====================================================================*/
  76
  77 typedef struct ide_info_t {
  78         struct pcmcia_device    *p_dev;
  79         ide_hwif_t              *hwif;
  80     int         ndev;
  81     dev_node_t  node;
  82 } ide_info_t;
  83
  84 static void ide_release(struct pcmcia_device *);
  85 static int ide_config(struct pcmcia_device *);
  86
  87 static void ide_detach(struct pcmcia_device *p_dev);
  88
  89
  90
  91
  92 /*======================================================================
  93
  94     ide_attach() creates an "instance" of the driver, allocating
  95     local data structures for one device.  The device is registered
  96     with Card Services.
  97
  98 ======================================================================*/
  99
 100 static int ide_probe(struct pcmcia_device *link)
 101 {
 102     ide_info_t *info;
 103
 104     DEBUG(0, "ide_attach()\n");
 105
 106     /* Create new ide device */
 107     info = kzalloc(sizeof(*info), GFP_KERNEL);
 108     if (!info)
 109         return -ENOMEM;
 110
 111     info->p_dev = link;
 112     link->priv = info;
 113
 114     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 115     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
 116     link->io.IOAddrLines = 3;
 117     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
 118     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 119     link->conf.Attributes = CONF_ENABLE_IRQ;
 120     link->conf.IntType = INT_MEMORY_AND_IO;
 121
 122     return ide_config(link);
 123 } /* ide_attach */
 124
 125 /*======================================================================
 126
 127     This deletes a driver "instance".  The device is de-registered
 128     with Card Services.  If it has been released, all local data
 129     structures are freed.  Otherwise, the structures will be freed
 130     when the device is released.
 131
 132 ======================================================================*/
 133
 134 static void ide_detach(struct pcmcia_device *link)
 135 {
 136     ide_info_t *info = link->priv;
 137     ide_hwif_t *hwif = info->hwif;
 138
 139     DEBUG(0, "ide_detach(0x%p)\n", link);
 140
 141     ide_release(link);
 142
 143     release_region(hwif->io_ports[IDE_CONTROL_OFFSET], 1);
 144     release_region(hwif->io_ports[IDE_DATA_OFFSET], 8);
 145
 146     kfree(info);
 147 } /* ide_detach */
 148
 149 static const struct ide_port_ops idecs_port_ops = {
 150         .quirkproc              = ide_undecoded_slave,
 151 };
 152
 153 static ide_hwif_t *idecs_register(unsigned long io, unsigned long ctl,
 154                                 unsigned long irq, struct pcmcia_device *handle)
 155 {
 156     ide_hwif_t *hwif;
 157     hw_regs_t hw;
 158     int i;
 159     u8 idx[4] = { 0xff, 0xff, 0xff, 0xff };
 160
 161     if (!request_region(io, 8, DRV_NAME)) {
 162         printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX not free.\n",
 163                         DRV_NAME, io, io + 7);
 164         return NULL;
 165     }
 166
 167     if (!request_region(ctl, 1, DRV_NAME)) {
 168         printk(KERN_ERR "%s: I/O resource 0x%lX not free.\n",
 169                         DRV_NAME, ctl);
 170         release_region(io, 8);
 171         return NULL;
 172     }
 173
 174     memset(&hw, 0, sizeof(hw));
 175     ide_std_init_ports(&hw, io, ctl);
 176     hw.irq = irq;
 177     hw.chipset = ide_pci;
 178     hw.dev = &handle->dev;
 179
 180     hwif = ide_find_port();
 181     if (hwif == NULL)
 182         goto out_release;
 183
 184     i = hwif->index;
 185
 186     if (hwif->present)
 187         ide_unregister(i);
 188     else
 189         ide_init_port_data(hwif, i);
 190
 191     ide_init_port_hw(hwif, &hw);
 192     hwif->port_ops = &idecs_port_ops;
 193
 194     idx[0] = i;
 195
 196     ide_device_add(idx, NULL);
 197
 198     if (hwif->present)
 199         return hwif;
 200
 201 out_release:
 202     release_region(ctl, 1);
 203     release_region(io, 8);
 204     return NULL;
 205 }
 206
 207 /*======================================================================
 208
 209     ide_config() is scheduled to run after a CARD_INSERTION event
 210     is received, to configure the PCMCIA socket, and to make the
 211     ide device available to the system.
 212
 213 ======================================================================*/
 214
 215 #define CS_CHECK(fn, ret) \
 216 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 217
 218 static int ide_config(struct pcmcia_device *link)
 219 {
 220     ide_info_t *info = link->priv;
 221     tuple_t tuple;
 222     struct {
 223         u_short         buf[128];
 224         cisparse_t      parse;
 225         config_info_t   conf;
 226         cistpl_cftable_entry_t dflt;
 227     } *stk = NULL;
 228     cistpl_cftable_entry_t *cfg;
 229     int i, pass, last_ret = 0, last_fn = 0, is_kme = 0;
 230     unsigned long io_base, ctl_base;
 231     ide_hwif_t *hwif;
 232
 233     DEBUG(0, "ide_config(0x%p)\n", link);
 234
 235     stk = kzalloc(sizeof(*stk), GFP_KERNEL);
 236     if (!stk) goto err_mem;
 237     cfg = &stk->parse.cftable_entry;
 238
 239     tuple.TupleData = (cisdata_t *)&stk->buf;
 240     tuple.TupleOffset = 0;
 241     tuple.TupleDataMax = 255;
 242     tuple.Attributes = 0;
 243
 244     is_kme = ((link->manf_id == MANFID_KME) &&
 245               ((link->card_id == PRODID_KME_KXLC005_A) ||
 246                (link->card_id == PRODID_KME_KXLC005_B)));
 247
 248     /* Not sure if this is right... look up the current Vcc */
 249     CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));
 250
 251     pass = io_base = ctl_base = 0;
 252     tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 253     tuple.Attributes = 0;
 254     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 255     while (1) {
 256         if (pcmcia_get_tuple_data(link, &tuple) != 0) goto next_entry;
 257         if (pcmcia_parse_tuple(link, &tuple, &stk->parse) != 0) goto next_entry;
 258
 259         /* Check for matching Vcc, unless we're desperate */
 260         if (!pass) {
 261             if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 262                 if (stk->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
 263                     goto next_entry;
 264             } else if (stk->dflt.vcc.present & (1 << CISTPL_POWER_VNOM)) {
 265                 if (stk->conf.Vcc != stk->dflt.vcc.param[CISTPL_POWER_VNOM] / 10000)
 266                     goto next_entry;
 267             }
 268         }
 269
 270         if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
 271             link->conf.Vpp =
 272                 cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 273         else if (stk->dflt.vpp1.present & (1 << CISTPL_POWER_VNOM))
 274             link->conf.Vpp =
 275                 stk->dflt.vpp1.param[CISTPL_POWER_VNOM] / 10000;
 276
 277         if ((cfg->io.nwin > 0) || (stk->dflt.io.nwin > 0)) {
 278             cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &stk->dflt.io;
 279             link->conf.ConfigIndex = cfg->index;
 280             link->io.BasePort1 = io->win[0].base;
 281             link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
 282             if (!(io->flags & CISTPL_IO_16BIT))
 283                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 284             if (io->nwin == 2) {
 285                 link->io.NumPorts1 = 8;
 286                 link->io.BasePort2 = io->win[1].base;
 287                 link->io.NumPorts2 = (is_kme) ? 2 : 1;
 288                 if (pcmcia_request_io(link, &link->io) != 0)
 289                         goto next_entry;
 290                 io_base = link->io.BasePort1;
 291                 ctl_base = link->io.BasePort2;
 292             } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
 293                 link->io.NumPorts1 = io->win[0].len;
 294                 link->io.NumPorts2 = 0;
 295                 if (pcmcia_request_io(link, &link->io) != 0)
 296                         goto next_entry;
 297                 io_base = link->io.BasePort1;
 298                 ctl_base = link->io.BasePort1 + 0x0e;
 299             } else goto next_entry;
 300             /* If we've got this far, we're done */
 301             break;
 302         }
 303
 304     next_entry:
 305         if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
 306             memcpy(&stk->dflt, cfg, sizeof(stk->dflt));
 307         if (pass) {
 308             CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
 309         } else if (pcmcia_get_next_tuple(link, &tuple) != 0) {
 310             CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 311             memset(&stk->dflt, 0, sizeof(stk->dflt));
 312             pass++;
 313         }
 314     }
 315
 316     CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
 317     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
 318
 319     /* disable drive interrupts during IDE probe */
 320     outb(0x02, ctl_base);
 321
 322     /* special setup for KXLC005 card */
 323     if (is_kme)
 324         outb(0x81, ctl_base+1);
 325
 326     /* retry registration in case device is still spinning up */
 327     for (i = 0; i < 10; i++) {
 328         hwif = idecs_register(io_base, ctl_base, link->irq.AssignedIRQ, link);
 329         if (hwif)
 330             break;
 331         if (link->io.NumPorts1 == 0x20) {
 332             outb(0x02, ctl_base + 0x10);
 333             hwif = idecs_register(io_base + 0x10, ctl_base + 0x10,
 334                                   link->irq.AssignedIRQ, link);
 335             if (hwif) {
 336                 io_base += 0x10;
 337                 ctl_base += 0x10;
 338                 break;
 339             }
 340         }
 341         msleep(100);
 342     }
 343
 344     if (hwif == NULL) {
 345         printk(KERN_NOTICE "ide-cs: ide_register() at 0x%3lx & 0x%3lx"
 346                ", irq %u failed\n", io_base, ctl_base,
 347                link->irq.AssignedIRQ);
 348         goto failed;
 349     }
 350
 351     info->ndev = 1;
 352     sprintf(info->node.dev_name, "hd%c", 'a' + hwif->index * 2);
 353     info->node.major = hwif->major;
 354     info->node.minor = 0;
 355     info->hwif = hwif;
 356     link->dev_node = &info->node;
 357     printk(KERN_INFO "ide-cs: %s: Vpp = %d.%d\n",
 358            info->node.dev_name, link->conf.Vpp / 10, link->conf.Vpp % 10);
 359
 360     kfree(stk);
 361     return 0;
 362
 363 err_mem:
 364     printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
 365     goto failed;
 366
 367 cs_failed:
 368     cs_error(link, last_fn, last_ret);
 369 failed:
 370     kfree(stk);
 371     ide_release(link);
 372     return -ENODEV;
 373 } /* ide_config */
 374
 375 /*======================================================================
 376
 377     After a card is removed, ide_release() will unregister the net
 378     device, and release the PCMCIA configuration.  If the device is
 379     still open, this will be postponed until it is closed.
 380
 381 ======================================================================*/
 382
 383 void ide_release(struct pcmcia_device *link)
 384 {
 385     ide_info_t *info = link->priv;
 386     ide_hwif_t *hwif = info->hwif;
 387
 388     DEBUG(0, "ide_release(0x%p)\n", link);
 389
 390     if (info->ndev) {
 391         /* FIXME: if this fails we need to queue the cleanup somehow
 392            -- need to investigate the required PCMCIA magic */
 393         ide_unregister(hwif->index);
 394     }
 395     info->ndev = 0;
 396
 397     pcmcia_disable_device(link);
 398 } /* ide_release */
 399
 400
 401 /*======================================================================
 402
 403     The card status event handler.  Mostly, this schedules other
 404     stuff to run after an event is received.  A CARD_REMOVAL event
 405     also sets some flags to discourage the ide drivers from
 406     talking to the ports.
 407
 408 ======================================================================*/
 409
 410 static struct pcmcia_device_id ide_ids[] = {
 411         PCMCIA_DEVICE_FUNC_ID(4),
 412         PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),        /* Corsair */
 413         PCMCIA_DEVICE_MANF_CARD(0x0007, 0x0000),        /* Hitachi */
 414         PCMCIA_DEVICE_MANF_CARD(0x000a, 0x0000),        /* I-O Data CFA */
 415         PCMCIA_DEVICE_MANF_CARD(0x001c, 0x0001),        /* Mitsubishi CFA */
 416         PCMCIA_DEVICE_MANF_CARD(0x0032, 0x0704),
 417         PCMCIA_DEVICE_MANF_CARD(0x0045, 0x0401),        /* SanDisk CFA */
 418         PCMCIA_DEVICE_MANF_CARD(0x0098, 0x0000),        /* Toshiba */
 419         PCMCIA_DEVICE_MANF_CARD(0x00a4, 0x002d),
 420         PCMCIA_DEVICE_MANF_CARD(0x00ce, 0x0000),        /* Samsung */
 421         PCMCIA_DEVICE_MANF_CARD(0x0319, 0x0000),        /* Hitachi */
 422         PCMCIA_DEVICE_MANF_CARD(0x2080, 0x0001),
 423         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0100),        /* Viking CFA */
 424         PCMCIA_DEVICE_MANF_CARD(0x4e01, 0x0200),        /* Lexar, Viking CFA */
 425         PCMCIA_DEVICE_PROD_ID123("Caravelle", "PSC-IDE ", "PSC000", 0x8c36137c, 0xd0693ab8, 0x2768a9f0),
 426         PCMCIA_DEVICE_PROD_ID123("CDROM", "IDE", "MCD-601p", 0x1b9179ca, 0xede88951, 0x0d902f74),
 427         PCMCIA_DEVICE_PROD_ID123("PCMCIA", "IDE CARD", "F1", 0x281f1c5d, 0x1907960c, 0xf7fde8b9),
 428         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "CD-ROM", 0x78f308dc, 0x66536591),
 429         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "PnPIDE", 0x78f308dc, 0x0c694728),
 430         PCMCIA_DEVICE_PROD_ID12("CNF CD-M", "CD-ROM", 0x7d93b852, 0x66536591),
 431         PCMCIA_DEVICE_PROD_ID12("Creative Technology Ltd.", "PCMCIA CD-ROM Interface Card", 0xff8c8a45, 0xfe8020c4),
 432         PCMCIA_DEVICE_PROD_ID12("Digital Equipment Corporation.", "Digital Mobile Media CD-ROM", 0x17692a66, 0xef1dcbde),
 433         PCMCIA_DEVICE_PROD_ID12("EXP", "CD+GAME", 0x6f58c983, 0x63c13aaf),
 434         PCMCIA_DEVICE_PROD_ID12("EXP   ", "CD-ROM", 0x0a5c52fd, 0x66536591),
 435         PCMCIA_DEVICE_PROD_ID12("EXP   ", "PnPIDE", 0x0a5c52fd, 0x0c694728),
 436         PCMCIA_DEVICE_PROD_ID12("FREECOM", "PCCARD-IDE", 0x5714cbf7, 0x48e0ab8e),
 437         PCMCIA_DEVICE_PROD_ID12("HITACHI", "FLASH", 0xf4f43949, 0x9eb86aae),
 438         PCMCIA_DEVICE_PROD_ID12("HITACHI", "microdrive", 0xf4f43949, 0xa6d76178),
 439         PCMCIA_DEVICE_PROD_ID12("Hyperstone", "Model1", 0x3d5b9ef5, 0xca6ab420),
 440         PCMCIA_DEVICE_PROD_ID12("IBM", "microdrive", 0xb569a6e5, 0xa6d76178),
 441         PCMCIA_DEVICE_PROD_ID12("IBM", "IBM17JSSFP20", 0xb569a6e5, 0xf2508753),
 442         PCMCIA_DEVICE_PROD_ID12("KINGSTON", "CF8GB", 0x2e6d1829, 0xacbe682e),
 443         PCMCIA_DEVICE_PROD_ID12("IO DATA", "CBIDE2      ", 0x547e66dc, 0x8671043b),
 444         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDE", 0x547e66dc, 0x5c5ab149),
 445         PCMCIA_DEVICE_PROD_ID12("IO DATA", "PCIDEII", 0x547e66dc, 0xb3662674),
 446         PCMCIA_DEVICE_PROD_ID12("LOOKMEET", "CBIDE2      ", 0xe37be2b5, 0x8671043b),
 447         PCMCIA_DEVICE_PROD_ID12("M-Systems", "CF500", 0x7ed2ad87, 0x7a13045c),
 448         PCMCIA_DEVICE_PROD_ID2("NinjaATA-", 0xebe0bd79),
 449         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "CD-ROM", 0x281f1c5d, 0x66536591),
 450         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "PnPIDE", 0x281f1c5d, 0x0c694728),
 451         PCMCIA_DEVICE_PROD_ID12("SHUTTLE TECHNOLOGY LTD.", "PCCARD-IDE/ATAPI Adapter", 0x4a3f0ba0, 0x322560e1),
 452         PCMCIA_DEVICE_PROD_ID12("SEAGATE", "ST1", 0x87c1b330, 0xe1f30883),
 453         PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
 454         PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
 455         PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
 456         PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
 457         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS1GCF80", 0x709b1bf1, 0x2a54d4b1),
 458         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS2GCF120", 0x709b1bf1, 0x969aa4f2),
 459         PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
 460         PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
 461         PCMCIA_DEVICE_PROD_ID12("WEIDA", "TWTTI", 0xcc7cf69c, 0x212bb918),
 462         PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
 463         PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
 464         PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
 465         PCMCIA_DEVICE_NULL,
 466 };
 467 MODULE_DEVICE_TABLE(pcmcia, ide_ids);
 468
 469 static struct pcmcia_driver ide_cs_driver = {
 470         .owner          = THIS_MODULE,
 471         .drv            = {
 472                 .name   = "ide-cs",
 473         },
 474         .probe          = ide_probe,
 475         .remove         = ide_detach,
 476         .id_table       = ide_ids,
 477 };
 478
 479 static int __init init_ide_cs(void)
 480 {
 481         return pcmcia_register_driver(&ide_cs_driver);
 482 }
 483
 484 static void __exit exit_ide_cs(void)
 485 {
 486         pcmcia_unregister_driver(&ide_cs_driver);
 487 }
 488
 489 late_initcall(init_ide_cs);
 490 module_exit(exit_ide_cs);