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