9532b9bb6d2f0f0270f2de3fed88a60b4fc36b64
[linux-3.10.git] / drivers / ata / pata_legacy.c
1 /*
2  *   pata-legacy.c - Legacy port PATA/SATA controller driver.
3  *   Copyright 2005/2006 Red Hat <alan@redhat.com>, 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  *
29  *  Unsupported but docs exist:
30  *      Appian/Adaptec AIC25VL01/Cirrus Logic PD7220
31  *      Winbond W83759A
32  *
33  *  This driver handles legacy (that is "ISA/VLB side") IDE ports found
34  *  on PC class systems. There are three hybrid devices that are exceptions
35  *  The Cyrix 5510/5520 where a pre SFF ATA device is on the bridge and
36  *  the MPIIX where the tuning is PCI side but the IDE is "ISA side".
37  *
38  *  Specific support is included for the ht6560a/ht6560b/opti82c611a/
39  *  opti82c465mv/promise 20230c/20630
40  *
41  *  Use the autospeed and pio_mask options with:
42  *      Appian ADI/2 aka CLPD7220 or AIC25VL01.
43  *  Use the jumpers, autospeed and set pio_mask to the mode on the jumpers with
44  *      Goldstar GM82C711, PIC-1288A-125, UMC 82C871F, Winbond W83759,
45  *      Winbond W83759A, Promise PDC20230-B
46  *
47  *  For now use autospeed and pio_mask as above with the W83759A. This may
48  *  change.
49  *
50  *  TODO
51  *      Merge existing pata_qdi driver
52  *
53  */
54
55 #include <linux/kernel.h>
56 #include <linux/module.h>
57 #include <linux/pci.h>
58 #include <linux/init.h>
59 #include <linux/blkdev.h>
60 #include <linux/delay.h>
61 #include <scsi/scsi_host.h>
62 #include <linux/ata.h>
63 #include <linux/libata.h>
64 #include <linux/platform_device.h>
65
66 #define DRV_NAME "pata_legacy"
67 #define DRV_VERSION "0.5.3"
68
69 #define NR_HOST 6
70
71 static int legacy_port[NR_HOST] = { 0x1f0, 0x170, 0x1e8, 0x168, 0x1e0, 0x160 };
72 static int legacy_irq[NR_HOST] = { 15, 14, 11, 10, 8, 12 };
73
74 struct legacy_data {
75         unsigned long timing;
76         u8 clock[2];
77         u8 last;
78         int fast;
79         struct platform_device *platform_dev;
80
81 };
82
83 static struct legacy_data legacy_data[NR_HOST];
84 static struct ata_host *legacy_host[NR_HOST];
85 static int nr_legacy_host;
86
87
88 static int probe_all;                   /* Set to check all ISA port ranges */
89 static int ht6560a;                     /* HT 6560A on primary 1, secondary 2, both 3 */
90 static int ht6560b;                     /* HT 6560A on primary 1, secondary 2, both 3 */
91 static int opti82c611a;                 /* Opti82c611A on primary 1, secondary 2, both 3 */
92 static int opti82c46x;          /* Opti 82c465MV present (pri/sec autodetect) */
93 static int autospeed;                   /* Chip present which snoops speed changes */
94 static int pio_mask = 0x1F;             /* PIO range for autospeed devices */
95
96 /**
97  *      legacy_set_mode         -       mode setting
98  *      @ap: IDE interface
99  *      @unused: Device that failed when error is returned
100  *
101  *      Use a non standard set_mode function. We don't want to be tuned.
102  *
103  *      The BIOS configured everything. Our job is not to fiddle. Just use
104  *      whatever PIO the hardware is using and leave it at that. When we
105  *      get some kind of nice user driven API for control then we can
106  *      expand on this as per hdparm in the base kernel.
107  */
108
109 static int legacy_set_mode(struct ata_port *ap, struct ata_device **unused)
110 {
111         int i;
112
113         for (i = 0; i < ATA_MAX_DEVICES; i++) {
114                 struct ata_device *dev = &ap->device[i];
115                 if (ata_dev_enabled(dev)) {
116                         dev->pio_mode = XFER_PIO_0;
117                         dev->xfer_mode = XFER_PIO_0;
118                         dev->xfer_shift = ATA_SHIFT_PIO;
119                         dev->flags |= ATA_DFLAG_PIO;
120                 }
121         }
122         return 0;
123 }
124
125 static struct scsi_host_template legacy_sht = {
126         .module                 = THIS_MODULE,
127         .name                   = DRV_NAME,
128         .ioctl                  = ata_scsi_ioctl,
129         .queuecommand           = ata_scsi_queuecmd,
130         .can_queue              = ATA_DEF_QUEUE,
131         .this_id                = ATA_SHT_THIS_ID,
132         .sg_tablesize           = LIBATA_MAX_PRD,
133         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,
134         .emulated               = ATA_SHT_EMULATED,
135         .use_clustering         = ATA_SHT_USE_CLUSTERING,
136         .proc_name              = DRV_NAME,
137         .dma_boundary           = ATA_DMA_BOUNDARY,
138         .slave_configure        = ata_scsi_slave_config,
139         .slave_destroy          = ata_scsi_slave_destroy,
140         .bios_param             = ata_std_bios_param,
141 };
142
143 /*
144  *      These ops are used if the user indicates the hardware
145  *      snoops the commands to decide on the mode and handles the
146  *      mode selection "magically" itself. Several legacy controllers
147  *      do this. The mode range can be set if it is not 0x1F by setting
148  *      pio_mask as well.
149  */
150
151 static struct ata_port_operations simple_port_ops = {
152         .port_disable   = ata_port_disable,
153         .tf_load        = ata_tf_load,
154         .tf_read        = ata_tf_read,
155         .check_status   = ata_check_status,
156         .exec_command   = ata_exec_command,
157         .dev_select     = ata_std_dev_select,
158
159         .freeze         = ata_bmdma_freeze,
160         .thaw           = ata_bmdma_thaw,
161         .error_handler  = ata_bmdma_error_handler,
162         .post_internal_cmd = ata_bmdma_post_internal_cmd,
163
164         .qc_prep        = ata_qc_prep,
165         .qc_issue       = ata_qc_issue_prot,
166
167         .data_xfer      = ata_pio_data_xfer_noirq,
168
169         .irq_handler    = ata_interrupt,
170         .irq_clear      = ata_bmdma_irq_clear,
171
172         .port_start     = ata_port_start,
173 };
174
175 static struct ata_port_operations legacy_port_ops = {
176         .set_mode       = legacy_set_mode,
177
178         .port_disable   = ata_port_disable,
179         .tf_load        = ata_tf_load,
180         .tf_read        = ata_tf_read,
181         .check_status   = ata_check_status,
182         .exec_command   = ata_exec_command,
183         .dev_select     = ata_std_dev_select,
184
185         .error_handler  = ata_bmdma_error_handler,
186
187         .qc_prep        = ata_qc_prep,
188         .qc_issue       = ata_qc_issue_prot,
189
190         .data_xfer      = ata_pio_data_xfer_noirq,
191
192         .irq_handler    = ata_interrupt,
193         .irq_clear      = ata_bmdma_irq_clear,
194
195         .port_start     = ata_port_start,
196 };
197
198 /*
199  *      Promise 20230C and 20620 support
200  *
201  *      This controller supports PIO0 to PIO2. We set PIO timings conservatively to
202  *      allow for 50MHz Vesa Local Bus. The 20620 DMA support is weird being DMA to
203  *      controller and PIO'd to the host and not supported.
204  */
205
206 static void pdc20230_set_piomode(struct ata_port *ap, struct ata_device *adev)
207 {
208         int tries = 5;
209         int pio = adev->pio_mode - XFER_PIO_0;
210         u8 rt;
211         unsigned long flags;
212
213         /* Safe as UP only. Force I/Os to occur together */
214
215         local_irq_save(flags);
216
217         /* Unlock the control interface */
218         do
219         {
220                 inb(0x1F5);
221                 outb(inb(0x1F2) | 0x80, 0x1F2);
222                 inb(0x1F2);
223                 inb(0x3F6);
224                 inb(0x3F6);
225                 inb(0x1F2);
226                 inb(0x1F2);
227         }
228         while((inb(0x1F2) & 0x80) && --tries);
229
230         local_irq_restore(flags);
231
232         outb(inb(0x1F4) & 0x07, 0x1F4);
233
234         rt = inb(0x1F3);
235         rt &= 0x07 << (3 * adev->devno);
236         if (pio)
237                 rt |= (1 + 3 * pio) << (3 * adev->devno);
238
239         udelay(100);
240         outb(inb(0x1F2) | 0x01, 0x1F2);
241         udelay(100);
242         inb(0x1F5);
243
244 }
245
246 static void pdc_data_xfer_vlb(struct ata_device *adev, unsigned char *buf, unsigned int buflen, int write_data)
247 {
248         struct ata_port *ap = adev->ap;
249         int slop = buflen & 3;
250         unsigned long flags;
251
252         if (ata_id_has_dword_io(adev->id)) {
253                 local_irq_save(flags);
254
255                 /* Perform the 32bit I/O synchronization sequence */
256                 inb(ap->ioaddr.nsect_addr);
257                 inb(ap->ioaddr.nsect_addr);
258                 inb(ap->ioaddr.nsect_addr);
259
260                 /* Now the data */
261
262                 if (write_data)
263                         outsl(ap->ioaddr.data_addr, buf, buflen >> 2);
264                 else
265                         insl(ap->ioaddr.data_addr, buf, buflen >> 2);
266
267                 if (unlikely(slop)) {
268                         u32 pad;
269                         if (write_data) {
270                                 memcpy(&pad, buf + buflen - slop, slop);
271                                 outl(le32_to_cpu(pad), ap->ioaddr.data_addr);
272                         } else {
273                                 pad = cpu_to_le16(inl(ap->ioaddr.data_addr));
274                                 memcpy(buf + buflen - slop, &pad, slop);
275                         }
276                 }
277                 local_irq_restore(flags);
278         }
279         else
280                 ata_pio_data_xfer_noirq(adev, buf, buflen, write_data);
281 }
282
283 static struct ata_port_operations pdc20230_port_ops = {
284         .set_piomode    = pdc20230_set_piomode,
285
286         .port_disable   = ata_port_disable,
287         .tf_load        = ata_tf_load,
288         .tf_read        = ata_tf_read,
289         .check_status   = ata_check_status,
290         .exec_command   = ata_exec_command,
291         .dev_select     = ata_std_dev_select,
292
293         .error_handler  = ata_bmdma_error_handler,
294
295         .qc_prep        = ata_qc_prep,
296         .qc_issue       = ata_qc_issue_prot,
297
298         .data_xfer      = pdc_data_xfer_vlb,
299
300         .irq_handler    = ata_interrupt,
301         .irq_clear      = ata_bmdma_irq_clear,
302
303         .port_start     = ata_port_start,
304 };
305
306 /*
307  *      Holtek 6560A support
308  *
309  *      This controller supports PIO0 to PIO2 (no IORDY even though higher timings
310  *      can be loaded).
311  */
312
313 static void ht6560a_set_piomode(struct ata_port *ap, struct ata_device *adev)
314 {
315         u8 active, recover;
316         struct ata_timing t;
317
318         /* Get the timing data in cycles. For now play safe at 50Mhz */
319         ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
320
321         active = FIT(t.active, 2, 15);
322         recover = FIT(t.recover, 4, 15);
323
324         inb(0x3E6);
325         inb(0x3E6);
326         inb(0x3E6);
327         inb(0x3E6);
328
329         outb(recover << 4 | active, ap->ioaddr.device_addr);
330         inb(ap->ioaddr.status_addr);
331 }
332
333 static struct ata_port_operations ht6560a_port_ops = {
334         .set_piomode    = ht6560a_set_piomode,
335
336         .port_disable   = ata_port_disable,
337         .tf_load        = ata_tf_load,
338         .tf_read        = ata_tf_read,
339         .check_status   = ata_check_status,
340         .exec_command   = ata_exec_command,
341         .dev_select     = ata_std_dev_select,
342
343         .error_handler  = ata_bmdma_error_handler,
344
345         .qc_prep        = ata_qc_prep,
346         .qc_issue       = ata_qc_issue_prot,
347
348         .data_xfer      = ata_pio_data_xfer,    /* Check vlb/noirq */
349
350         .irq_handler    = ata_interrupt,
351         .irq_clear      = ata_bmdma_irq_clear,
352
353         .port_start     = ata_port_start,
354 };
355
356 /*
357  *      Holtek 6560B support
358  *
359  *      This controller supports PIO0 to PIO4. We honour the BIOS/jumper FIFO setting
360  *      unless we see an ATAPI device in which case we force it off.
361  *
362  *      FIXME: need to implement 2nd channel support.
363  */
364
365 static void ht6560b_set_piomode(struct ata_port *ap, struct ata_device *adev)
366 {
367         u8 active, recover;
368         struct ata_timing t;
369
370         /* Get the timing data in cycles. For now play safe at 50Mhz */
371         ata_timing_compute(adev, adev->pio_mode, &t, 20000, 1000);
372
373         active = FIT(t.active, 2, 15);
374         recover = FIT(t.recover, 2, 16);
375         recover &= 0x15;
376
377         inb(0x3E6);
378         inb(0x3E6);
379         inb(0x3E6);
380         inb(0x3E6);
381
382         outb(recover << 4 | active, ap->ioaddr.device_addr);
383
384         if (adev->class != ATA_DEV_ATA) {
385                 u8 rconf = inb(0x3E6);
386                 if (rconf & 0x24) {
387                         rconf &= ~ 0x24;
388                         outb(rconf, 0x3E6);
389                 }
390         }
391         inb(ap->ioaddr.status_addr);
392 }
393
394 static struct ata_port_operations ht6560b_port_ops = {
395         .set_piomode    = ht6560b_set_piomode,
396
397         .port_disable   = ata_port_disable,
398         .tf_load        = ata_tf_load,
399         .tf_read        = ata_tf_read,
400         .check_status   = ata_check_status,
401         .exec_command   = ata_exec_command,
402         .dev_select     = ata_std_dev_select,
403
404         .error_handler  = ata_bmdma_error_handler,
405
406         .qc_prep        = ata_qc_prep,
407         .qc_issue       = ata_qc_issue_prot,
408
409         .data_xfer      = ata_pio_data_xfer,    /* FIXME: Check 32bit and noirq */
410
411         .irq_handler    = ata_interrupt,
412         .irq_clear      = ata_bmdma_irq_clear,
413
414         .port_start     = ata_port_start,
415 };
416
417 /*
418  *      Opti core chipset helpers
419  */
420
421 /**
422  *      opti_syscfg     -       read OPTI chipset configuration
423  *      @reg: Configuration register to read
424  *
425  *      Returns the value of an OPTI system board configuration register.
426  */
427
428 static u8 opti_syscfg(u8 reg)
429 {
430         unsigned long flags;
431         u8 r;
432
433         /* Uniprocessor chipset and must force cycles adjancent */
434         local_irq_save(flags);
435         outb(reg, 0x22);
436         r = inb(0x24);
437         local_irq_restore(flags);
438         return r;
439 }
440
441 /*
442  *      Opti 82C611A
443  *
444  *      This controller supports PIO0 to PIO3.
445  */
446
447 static void opti82c611a_set_piomode(struct ata_port *ap, struct ata_device *adev)
448 {
449         u8 active, recover, setup;
450         struct ata_timing t;
451         struct ata_device *pair = ata_dev_pair(adev);
452         int clock;
453         int khz[4] = { 50000, 40000, 33000, 25000 };
454         u8 rc;
455
456         /* Enter configuration mode */
457         inw(ap->ioaddr.error_addr);
458         inw(ap->ioaddr.error_addr);
459         outb(3, ap->ioaddr.nsect_addr);
460
461         /* Read VLB clock strapping */
462         clock = 1000000000 / khz[inb(ap->ioaddr.lbah_addr) & 0x03];
463
464         /* Get the timing data in cycles */
465         ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);
466
467         /* Setup timing is shared */
468         if (pair) {
469                 struct ata_timing tp;
470                 ata_timing_compute(pair, pair->pio_mode, &tp, clock, 1000);
471
472                 ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
473         }
474
475         active = FIT(t.active, 2, 17) - 2;
476         recover = FIT(t.recover, 1, 16) - 1;
477         setup = FIT(t.setup, 1, 4) - 1;
478
479         /* Select the right timing bank for write timing */
480         rc = inb(ap->ioaddr.lbal_addr);
481         rc &= 0x7F;
482         rc |= (adev->devno << 7);
483         outb(rc, ap->ioaddr.lbal_addr);
484
485         /* Write the timings */
486         outb(active << 4 | recover, ap->ioaddr.error_addr);
487
488         /* Select the right bank for read timings, also
489            load the shared timings for address */
490         rc = inb(ap->ioaddr.device_addr);
491         rc &= 0xC0;
492         rc |= adev->devno;      /* Index select */
493         rc |= (setup << 4) | 0x04;
494         outb(rc, ap->ioaddr.device_addr);
495
496         /* Load the read timings */
497         outb(active << 4 | recover, ap->ioaddr.data_addr);
498
499         /* Ensure the timing register mode is right */
500         rc = inb (ap->ioaddr.lbal_addr);
501         rc &= 0x73;
502         rc |= 0x84;
503         outb(rc, ap->ioaddr.lbal_addr);
504
505         /* Exit command mode */
506         outb(0x83,  ap->ioaddr.nsect_addr);
507 }
508
509
510 static struct ata_port_operations opti82c611a_port_ops = {
511         .set_piomode    = opti82c611a_set_piomode,
512
513         .port_disable   = ata_port_disable,
514         .tf_load        = ata_tf_load,
515         .tf_read        = ata_tf_read,
516         .check_status   = ata_check_status,
517         .exec_command   = ata_exec_command,
518         .dev_select     = ata_std_dev_select,
519
520         .error_handler  = ata_bmdma_error_handler,
521
522         .qc_prep        = ata_qc_prep,
523         .qc_issue       = ata_qc_issue_prot,
524
525         .data_xfer      = ata_pio_data_xfer,
526
527         .irq_handler    = ata_interrupt,
528         .irq_clear      = ata_bmdma_irq_clear,
529
530         .port_start     = ata_port_start,
531 };
532
533 /*
534  *      Opti 82C465MV
535  *
536  *      This controller supports PIO0 to PIO3. Unlike the 611A the MVB
537  *      version is dual channel but doesn't have a lot of unique registers.
538  */
539
540 static void opti82c46x_set_piomode(struct ata_port *ap, struct ata_device *adev)
541 {
542         u8 active, recover, setup;
543         struct ata_timing t;
544         struct ata_device *pair = ata_dev_pair(adev);
545         int clock;
546         int khz[4] = { 50000, 40000, 33000, 25000 };
547         u8 rc;
548         u8 sysclk;
549
550         /* Get the clock */
551         sysclk = opti_syscfg(0xAC) & 0xC0;      /* BIOS set */
552
553         /* Enter configuration mode */
554         inw(ap->ioaddr.error_addr);
555         inw(ap->ioaddr.error_addr);
556         outb(3, ap->ioaddr.nsect_addr);
557
558         /* Read VLB clock strapping */
559         clock = 1000000000 / khz[sysclk];
560
561         /* Get the timing data in cycles */
562         ata_timing_compute(adev, adev->pio_mode, &t, clock, 1000);
563
564         /* Setup timing is shared */
565         if (pair) {
566                 struct ata_timing tp;
567                 ata_timing_compute(pair, pair->pio_mode, &tp, clock, 1000);
568
569                 ata_timing_merge(&t, &tp, &t, ATA_TIMING_SETUP);
570         }
571
572         active = FIT(t.active, 2, 17) - 2;
573         recover = FIT(t.recover, 1, 16) - 1;
574         setup = FIT(t.setup, 1, 4) - 1;
575
576         /* Select the right timing bank for write timing */
577         rc = inb(ap->ioaddr.lbal_addr);
578         rc &= 0x7F;
579         rc |= (adev->devno << 7);
580         outb(rc, ap->ioaddr.lbal_addr);
581
582         /* Write the timings */
583         outb(active << 4 | recover, ap->ioaddr.error_addr);
584
585         /* Select the right bank for read timings, also
586            load the shared timings for address */
587         rc = inb(ap->ioaddr.device_addr);
588         rc &= 0xC0;
589         rc |= adev->devno;      /* Index select */
590         rc |= (setup << 4) | 0x04;
591         outb(rc, ap->ioaddr.device_addr);
592
593         /* Load the read timings */
594         outb(active << 4 | recover, ap->ioaddr.data_addr);
595
596         /* Ensure the timing register mode is right */
597         rc = inb (ap->ioaddr.lbal_addr);
598         rc &= 0x73;
599         rc |= 0x84;
600         outb(rc, ap->ioaddr.lbal_addr);
601
602         /* Exit command mode */
603         outb(0x83,  ap->ioaddr.nsect_addr);
604
605         /* We need to know this for quad device on the MVB */
606         ap->host->private_data = ap;
607 }
608
609 /**
610  *      opt82c465mv_qc_issue_prot       -       command issue
611  *      @qc: command pending
612  *
613  *      Called when the libata layer is about to issue a command. We wrap
614  *      this interface so that we can load the correct ATA timings. The
615  *      MVB has a single set of timing registers and these are shared
616  *      across channels. As there are two registers we really ought to
617  *      track the last two used values as a sort of register window. For
618  *      now we just reload on a channel switch. On the single channel
619  *      setup this condition never fires so we do nothing extra.
620  *
621  *      FIXME: dual channel needs ->serialize support
622  */
623
624 static unsigned int opti82c46x_qc_issue_prot(struct ata_queued_cmd *qc)
625 {
626         struct ata_port *ap = qc->ap;
627         struct ata_device *adev = qc->dev;
628
629         /* If timings are set and for the wrong channel (2nd test is
630            due to a libata shortcoming and will eventually go I hope) */
631         if (ap->host->private_data != ap->host
632             && ap->host->private_data != NULL)
633                 opti82c46x_set_piomode(ap, adev);
634
635         return ata_qc_issue_prot(qc);
636 }
637
638 static struct ata_port_operations opti82c46x_port_ops = {
639         .set_piomode    = opti82c46x_set_piomode,
640
641         .port_disable   = ata_port_disable,
642         .tf_load        = ata_tf_load,
643         .tf_read        = ata_tf_read,
644         .check_status   = ata_check_status,
645         .exec_command   = ata_exec_command,
646         .dev_select     = ata_std_dev_select,
647
648         .error_handler  = ata_bmdma_error_handler,
649
650         .qc_prep        = ata_qc_prep,
651         .qc_issue       = opti82c46x_qc_issue_prot,
652
653         .data_xfer      = ata_pio_data_xfer,
654
655         .irq_handler    = ata_interrupt,
656         .irq_clear      = ata_bmdma_irq_clear,
657
658         .port_start     = ata_port_start,
659 };
660
661
662 /**
663  *      legacy_init_one         -       attach a legacy interface
664  *      @port: port number
665  *      @io: I/O port start
666  *      @ctrl: control port
667  *      @irq: interrupt line
668  *
669  *      Register an ISA bus IDE interface. Such interfaces are PIO and we
670  *      assume do not support IRQ sharing.
671  */
672
673 static __init int legacy_init_one(int port, unsigned long io, unsigned long ctrl, int irq)
674 {
675         struct legacy_data *ld = &legacy_data[nr_legacy_host];
676         struct ata_probe_ent ae;
677         struct platform_device *pdev;
678         struct ata_port_operations *ops = &legacy_port_ops;
679         int pio_modes = pio_mask;
680         u32 mask = (1 << port);
681         int ret;
682
683         pdev = platform_device_register_simple(DRV_NAME, nr_legacy_host, NULL, 0);
684         if (IS_ERR(pdev))
685                 return PTR_ERR(pdev);
686
687         ret = -EBUSY;
688         if (devm_request_region(&pdev->dev, io, 8, "pata_legacy") == NULL ||
689             devm_request_region(&pdev->dev, ctrl, 1, "pata_legacy") == NULL)
690                 goto fail;
691
692         if (ht6560a & mask) {
693                 ops = &ht6560a_port_ops;
694                 pio_modes = 0x07;
695         }
696         if (ht6560b & mask) {
697                 ops = &ht6560b_port_ops;
698                 pio_modes = 0x1F;
699         }
700         if (opti82c611a & mask) {
701                 ops = &opti82c611a_port_ops;
702                 pio_modes = 0x0F;
703         }
704         if (opti82c46x & mask) {
705                 ops = &opti82c46x_port_ops;
706                 pio_modes = 0x0F;
707         }
708
709         /* Probe for automatically detectable controllers */
710
711         if (io == 0x1F0 && ops == &legacy_port_ops) {
712                 unsigned long flags;
713
714                 local_irq_save(flags);
715
716                 /* Probes */
717                 inb(0x1F5);
718                 outb(inb(0x1F2) | 0x80, 0x1F2);
719                 inb(0x1F2);
720                 inb(0x3F6);
721                 inb(0x3F6);
722                 inb(0x1F2);
723                 inb(0x1F2);
724
725                 if ((inb(0x1F2) & 0x80) == 0) {
726                         /* PDC20230c or 20630 ? */
727                         printk(KERN_INFO "PDC20230-C/20630 VLB ATA controller detected.\n");
728                                 pio_modes = 0x07;
729                         ops = &pdc20230_port_ops;
730                         udelay(100);
731                         inb(0x1F5);
732                 } else {
733                         outb(0x55, 0x1F2);
734                         inb(0x1F2);
735                         inb(0x1F2);
736                         if (inb(0x1F2) == 0x00) {
737                                 printk(KERN_INFO "PDC20230-B VLB ATA controller detected.\n");
738                         }
739                 }
740                 local_irq_restore(flags);
741         }
742
743
744         /* Chip does mode setting by command snooping */
745         if (ops == &legacy_port_ops && (autospeed & mask))
746                 ops = &simple_port_ops;
747         memset(&ae, 0, sizeof(struct ata_probe_ent));
748         INIT_LIST_HEAD(&ae.node);
749         ae.dev = &pdev->dev;
750         ae.port_ops = ops;
751         ae.sht = &legacy_sht;
752         ae.n_ports = 1;
753         ae.pio_mask = pio_modes;
754         ae.irq = irq;
755         ae.irq_flags = 0;
756         ae.port_flags = ATA_FLAG_SLAVE_POSS|ATA_FLAG_SRST;
757         ae.port[0].cmd_addr = io;
758         ae.port[0].altstatus_addr = ctrl;
759         ae.port[0].ctl_addr =   ctrl;
760         ata_std_ports(&ae.port[0]);
761         ae.private_data = ld;
762
763         ret = -ENODEV;
764         if (!ata_device_add(&ae))
765                 goto fail;
766
767         legacy_host[nr_legacy_host++] = dev_get_drvdata(&pdev->dev);
768         ld->platform_dev = pdev;
769         return 0;
770
771 fail:
772         platform_device_unregister(pdev);
773         return ret;
774 }
775
776 /**
777  *      legacy_check_special_cases      -       ATA special cases
778  *      @p: PCI device to check
779  *      @master: set this if we find an ATA master
780  *      @master: set this if we find an ATA secondary
781  *
782  *      A small number of vendors implemented early PCI ATA interfaces on bridge logic
783  *      without the ATA interface being PCI visible. Where we have a matching PCI driver
784  *      we must skip the relevant device here. If we don't know about it then the legacy
785  *      driver is the right driver anyway.
786  */
787
788 static void legacy_check_special_cases(struct pci_dev *p, int *primary, int *secondary)
789 {
790         /* Cyrix CS5510 pre SFF MWDMA ATA on the bridge */
791         if (p->vendor == 0x1078 && p->device == 0x0000) {
792                 *primary = *secondary = 1;
793                 return;
794         }
795         /* Cyrix CS5520 pre SFF MWDMA ATA on the bridge */
796         if (p->vendor == 0x1078 && p->device == 0x0002) {
797                 *primary = *secondary = 1;
798                 return;
799         }
800         /* Intel MPIIX - PIO ATA on non PCI side of bridge */
801         if (p->vendor == 0x8086 && p->device == 0x1234) {
802                 u16 r;
803                 pci_read_config_word(p, 0x6C, &r);
804                 if (r & 0x8000) {       /* ATA port enabled */
805                         if (r & 0x4000)
806                                 *secondary = 1;
807                         else
808                                 *primary = 1;
809                 }
810                 return;
811         }
812 }
813
814
815 /**
816  *      legacy_init             -       attach legacy interfaces
817  *
818  *      Attach legacy IDE interfaces by scanning the usual IRQ/port suspects.
819  *      Right now we do not scan the ide0 and ide1 address but should do so
820  *      for non PCI systems or systems with no PCI IDE legacy mode devices.
821  *      If you fix that note there are special cases to consider like VLB
822  *      drivers and CS5510/20.
823  */
824
825 static __init int legacy_init(void)
826 {
827         int i;
828         int ct = 0;
829         int primary = 0;
830         int secondary = 0;
831         int last_port = NR_HOST;
832
833         struct pci_dev *p = NULL;
834
835         for_each_pci_dev(p) {
836                 int r;
837                 /* Check for any overlap of the system ATA mappings. Native mode controllers
838                    stuck on these addresses or some devices in 'raid' mode won't be found by
839                    the storage class test */
840                 for (r = 0; r < 6; r++) {
841                         if (pci_resource_start(p, r) == 0x1f0)
842                                 primary = 1;
843                         if (pci_resource_start(p, r) == 0x170)
844                                 secondary = 1;
845                 }
846                 /* Check for special cases */
847                 legacy_check_special_cases(p, &primary, &secondary);
848
849                 /* If PCI bus is present then don't probe for tertiary legacy ports */
850                 if (probe_all == 0)
851                         last_port = 2;
852         }
853
854         /* If an OPTI 82C46X is present find out where the channels are */
855         if (opti82c46x) {
856                 static const char *optis[4] = {
857                         "3/463MV", "5MV",
858                         "5MVA", "5MVB"
859                 };
860                 u8 chans = 1;
861                 u8 ctrl = (opti_syscfg(0x30) & 0xC0) >> 6;
862
863                 opti82c46x = 3; /* Assume master and slave first */
864                 printk(KERN_INFO DRV_NAME ": Opti 82C46%s chipset support.\n", optis[ctrl]);
865                 if (ctrl == 3)
866                         chans = (opti_syscfg(0x3F) & 0x20) ? 2 : 1;
867                 ctrl = opti_syscfg(0xAC);
868                 /* Check enabled and this port is the 465MV port. On the
869                    MVB we may have two channels */
870                 if (ctrl & 8) {
871                         if (ctrl & 4)
872                                 opti82c46x = 2; /* Slave */
873                         else
874                                 opti82c46x = 1; /* Master */
875                         if (chans == 2)
876                                 opti82c46x = 3; /* Master and Slave */
877                 }       /* Slave only */
878                 else if (chans == 1)
879                         opti82c46x = 1;
880         }
881
882         for (i = 0; i < last_port; i++) {
883                 /* Skip primary if we have seen a PCI one */
884                 if (i == 0 && primary == 1)
885                         continue;
886                 /* Skip secondary if we have seen a PCI one */
887                 if (i == 1 && secondary == 1)
888                         continue;
889                 if (legacy_init_one(i, legacy_port[i],
890                                    legacy_port[i] + 0x0206,
891                                    legacy_irq[i]) == 0)
892                         ct++;
893         }
894         if (ct != 0)
895                 return 0;
896         return -ENODEV;
897 }
898
899 static __exit void legacy_exit(void)
900 {
901         int i;
902
903         for (i = 0; i < nr_legacy_host; i++) {
904                 struct legacy_data *ld = &legacy_data[i];
905
906                 ata_host_detach(legacy_host[i]);
907                 platform_device_unregister(ld->platform_dev);
908                 if (ld->timing)
909                         release_region(ld->timing, 2);
910         }
911 }
912
913 MODULE_AUTHOR("Alan Cox");
914 MODULE_DESCRIPTION("low-level driver for legacy ATA");
915 MODULE_LICENSE("GPL");
916 MODULE_VERSION(DRV_VERSION);
917
918 module_param(probe_all, int, 0);
919 module_param(autospeed, int, 0);
920 module_param(ht6560a, int, 0);
921 module_param(ht6560b, int, 0);
922 module_param(opti82c611a, int, 0);
923 module_param(opti82c46x, int, 0);
924 module_param(pio_mask, int, 0);
925
926 module_init(legacy_init);
927 module_exit(legacy_exit);
928