pcmcia: do not use io_req_t after call to pcmcia_request_io()
[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/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);