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