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