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