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