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