drivers/ata/pata_legacy.c

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