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