sata_mv: add power management support for the platform driver
[linux-2.6.git] / drivers / ata / pata_legacy.c
1 /*
2  *   pata-legacy.c - Legacy port PATA/SATA controller driver.
3  *   Copyright 2005/2006 Red Hat, all rights reserved.
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; either version 2, or (at your option)
8  *  any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; see the file COPYING.  If not, write to
17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  *   An ATA driver for the legacy ATA ports.
20  *
21  *   Data Sources:
22  *      Opti 82C465/82C611 support: Data sheets at opti-inc.com
23  *      HT6560 series:
24  *      Promise 20230/20620:
25  *              http://www.ryston.cz/petr/vlb/pdc20230b.html
26  *              http://www.ryston.cz/petr/vlb/pdc20230c.html
27  *              http://www.ryston.cz/petr/vlb/pdc20630.html
28  *      QDI65x0:
29  *              http://www.ryston.cz/petr/vlb/qd6500.html
30  *              http://www.ryston.cz/petr/vlb/qd6580.html
31  *
32  *      QDI65x0 probe code based on drivers/ide/legacy/qd65xx.c
33  *      Rewritten from the work of Colten Edwards <pje120@cs.usask.ca> by
34  *      Samuel Thibault <samuel.thibault@ens-lyon.org>
35  *
36  *  Unsupported but docs exist:
37  *      Appian/Adaptec AIC25VL01/Cirrus Logic PD7220
38  *
39  *  This driver handles legacy (that is "ISA/VLB side") IDE ports found
40  *  on PC class systems. There are three hybrid devices that are exceptions
41  *  The Cyrix 5510/5520 where a pre SFF ATA device is on the bridge and
42  *  the MPIIX where the tuning is PCI side but the IDE is "ISA side".
43  *
44  *  Specific support is included for the ht6560a/ht6560b/opti82c611a/
45  *  opti82c465mv/promise 20230c/20630/qdi65x0/winbond83759A
46  *
47  *  Use the autospeed and pio_mask options with:
48  *      Appian ADI/2 aka CLPD7220 or AIC25VL01.
49  *  Use the jumpers, autospeed and set pio_mask to the mode on the jumpers with
50  *      Goldstar GM82C711, PIC-1288A-125, UMC 82C871F, Winbond W83759,
51  *      Winbond W83759A, Promise PDC20230-B
52  *
53  *  For now use autospeed and pio_mask as above with the W83759A. This may
54  *  change.
55  *
56  */
57
58 #include <linux/async.h>
59 #include <linux/kernel.h>
60 #include <linux/module.h>
61 #include <linux/pci.h>
62 #include <linux/init.h>
63 #include <linux/blkdev.h>
64 #include <linux/delay.h>
65 #include <scsi/scsi_host.h>
66 #include <linux/ata.h>
67 #include <linux/libata.h>
68 #include <linux/platform_device.h>
69
70 #define DRV_NAME "pata_legacy"
71 #define DRV_VERSION "0.6.5"
72
73 #define NR_HOST 6
74
75 static int all;
76 module_param(all, int, 0444);
77 MODULE_PARM_DESC(all, "Grab all legacy port devices, even if PCI(0=off, 1=on)");
78
79 struct legacy_data {
80         unsigned long timing;
81         u8 clock[2];
82         u8 last;
83         int fast;
84         struct platform_device *platform_dev;
85
86 };
87
88 enum controller {
89         BIOS = 0,
90         SNOOP = 1,
91         PDC20230 = 2,
92         HT6560A = 3,
93         HT6560B = 4,
94         OPTI611A = 5,
95         OPTI46X = 6,
96         QDI6500 = 7,
97         QDI6580 = 8,
98         QDI6580DP = 9,          /* Dual channel mode is different */
99         W83759A = 10,
100
101         UNKNOWN = -1
102 };
103
104
105 struct legacy_probe {
106         unsigned char *name;
107         unsigned long port;
108         unsigned int irq;
109         unsigned int slot;
110         enum controller type;
111         unsigned long private;
112 };
113
114 struct legacy_controller {
115         const char *name;
116         struct ata_port_operations *ops;
117         unsigned int pio_mask;
118         unsigned int flags;
119         unsigned int pflags;
120         int (*setup)(struct platform_device *, struct legacy_probe *probe,
121                 struct legacy_data *data);
122 };
123
124 static int legacy_port[NR_HOST] = { 0x1f0, 0x170, 0x1e8, 0x168, 0x1e0, 0x160 };
125
126 static struct legacy_probe probe_list[NR_HOST];
127 static struct legacy_data legacy_data[NR_HOST];
128 static struct ata_host *legacy_host[NR_HOST];
129 static int nr_legacy_host;
130
131
132 static int probe_all;           /* Set to check all ISA port ranges */
133 static int ht6560a;             /* HT 6560A on primary 1, second 2, both 3 */
134 static int ht6560b;             /* HT 6560A on primary 1, second 2, both 3 */
135 static int opti82c611a;         /* Opti82c611A on primary 1, sec 2, both 3 */
136 static int opti82c46x;          /* Opti 82c465MV present(pri/sec autodetect) */
137 static int qdi;                 /* Set to probe QDI controllers */
138 static int winbond;             /* Set to probe Winbond controllers,
139                                         give I/O port if non standard */
140 static int autospeed;           /* Chip present which snoops speed changes */
141 static int pio_mask = ATA_PIO4; /* PIO range for autospeed devices */
142 static int iordy_mask = 0xFFFFFFFF;     /* Use iordy if available */
143
144 /**
145  *      legacy_probe_add        -       Add interface to probe list
146  *      @port: Controller port
147  *      @irq: IRQ number
148  *      @type: Controller type
149  *      @private: Controller specific info
150  *
151  *      Add an entry into the probe list for ATA controllers. This is used
152  *      to add the default ISA slots and then to build up the table
153  *      further according to other ISA/VLB/Weird device scans
154  *
155  *      An I/O port list is used to keep ordering stable and sane, as we
156  *      don't have any good way to talk about ordering otherwise
157  */
158
159 static int legacy_probe_add(unsigned long port, unsigned int irq,
160                                 enum controller type, unsigned long private)
161 {
162         struct legacy_probe *lp = &probe_list[0];
163         int i;
164         struct legacy_probe *free = NULL;
165
166         for (i = 0; i < NR_HOST; i++) {
167                 if (lp->port == 0 && free == NULL)
168                         free = lp;
169                 /* Matching port, or the correct slot for ordering */
170                 if (lp->port == port || legacy_port[i] == port) {
171                         free = lp;
172                         break;
173                 }
174                 lp++;
175         }
176         if (free == NULL) {
177                 printk(KERN_ERR "pata_legacy: Too many interfaces.\n");
178                 return -1;
179         }
180         /* Fill in the entry for later probing */
181         free->port = port;
182         free->irq = irq;
183         free->type = type;
184         free->private = private;
185         return 0;
186 }
187
188
189 /**
190  *      legacy_set_mode         -       mode setting
191  *      @link: IDE link
192  *      @unused: Device that failed when error is returned
193  *
194  *      Use a non standard set_mode function. We don't want to be tuned.
195  *
196  *      The BIOS configured everything. Our job is not to fiddle. Just use
197  *      whatever PIO the hardware is using and leave it at that. When we
198  *      get some kind of nice user driven API for control then we can
199  *      expand on this as per hdparm in the base kernel.
200  */
201
202 static int legacy_set_mode(struct ata_link *link, struct ata_device **unused)
203 {
204         struct ata_device *dev;
205
206         ata_for_each_dev(dev, link, ENABLED) {
207                 ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
208                 dev->pio_mode = XFER_PIO_0;
209                 dev->xfer_mode = XFER_PIO_0;
210                 dev->xfer_shift = ATA_SHIFT_PIO;
211                 dev->flags |= ATA_DFLAG_PIO;
212         }
213         return 0;
214 }
215
216 static struct scsi_host_template legacy_sht = {
217         ATA_PIO_SHT(DRV_NAME),
218 };
219
220 static const struct ata_port_operations legacy_base_port_ops = {
221         .inherits       = &ata_sff_port_ops,
222         .cable_detect   = ata_cable_40wire,
223 };
224
225 /*
226  *      These ops are used if the user indicates the hardware
227  *      snoops the commands to decide on the mode and handles the
228  *      mode selection "magically" itself. Several legacy controllers
229  *      do this. The mode range can be set if it is not 0x1F by setting
230  *      pio_mask as well.
231  */
232
233 static struct ata_port_operations simple_port_ops = {
234         .inherits       = &legacy_base_port_ops,
235         .sff_data_xfer  = ata_sff_data_xfer_noirq,
236 };
237
238 static struct ata_port_operations legacy_port_ops = {
239         .inherits       = &legacy_base_port_ops,
240         .sff_data_xfer  = ata_sff_data_xfer_noirq,
241         .set_mode       = legacy_set_mode,
242 };
243
244 /*
245  *      Promise 20230C and 20620 support
246  *
247  *      This controller supports PIO0 to PIO2. We set PIO timings
248  *      conservatively to allow for 50MHz Vesa Local Bus. The 20620 DMA
249  *      support is weird being DMA to controller and PIO'd to the host
250  *      and not supported.
251  */
252
253 static void pdc20230_set_piomode(struct ata_port *ap, struct ata_device *adev)
254 {
255         int tries = 5;
256         int pio = adev->pio_mode - XFER_PIO_0;
257         u8 rt;
258         unsigned long flags;
259
260         /* Safe as UP only. Force I/Os to occur together */
261
262         local_irq_save(flags);
263
264         /* Unlock the control interface */
265         do {
266                 inb(0x1F5);
267                 outb(inb(0x1F2) | 0x80, 0x1F2);
268                 inb(0x1F2);
269                 inb(0x3F6);
270                 inb(0x3F6);
271                 inb(0x1F2);
272                 inb(0x1F2);
273         }
274         while ((inb(0x1F2) & 0x80) && --tries);
275
276         local_irq_restore(flags);
277
278         outb(inb(0x1F4) & 0x07, 0x1F4);
279
280         rt = inb(0x1F3);
281         rt &= 0x07 << (3 * adev->devno);
282         if (pio)
283                 rt |= (1 + 3 * pio) << (3 * adev->devno);
284
285         udelay(100);
286         outb(inb(0x1F2) | 0x01, 0x1F2);
287         udelay(100);
288         inb(0x1F5);
289
290 }
291
292 static unsigned int pdc_data_xfer_vlb(struct ata_device *dev,
293                         unsigned char *buf, unsigned int buflen, int rw)
294 {
295         int slop = buflen & 3;
296         struct ata_port *ap = dev->link->ap;
297
298         /* 32bit I/O capable *and* we need to write a whole number of dwords */
299         if (ata_id_has_dword_io(dev->id) && (slop == 0 || slop == 3)
300                                         && (ap->pflags & ATA_PFLAG_PIO32)) {
301                 unsigned long flags;
302
303                 local_irq_save(flags);
304
305                 /* Perform the 32bit I/O synchronization sequence */
306                 ioread8(ap->ioaddr.nsect_addr);
307                 ioread8(ap->ioaddr.nsect_addr);
308                 ioread8(ap->ioaddr.nsect_addr);
309
310                 /* Now the data */
311                 if (rw == READ)
312                         ioread32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
313                 else
314                         iowrite32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
315
316                 if (unlikely(slop)) {
317                         __le32 pad;
318                         if (rw == READ) {
319                                 pad = cpu_to_le32(ioread32(ap->ioaddr.data_addr));
320                                 memcpy(buf + buflen - slop, &pad, slop);
321                         } else {
322                                 memcpy(&pad, buf + buflen - slop, slop);
323                                 iowrite32(le32_to_cpu(pad), ap->ioaddr.data_addr);
324                         }
325                         buflen += 4 - slop;
326                 }
327                 local_irq_restore(flags);
328         } else
329                 buflen = ata_sff_data_xfer_noirq(dev, buf, buflen, rw);
330
331         return buflen;
332 }
333
334 static struct ata_port_operations pdc20230_port_ops = {
335         .inherits       = &legacy_base_port_ops,
336         .set_piomode    = pdc20230_set_piomode,
337         .sff_data_xfer  = pdc_data_xfer_vlb,
338 };
339
340 /*
341  *      Holtek 6560A support
342  *
343  *      This controller supports PIO0 to PIO2 (no IORDY even though higher
344  *      timings can be loaded).
345  */
346
347 static void ht6560a_set_piomode(struct ata_port *ap, struct ata_device *adev)
348 {
349         u8 active, recover;
350         struct ata_timing t;
351
352         /* Get the timing data in cycles. For now play safe at 50Mhz */
353         ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
354
355         active = clamp_val(t.active, 2, 15);
356         recover = clamp_val(t.recover, 4, 15);
357
358         inb(0x3E6);
359         inb(0x3E6);
360         inb(0x3E6);
361         inb(0x3E6);
362
363         iowrite8(recover << 4 | active, ap->ioaddr.device_addr);
364         ioread8(ap->ioaddr.status_addr);
365 }
366
367 static struct ata_port_operations ht6560a_port_ops = {
368         .inherits       = &legacy_base_port_ops,
369         .set_piomode    = ht6560a_set_piomode,
370 };
371
372 /*
373  *      Holtek 6560B support
374  *
375  *      This controller supports PIO0 to PIO4. We honour the BIOS/jumper FIFO
376  *      setting unless we see an ATAPI device in which case we force it off.
377  *
378  *      FIXME: need to implement 2nd channel support.
379  */
380
381 static void ht6560b_set_piomode(struct ata_port *ap, struct ata_device *adev)
382 {
383         u8 active, recover;
384         struct ata_timing t;
385
386         /* Get the timing data in cycles. For now play safe at 50Mhz */
387         ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
388
389         active = clamp_val(t.active, 2, 15);
390         recover = clamp_val(t.recover, 2, 16);
391         recover &= 0x15;
392
393         inb(0x3E6);
394         inb(0x3E6);
395         inb(0x3E6);
396         inb(0x3E6);
397
398         iowrite8(recover << 4 | active, ap->ioaddr.device_addr);
399
400         if (adev->class != ATA_DEV_ATA) {
401                 u8 rconf = inb(0x3E6);
402                 if (rconf & 0x24) {
403                         rconf &= ~0x24;
404                         outb(rconf, 0x3E6);
405                 }
406         }
407         ioread8(ap->ioaddr.status_addr);
408 }
409
410 static struct ata_port_operations ht6560b_port_ops = {
411         .inherits       = &legacy_base_port_ops,
412         .set_piomode    = ht6560b_set_piomode,
413 };
414
415 /*
416  *      Opti core chipset helpers
417  */
418
419 /**
420  *      opti_syscfg     -       read OPTI chipset configuration
421  *      @reg: Configuration register to read
422  *
423  *      Returns the value of an OPTI system board configuration register.
424  */
425
426 static u8 opti_syscfg(u8 reg)
427 {
428         unsigned long flags;
429         u8 r;
430
431         /* Uniprocessor chipset and must force cycles adjancent */
432         local_irq_save(flags);
433         outb(reg, 0x22);
434         r = inb(0x24);
435         local_irq_restore(flags);
436         return r;
437 }
438
439 /*
440  *      Opti 82C611A
441  *
442  *      This controller supports PIO0 to PIO3.
443  */
444
445 static void opti82c611a_set_piomode(struct ata_port *ap,
446                                                 struct ata_device *adev)
447 {
448         u8 active, recover, setup;
449         struct ata_timing t;
450         struct ata_device *pair = ata_dev_pair(adev);
451         int clock;
452         int khz[4] = { 50000, 40000, 33000, 25000 };
453         u8 rc;
454
455         /* Enter configuration mode */
456         ioread16(ap->ioaddr.error_addr);
457         ioread16(ap->ioaddr.error_addr);
458         iowrite8(3, ap->ioaddr.nsect_addr);
459
460         /* Read VLB clock strapping */
461         clock = 1000000000 / khz[ioread8(ap->ioaddr.lbah_addr) & 0x03];
462
463         /* Get the timing data in cycles */
464         ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);
465
466         /* Setup timing is shared */
467         if (pair) {
468                 struct ata_timing tp;
469                 ata_timing_compute(pair, pair->pio_mode, &tp, clock, 1000);
470
471                 ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
472         }
473
474         active = clamp_val(t.active, 2, 17) - 2;
475         recover = clamp_val(t.recover, 1, 16) - 1;
476         setup = clamp_val(t.setup, 1, 4) - 1;
477
478         /* Select the right timing bank for write timing */
479         rc = ioread8(ap->ioaddr.lbal_addr);
480         rc &= 0x7F;
481         rc |= (adev->devno << 7);
482         iowrite8(rc, ap->ioaddr.lbal_addr);
483
484         /* Write the timings */
485         iowrite8(active << 4 | recover, ap->ioaddr.error_addr);
486
487         /* Select the right bank for read timings, also
488            load the shared timings for address */
489         rc = ioread8(ap->ioaddr.device_addr);
490         rc &= 0xC0;
491         rc |= adev->devno;      /* Index select */
492         rc |= (setup << 4) | 0x04;
493         iowrite8(rc, ap->ioaddr.device_addr);
494
495         /* Load the read timings */
496         iowrite8(active << 4 | recover, ap->ioaddr.data_addr);
497
498         /* Ensure the timing register mode is right */
499         rc = ioread8(ap->ioaddr.lbal_addr);
500         rc &= 0x73;
501         rc |= 0x84;
502         iowrite8(rc, ap->ioaddr.lbal_addr);
503
504         /* Exit command mode */
505         iowrite8(0x83,  ap->ioaddr.nsect_addr);
506 }
507
508
509 static struct ata_port_operations opti82c611a_port_ops = {
510         .inherits       = &legacy_base_port_ops,
511         .set_piomode    = opti82c611a_set_piomode,
512 };
513
514 /*
515  *      Opti 82C465MV
516  *
517  *      This controller supports PIO0 to PIO3. Unlike the 611A the MVB
518  *      version is dual channel but doesn't have a lot of unique registers.
519  */
520
521 static void opti82c46x_set_piomode(struct ata_port *ap, struct ata_device *adev)
522 {
523         u8 active, recover, setup;
524         struct ata_timing t;
525         struct ata_device *pair = ata_dev_pair(adev);
526         int clock;
527         int khz[4] = { 50000, 40000, 33000, 25000 };
528         u8 rc;
529         u8 sysclk;
530
531         /* Get the clock */
532         sysclk = opti_syscfg(0xAC) & 0xC0;      /* BIOS set */
533
534         /* Enter configuration mode */
535         ioread16(ap->ioaddr.error_addr);
536         ioread16(ap->ioaddr.error_addr);
537         iowrite8(3, ap->ioaddr.nsect_addr);
538
539         /* Read VLB clock strapping */
540         clock = 1000000000 / khz[sysclk];
541
542         /* Get the timing data in cycles */
543         ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);
544
545         /* Setup timing is shared */
546         if (pair) {
547                 struct ata_timing tp;
548                 ata_timing_compute(pair, pair->pio_mode, &tp, clock, 1000);
549
550                 ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
551         }
552
553         active = clamp_val(t.active, 2, 17) - 2;
554         recover = clamp_val(t.recover, 1, 16) - 1;
555         setup = clamp_val(t.setup, 1, 4) - 1;
556
557         /* Select the right timing bank for write timing */
558         rc = ioread8(ap->ioaddr.lbal_addr);
559         rc &= 0x7F;
560         rc |= (adev->devno << 7);
561         iowrite8(rc, ap->ioaddr.lbal_addr);
562
563         /* Write the timings */
564         iowrite8(active << 4 | recover, ap->ioaddr.error_addr);
565
566         /* Select the right bank for read timings, also
567            load the shared timings for address */
568         rc = ioread8(ap->ioaddr.device_addr);
569         rc &= 0xC0;
570         rc |= adev->devno;      /* Index select */
571         rc |= (setup << 4) | 0x04;
572         iowrite8(rc, ap->ioaddr.device_addr);
573
574         /* Load the read timings */
575         iowrite8(active << 4 | recover, ap->ioaddr.data_addr);
576
577         /* Ensure the timing register mode is right */
578         rc = ioread8(ap->ioaddr.lbal_addr);
579         rc &= 0x73;
580         rc |= 0x84;
581         iowrite8(rc, ap->ioaddr.lbal_addr);
582
583         /* Exit command mode */
584         iowrite8(0x83,  ap->ioaddr.nsect_addr);
585
586         /* We need to know this for quad device on the MVB */
587         ap->host->private_data = ap;
588 }
589
590 /**
591  *      opt82c465mv_qc_issue            -       command issue
592  *      @qc: command pending
593  *
594  *      Called when the libata layer is about to issue a command. We wrap
595  *      this interface so that we can load the correct ATA timings. The
596  *      MVB has a single set of timing registers and these are shared
597  *      across channels. As there are two registers we really ought to
598  *      track the last two used values as a sort of register window. For
599  *      now we just reload on a channel switch. On the single channel
600  *      setup this condition never fires so we do nothing extra.
601  *
602  *      FIXME: dual channel needs ->serialize support
603  */
604
605 static unsigned int opti82c46x_qc_issue(struct ata_queued_cmd *qc)
606 {
607         struct ata_port *ap = qc->ap;
608         struct ata_device *adev = qc->dev;
609
610         /* If timings are set and for the wrong channel (2nd test is
611            due to a libata shortcoming and will eventually go I hope) */
612         if (ap->host->private_data != ap->host
613             && ap->host->private_data != NULL)
614                 opti82c46x_set_piomode(ap, adev);
615
616         return ata_sff_qc_issue(qc);
617 }
618
619 static struct ata_port_operations opti82c46x_port_ops = {
620         .inherits       = &legacy_base_port_ops,
621         .set_piomode    = opti82c46x_set_piomode,
622         .qc_issue       = opti82c46x_qc_issue,
623 };
624
625 static void qdi6500_set_piomode(struct ata_port *ap, struct ata_device *adev)
626 {
627         struct ata_timing t;
628         struct legacy_data *ld_qdi = ap->host->private_data;
629         int active, recovery;
630         u8 timing;
631
632         /* Get the timing data in cycles */
633         ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
634
635         if (ld_qdi->fast) {
636                 active = 8 - clamp_val(t.active, 1, 8);
637                 recovery = 18 - clamp_val(t.recover, 3, 18);
638         } else {
639                 active = 9 - clamp_val(t.active, 2, 9);
640                 recovery = 15 - clamp_val(t.recover, 0, 15);
641         }
642         timing = (recovery << 4) | active | 0x08;
643
644         ld_qdi->clock[adev->devno] = timing;
645
646         outb(timing, ld_qdi->timing);
647 }
648
649 /**
650  *      qdi6580dp_set_piomode           -       PIO setup for dual channel
651  *      @ap: Port
652  *      @adev: Device
653  *
654  *      In dual channel mode the 6580 has one clock per channel and we have
655  *      to software clockswitch in qc_issue.
656  */
657
658 static void qdi6580dp_set_piomode(struct ata_port *ap, struct ata_device *adev)
659 {
660         struct ata_timing t;
661         struct legacy_data *ld_qdi = ap->host->private_data;
662         int active, recovery;
663         u8 timing;
664
665         /* Get the timing data in cycles */
666         ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
667
668         if (ld_qdi->fast) {
669                 active = 8 - clamp_val(t.active, 1, 8);
670                 recovery = 18 - clamp_val(t.recover, 3, 18);
671         } else {
672                 active = 9 - clamp_val(t.active, 2, 9);
673                 recovery = 15 - clamp_val(t.recover, 0, 15);
674         }
675         timing = (recovery << 4) | active | 0x08;
676
677         ld_qdi->clock[adev->devno] = timing;
678
679         outb(timing, ld_qdi->timing + 2 * ap->port_no);
680         /* Clear the FIFO */
681         if (adev->class != ATA_DEV_ATA)
682                 outb(0x5F, (ld_qdi->timing & 0xFFF0) + 3);
683 }
684
685 /**
686  *      qdi6580_set_piomode             -       PIO setup for single channel
687  *      @ap: Port
688  *      @adev: Device
689  *
690  *      In single channel mode the 6580 has one clock per device and we can
691  *      avoid the requirement to clock switch. We also have to load the timing
692  *      into the right clock according to whether we are master or slave.
693  */
694
695 static void qdi6580_set_piomode(struct ata_port *ap, struct ata_device *adev)
696 {
697         struct ata_timing t;
698         struct legacy_data *ld_qdi = ap->host->private_data;
699         int active, recovery;
700         u8 timing;
701
702         /* Get the timing data in cycles */
703         ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
704
705         if (ld_qdi->fast) {
706                 active = 8 - clamp_val(t.active, 1, 8);
707                 recovery = 18 - clamp_val(t.recover, 3, 18);
708         } else {
709                 active = 9 - clamp_val(t.active, 2, 9);
710                 recovery = 15 - clamp_val(t.recover, 0, 15);
711         }
712         timing = (recovery << 4) | active | 0x08;
713         ld_qdi->clock[adev->devno] = timing;
714         outb(timing, ld_qdi->timing + 2 * adev->devno);
715         /* Clear the FIFO */
716         if (adev->class != ATA_DEV_ATA)
717                 outb(0x5F, (ld_qdi->timing & 0xFFF0) + 3);
718 }
719
720 /**
721  *      qdi_qc_issue            -       command issue
722  *      @qc: command pending
723  *
724  *      Called when the libata layer is about to issue a command. We wrap
725  *      this interface so that we can load the correct ATA timings.
726  */
727
728 static unsigned int qdi_qc_issue(struct ata_queued_cmd *qc)
729 {
730         struct ata_port *ap = qc->ap;
731         struct ata_device *adev = qc->dev;
732         struct legacy_data *ld_qdi = ap->host->private_data;
733
734         if (ld_qdi->clock[adev->devno] != ld_qdi->last) {
735                 if (adev->pio_mode) {
736                         ld_qdi->last = ld_qdi->clock[adev->devno];
737                         outb(ld_qdi->clock[adev->devno], ld_qdi->timing +
738                                                         2 * ap->port_no);
739                 }
740         }
741         return ata_sff_qc_issue(qc);
742 }
743
744 static unsigned int vlb32_data_xfer(struct ata_device *adev, unsigned char *buf,
745                                         unsigned int buflen, int rw)
746 {
747         struct ata_port *ap = adev->link->ap;
748         int slop = buflen & 3;
749
750         if (ata_id_has_dword_io(adev->id) && (slop == 0 || slop == 3)
751                                         && (ap->pflags & ATA_PFLAG_PIO32)) {
752                 if (rw == WRITE)
753                         iowrite32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
754                 else
755                         ioread32_rep(ap->ioaddr.data_addr, buf, buflen >> 2);
756
757                 if (unlikely(slop)) {
758                         __le32 pad;
759                         if (rw == WRITE) {
760                                 memcpy(&pad, buf + buflen - slop, slop);
761                                 iowrite32(le32_to_cpu(pad), ap->ioaddr.data_addr);
762                         } else {
763                                 pad = cpu_to_le32(ioread32(ap->ioaddr.data_addr));
764                                 memcpy(buf + buflen - slop, &pad, slop);
765                         }
766                 }
767                 return (buflen + 3) & ~3;
768         } else
769                 return ata_sff_data_xfer(adev, buf, buflen, rw);
770 }
771
772 static int qdi_port(struct platform_device *dev,
773                         struct legacy_probe *lp, struct legacy_data *ld)
774 {
775         if (devm_request_region(&dev->dev, lp->private, 4, "qdi") == NULL)
776                 return -EBUSY;
777         ld->timing = lp->private;
778         return 0;
779 }
780
781 static struct ata_port_operations qdi6500_port_ops = {
782         .inherits       = &legacy_base_port_ops,
783         .set_piomode    = qdi6500_set_piomode,
784         .qc_issue       = qdi_qc_issue,
785         .sff_data_xfer  = vlb32_data_xfer,
786 };
787
788 static struct ata_port_operations qdi6580_port_ops = {
789         .inherits       = &legacy_base_port_ops,
790         .set_piomode    = qdi6580_set_piomode,
791         .sff_data_xfer  = vlb32_data_xfer,
792 };
793
794 static struct ata_port_operations qdi6580dp_port_ops = {
795         .inherits       = &legacy_base_port_ops,
796         .set_piomode    = qdi6580dp_set_piomode,
797         .qc_issue       = qdi_qc_issue,
798         .sff_data_xfer  = vlb32_data_xfer,
799 };
800
801 static DEFINE_SPINLOCK(winbond_lock);
802
803 static void winbond_writecfg(unsigned long port, u8 reg, u8 val)
804 {
805         unsigned long flags;
806         spin_lock_irqsave(&winbond_lock, flags);
807         outb(reg, port + 0x01);
808         outb(val, port + 0x02);
809         spin_unlock_irqrestore(&winbond_lock, flags);
810 }
811
812 static u8 winbond_readcfg(unsigned long port, u8 reg)
813 {
814         u8 val;
815
816         unsigned long flags;
817         spin_lock_irqsave(&winbond_lock, flags);
818         outb(reg, port + 0x01);
819         val = inb(port + 0x02);
820         spin_unlock_irqrestore(&winbond_lock, flags);
821
822         return val;
823 }
824
825 static void winbond_set_piomode(struct ata_port *ap, struct ata_device *adev)
826 {
827         struct ata_timing t;
828         struct legacy_data *ld_winbond = ap->host->private_data;
829         int active, recovery;
830         u8 reg;
831         int timing = 0x88 + (ap->port_no * 4) + (adev->devno * 2);
832
833         reg = winbond_readcfg(ld_winbond->timing, 0x81);
834
835         /* Get the timing data in cycles */
836         if (reg & 0x40)         /* Fast VLB bus, assume 50MHz */
837                 ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
838         else
839                 ata_timing_compute(adev, adev->pio_mode, &t, 30303, 1000);
840
841         active = (clamp_val(t.active, 3, 17) - 1) & 0x0F;
842         recovery = (clamp_val(t.recover, 1, 15) + 1) & 0x0F;
843         timing = (active << 4) | recovery;
844         winbond_writecfg(ld_winbond->timing, timing, reg);
845
846         /* Load the setup timing */
847
848         reg = 0x35;
849         if (adev->class != ATA_DEV_ATA)
850                 reg |= 0x08;    /* FIFO off */
851         if (!ata_pio_need_iordy(adev))
852                 reg |= 0x02;    /* IORDY off */
853         reg |= (clamp_val(t.setup, 0, 3) << 6);
854         winbond_writecfg(ld_winbond->timing, timing + 1, reg);
855 }
856
857 static int winbond_port(struct platform_device *dev,
858                         struct legacy_probe *lp, struct legacy_data *ld)
859 {
860         if (devm_request_region(&dev->dev, lp->private, 4, "winbond") == NULL)
861                 return -EBUSY;
862         ld->timing = lp->private;
863         return 0;
864 }
865
866 static struct ata_port_operations winbond_port_ops = {
867         .inherits       = &legacy_base_port_ops,
868         .set_piomode    = winbond_set_piomode,
869         .sff_data_xfer  = vlb32_data_xfer,
870 };
871
872 static struct legacy_controller controllers[] = {
873         {"BIOS",        &legacy_port_ops,       0x1F,
874                         ATA_FLAG_NO_IORDY,      0,                      NULL },
875         {"Snooping",    &simple_port_ops,       0x1F,
876                         0,                      0,                      NULL },
877         {"PDC20230",    &pdc20230_port_ops,     0x7,
878                         ATA_FLAG_NO_IORDY,
879                         ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE,        NULL },
880         {"HT6560A",     &ht6560a_port_ops,      0x07,
881                         ATA_FLAG_NO_IORDY,      0,                      NULL },
882         {"HT6560B",     &ht6560b_port_ops,      0x1F,
883                         ATA_FLAG_NO_IORDY,      0,                      NULL },
884         {"OPTI82C611A", &opti82c611a_port_ops,  0x0F,
885                         0,                      0,                      NULL },
886         {"OPTI82C46X",  &opti82c46x_port_ops,   0x0F,
887                         0,                      0,                      NULL },
888         {"QDI6500",     &qdi6500_port_ops,      0x07,
889                         ATA_FLAG_NO_IORDY,
890                         ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE,    qdi_port },
891         {"QDI6580",     &qdi6580_port_ops,      0x1F,
892                         0, ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE, qdi_port },
893         {"QDI6580DP",   &qdi6580dp_port_ops,    0x1F,
894                         0, ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE, qdi_port },
895         {"W83759A",     &winbond_port_ops,      0x1F,
896                         0, ATA_PFLAG_PIO32 | ATA_PFLAG_PIO32CHANGE,
897                                                                 winbond_port }
898 };
899
900 /**
901  *      probe_chip_type         -       Discover controller
902  *      @probe: Probe entry to check
903  *
904  *      Probe an ATA port and identify the type of controller. We don't
905  *      check if the controller appears to be driveless at this point.
906  */
907
908 static __init int probe_chip_type(struct legacy_probe *probe)
909 {
910         int mask = 1 << probe->slot;
911
912         if (winbond && (probe->port == 0x1F0 || probe->port == 0x170)) {
913                 u8 reg = winbond_readcfg(winbond, 0x81);
914                 reg |= 0x80;    /* jumpered mode off */
915                 winbond_writecfg(winbond, 0x81, reg);
916                 reg = winbond_readcfg(winbond, 0x83);
917                 reg |= 0xF0;    /* local control */
918                 winbond_writecfg(winbond, 0x83, reg);
919                 reg = winbond_readcfg(winbond, 0x85);
920                 reg |= 0xF0;    /* programmable timing */
921                 winbond_writecfg(winbond, 0x85, reg);
922
923                 reg = winbond_readcfg(winbond, 0x81);
924
925                 if (reg & mask)
926                         return W83759A;
927         }
928         if (probe->port == 0x1F0) {
929                 unsigned long flags;
930                 local_irq_save(flags);
931                 /* Probes */
932                 outb(inb(0x1F2) | 0x80, 0x1F2);
933                 inb(0x1F5);
934                 inb(0x1F2);
935                 inb(0x3F6);
936                 inb(0x3F6);
937                 inb(0x1F2);
938                 inb(0x1F2);
939
940                 if ((inb(0x1F2) & 0x80) == 0) {
941                         /* PDC20230c or 20630 ? */
942                         printk(KERN_INFO  "PDC20230-C/20630 VLB ATA controller"
943                                                         " detected.\n");
944                         udelay(100);
945                         inb(0x1F5);
946                         local_irq_restore(flags);
947                         return PDC20230;
948                 } else {
949                         outb(0x55, 0x1F2);
950                         inb(0x1F2);
951                         inb(0x1F2);
952                         if (inb(0x1F2) == 0x00)
953                                 printk(KERN_INFO "PDC20230-B VLB ATA "
954                                                      "controller detected.\n");
955                         local_irq_restore(flags);
956                         return BIOS;
957                 }
958                 local_irq_restore(flags);
959         }
960
961         if (ht6560a & mask)
962                 return HT6560A;
963         if (ht6560b & mask)
964                 return HT6560B;
965         if (opti82c611a & mask)
966                 return OPTI611A;
967         if (opti82c46x & mask)
968                 return OPTI46X;
969         if (autospeed & mask)
970                 return SNOOP;
971         return BIOS;
972 }
973
974
975 /**
976  *      legacy_init_one         -       attach a legacy interface
977  *      @pl: probe record
978  *
979  *      Register an ISA bus IDE interface. Such interfaces are PIO and we
980  *      assume do not support IRQ sharing.
981  */
982
983 static __init int legacy_init_one(struct legacy_probe *probe)
984 {
985         struct legacy_controller *controller = &controllers[probe->type];
986         int pio_modes = controller->pio_mask;
987         unsigned long io = probe->port;
988         u32 mask = (1 << probe->slot);
989         struct ata_port_operations *ops = controller->ops;
990         struct legacy_data *ld = &legacy_data[probe->slot];
991         struct ata_host *host = NULL;
992         struct ata_port *ap;
993         struct platform_device *pdev;
994         struct ata_device *dev;
995         void __iomem *io_addr, *ctrl_addr;
996         u32 iordy = (iordy_mask & mask) ? 0: ATA_FLAG_NO_IORDY;
997         int ret;
998
999         iordy |= controller->flags;
1000
1001         pdev = platform_device_register_simple(DRV_NAME, probe->slot, NULL, 0);
1002         if (IS_ERR(pdev))
1003                 return PTR_ERR(pdev);
1004
1005         ret = -EBUSY;
1006         if (devm_request_region(&pdev->dev, io, 8, "pata_legacy") == NULL ||
1007             devm_request_region(&pdev->dev, io + 0x0206, 1,
1008                                                         "pata_legacy") == NULL)
1009                 goto fail;
1010
1011         ret = -ENOMEM;
1012         io_addr = devm_ioport_map(&pdev->dev, io, 8);
1013         ctrl_addr = devm_ioport_map(&pdev->dev, io + 0x0206, 1);
1014         if (!io_addr || !ctrl_addr)
1015                 goto fail;
1016         if (controller->setup)
1017                 if (controller->setup(pdev, probe, ld) < 0)
1018                         goto fail;
1019         host = ata_host_alloc(&pdev->dev, 1);
1020         if (!host)
1021                 goto fail;
1022         ap = host->ports[0];
1023
1024         ap->ops = ops;
1025         ap->pio_mask = pio_modes;
1026         ap->flags |= ATA_FLAG_SLAVE_POSS | iordy;
1027         ap->pflags |= controller->pflags;
1028         ap->ioaddr.cmd_addr = io_addr;
1029         ap->ioaddr.altstatus_addr = ctrl_addr;
1030         ap->ioaddr.ctl_addr = ctrl_addr;
1031         ata_sff_std_ports(&ap->ioaddr);
1032         ap->host->private_data = ld;
1033
1034         ata_port_desc(ap, "cmd 0x%lx ctl 0x%lx", io, io + 0x0206);
1035
1036         ret = ata_host_activate(host, probe->irq, ata_sff_interrupt, 0,
1037                                 &legacy_sht);
1038         if (ret)
1039                 goto fail;
1040         async_synchronize_full();
1041         ld->platform_dev = pdev;
1042
1043         /* Nothing found means we drop the port as its probably not there */
1044
1045         ret = -ENODEV;
1046         ata_for_each_dev(dev, &ap->link, ALL) {
1047                 if (!ata_dev_absent(dev)) {
1048                         legacy_host[probe->slot] = host;
1049                         ld->platform_dev = pdev;
1050                         return 0;
1051                 }
1052         }
1053         ata_host_detach(host);
1054 fail:
1055         platform_device_unregister(pdev);
1056         return ret;
1057 }
1058
1059 /**
1060  *      legacy_check_special_cases      -       ATA special cases
1061  *      @p: PCI device to check
1062  *      @master: set this if we find an ATA master
1063  *      @master: set this if we find an ATA secondary
1064  *
1065  *      A small number of vendors implemented early PCI ATA interfaces
1066  *      on bridge logic without the ATA interface being PCI visible.
1067  *      Where we have a matching PCI driver we must skip the relevant
1068  *      device here. If we don't know about it then the legacy driver
1069  *      is the right driver anyway.
1070  */
1071
1072 static void __init legacy_check_special_cases(struct pci_dev *p, int *primary,
1073                                                                 int *secondary)
1074 {
1075         /* Cyrix CS5510 pre SFF MWDMA ATA on the bridge */
1076         if (p->vendor == 0x1078 && p->device == 0x0000) {
1077                 *primary = *secondary = 1;
1078                 return;
1079         }
1080         /* Cyrix CS5520 pre SFF MWDMA ATA on the bridge */
1081         if (p->vendor == 0x1078 && p->device == 0x0002) {
1082                 *primary = *secondary = 1;
1083                 return;
1084         }
1085         /* Intel MPIIX - PIO ATA on non PCI side of bridge */
1086         if (p->vendor == 0x8086 && p->device == 0x1234) {
1087                 u16 r;
1088                 pci_read_config_word(p, 0x6C, &r);
1089                 if (r & 0x8000) {
1090                         /* ATA port enabled */
1091                         if (r & 0x4000)
1092                                 *secondary = 1;
1093                         else
1094                                 *primary = 1;
1095                 }
1096                 return;
1097         }
1098 }
1099
1100 static __init void probe_opti_vlb(void)
1101 {
1102         /* If an OPTI 82C46X is present find out where the channels are */
1103         static const char *optis[4] = {
1104                 "3/463MV", "5MV",
1105                 "5MVA", "5MVB"
1106         };
1107         u8 chans = 1;
1108         u8 ctrl = (opti_syscfg(0x30) & 0xC0) >> 6;
1109
1110         opti82c46x = 3; /* Assume master and slave first */
1111         printk(KERN_INFO DRV_NAME ": Opti 82C46%s chipset support.\n",
1112                                                                 optis[ctrl]);
1113         if (ctrl == 3)
1114                 chans = (opti_syscfg(0x3F) & 0x20) ? 2 : 1;
1115         ctrl = opti_syscfg(0xAC);
1116         /* Check enabled and this port is the 465MV port. On the
1117            MVB we may have two channels */
1118         if (ctrl & 8) {
1119                 if (chans == 2) {
1120                         legacy_probe_add(0x1F0, 14, OPTI46X, 0);
1121                         legacy_probe_add(0x170, 15, OPTI46X, 0);
1122                 }
1123                 if (ctrl & 4)
1124                         legacy_probe_add(0x170, 15, OPTI46X, 0);
1125                 else
1126                         legacy_probe_add(0x1F0, 14, OPTI46X, 0);
1127         } else
1128                 legacy_probe_add(0x1F0, 14, OPTI46X, 0);
1129 }
1130
1131 static __init void qdi65_identify_port(u8 r, u8 res, unsigned long port)
1132 {
1133         static const unsigned long ide_port[2] = { 0x170, 0x1F0 };
1134         /* Check card type */
1135         if ((r & 0xF0) == 0xC0) {
1136                 /* QD6500: single channel */
1137                 if (r & 8)
1138                         /* Disabled ? */
1139                         return;
1140                 legacy_probe_add(ide_port[r & 0x01], 14 + (r & 0x01),
1141                                                                 QDI6500, port);
1142         }
1143         if (((r & 0xF0) == 0xA0) || (r & 0xF0) == 0x50) {
1144                 /* QD6580: dual channel */
1145                 if (!request_region(port + 2 , 2, "pata_qdi")) {
1146                         release_region(port, 2);
1147                         return;
1148                 }
1149                 res = inb(port + 3);
1150                 /* Single channel mode ? */
1151                 if (res & 1)
1152                         legacy_probe_add(ide_port[r & 0x01], 14 + (r & 0x01),
1153                                                                 QDI6580, port);
1154                 else { /* Dual channel mode */
1155                         legacy_probe_add(0x1F0, 14, QDI6580DP, port);
1156                         /* port + 0x02, r & 0x04 */
1157                         legacy_probe_add(0x170, 15, QDI6580DP, port + 2);
1158                 }
1159                 release_region(port + 2, 2);
1160         }
1161 }
1162
1163 static __init void probe_qdi_vlb(void)
1164 {
1165         unsigned long flags;
1166         static const unsigned long qd_port[2] = { 0x30, 0xB0 };
1167         int i;
1168
1169         /*
1170          *      Check each possible QD65xx base address
1171          */
1172
1173         for (i = 0; i < 2; i++) {
1174                 unsigned long port = qd_port[i];
1175                 u8 r, res;
1176
1177
1178                 if (request_region(port, 2, "pata_qdi")) {
1179                         /* Check for a card */
1180                         local_irq_save(flags);
1181                         /* I have no h/w that needs this delay but it
1182                            is present in the historic code */
1183                         r = inb(port);
1184                         udelay(1);
1185                         outb(0x19, port);
1186                         udelay(1);
1187                         res = inb(port);
1188                         udelay(1);
1189                         outb(r, port);
1190                         udelay(1);
1191                         local_irq_restore(flags);
1192
1193                         /* Fail */
1194                         if (res == 0x19) {
1195                                 release_region(port, 2);
1196                                 continue;
1197                         }
1198                         /* Passes the presence test */
1199                         r = inb(port + 1);
1200                         udelay(1);
1201                         /* Check port agrees with port set */
1202                         if ((r & 2) >> 1 == i)
1203                                 qdi65_identify_port(r, res, port);
1204                         release_region(port, 2);
1205                 }
1206         }
1207 }
1208
1209 /**
1210  *      legacy_init             -       attach legacy interfaces
1211  *
1212  *      Attach legacy IDE interfaces by scanning the usual IRQ/port suspects.
1213  *      Right now we do not scan the ide0 and ide1 address but should do so
1214  *      for non PCI systems or systems with no PCI IDE legacy mode devices.
1215  *      If you fix that note there are special cases to consider like VLB
1216  *      drivers and CS5510/20.
1217  */
1218
1219 static __init int legacy_init(void)
1220 {
1221         int i;
1222         int ct = 0;
1223         int primary = 0;
1224         int secondary = 0;
1225         int pci_present = 0;
1226         struct legacy_probe *pl = &probe_list[0];
1227         int slot = 0;
1228
1229         struct pci_dev *p = NULL;
1230
1231         for_each_pci_dev(p) {
1232                 int r;
1233                 /* Check for any overlap of the system ATA mappings. Native
1234                    mode controllers stuck on these addresses or some devices
1235                    in 'raid' mode won't be found by the storage class test */
1236                 for (r = 0; r < 6; r++) {
1237                         if (pci_resource_start(p, r) == 0x1f0)
1238                                 primary = 1;
1239                         if (pci_resource_start(p, r) == 0x170)
1240                                 secondary = 1;
1241                 }
1242                 /* Check for special cases */
1243                 legacy_check_special_cases(p, &primary, &secondary);
1244
1245                 /* If PCI bus is present then don't probe for tertiary
1246                    legacy ports */
1247                 pci_present = 1;
1248         }
1249
1250         if (winbond == 1)
1251                 winbond = 0x130;        /* Default port, alt is 1B0 */
1252
1253         if (primary == 0 || all)
1254                 legacy_probe_add(0x1F0, 14, UNKNOWN, 0);
1255         if (secondary == 0 || all)
1256                 legacy_probe_add(0x170, 15, UNKNOWN, 0);
1257
1258         if (probe_all || !pci_present) {
1259                 /* ISA/VLB extra ports */
1260                 legacy_probe_add(0x1E8, 11, UNKNOWN, 0);
1261                 legacy_probe_add(0x168, 10, UNKNOWN, 0);
1262                 legacy_probe_add(0x1E0, 8, UNKNOWN, 0);
1263                 legacy_probe_add(0x160, 12, UNKNOWN, 0);
1264         }
1265
1266         if (opti82c46x)
1267                 probe_opti_vlb();
1268         if (qdi)
1269                 probe_qdi_vlb();
1270
1271         for (i = 0; i < NR_HOST; i++, pl++) {
1272                 if (pl->port == 0)
1273                         continue;
1274                 if (pl->type == UNKNOWN)
1275                         pl->type = probe_chip_type(pl);
1276                 pl->slot = slot++;
1277                 if (legacy_init_one(pl) == 0)
1278                         ct++;
1279         }
1280         if (ct != 0)
1281                 return 0;
1282         return -ENODEV;
1283 }
1284
1285 static __exit void legacy_exit(void)
1286 {
1287         int i;
1288
1289         for (i = 0; i < nr_legacy_host; i++) {
1290                 struct legacy_data *ld = &legacy_data[i];
1291                 ata_host_detach(legacy_host[i]);
1292                 platform_device_unregister(ld->platform_dev);
1293         }
1294 }
1295
1296 MODULE_AUTHOR("Alan Cox");
1297 MODULE_DESCRIPTION("low-level driver for legacy ATA");
1298 MODULE_LICENSE("GPL");
1299 MODULE_VERSION(DRV_VERSION);
1300
1301 module_param(probe_all, int, 0);
1302 module_param(autospeed, int, 0);
1303 module_param(ht6560a, int, 0);
1304 module_param(ht6560b, int, 0);
1305 module_param(opti82c611a, int, 0);
1306 module_param(opti82c46x, int, 0);
1307 module_param(qdi, int, 0);
1308 module_param(pio_mask, int, 0);
1309 module_param(iordy_mask, int, 0);
1310
1311 module_init(legacy_init);
1312 module_exit(legacy_exit);