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