drivers/scsi/libata-core.c

   1 /*
   2    libata-core.c - helper library for ATA
   3
   4    Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   5    Copyright 2003-2004 Jeff Garzik
   6
   7    The contents of this file are subject to the Open
   8    Software License version 1.1 that can be found at
   9    http://www.opensource.org/licenses/osl-1.1.txt and is included herein
  10    by reference.
  11
  12    Alternatively, the contents of this file may be used under the terms
  13    of the GNU General Public License version 2 (the "GPL") as distributed
  14    in the kernel source COPYING file, in which case the provisions of
  15    the GPL are applicable instead of the above.  If you wish to allow
  16    the use of your version of this file only under the terms of the
  17    GPL and not to allow others to use your version of this file under
  18    the OSL, indicate your decision by deleting the provisions above and
  19    replace them with the notice and other provisions required by the GPL.
  20    If you do not delete the provisions above, a recipient may use your
  21    version of this file under either the OSL or the GPL.
  22
  23  */
  24
  25 #include <linux/config.h>
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/pci.h>
  29 #include <linux/init.h>
  30 #include <linux/list.h>
  31 #include <linux/highmem.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/blkdev.h>
  34 #include <linux/delay.h>
  35 #include <linux/timer.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/completion.h>
  38 #include <linux/suspend.h>
  39 #include <linux/workqueue.h>
  40 #include <scsi/scsi.h>
  41 #include "scsi.h"
  42 #include "scsi_priv.h"
  43 #include <scsi/scsi_host.h>
  44 #include <linux/libata.h>
  45 #include <asm/io.h>
  46 #include <asm/semaphore.h>
  47 #include <asm/byteorder.h>
  48
  49 #include "libata.h"
  50
  51 static unsigned int ata_busy_sleep (struct ata_port *ap,
  52                                     unsigned long tmout_pat,
  53                                     unsigned long tmout);
  54 static void ata_set_mode(struct ata_port *ap);
  55 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
  56 static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift);
  57 static int fgb(u32 bitmap);
  58 static int ata_choose_xfer_mode(struct ata_port *ap,
  59                                 u8 *xfer_mode_out,
  60                                 unsigned int *xfer_shift_out);
  61 static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat);
  62 static void __ata_qc_complete(struct ata_queued_cmd *qc);
  63
  64 static unsigned int ata_unique_id = 1;
  65 static struct workqueue_struct *ata_wq;
  66
  67 MODULE_AUTHOR("Jeff Garzik");
  68 MODULE_DESCRIPTION("Library module for ATA devices");
  69 MODULE_LICENSE("GPL");
  70 MODULE_VERSION(DRV_VERSION);
  71
  72 /**
  73  *      ata_tf_load - send taskfile registers to host controller
  74  *      @ap: Port to which output is sent
  75  *      @tf: ATA taskfile register set
  76  *
  77  *      Outputs ATA taskfile to standard ATA host controller.
  78  *
  79  *      LOCKING:
  80  *      Inherited from caller.
  81  */
  82
  83 static void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
  84 {
  85         struct ata_ioports *ioaddr = &ap->ioaddr;
  86         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
  87
  88         if (tf->ctl != ap->last_ctl) {
  89                 outb(tf->ctl, ioaddr->ctl_addr);
  90                 ap->last_ctl = tf->ctl;
  91                 ata_wait_idle(ap);
  92         }
  93
  94         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
  95                 outb(tf->hob_feature, ioaddr->feature_addr);
  96                 outb(tf->hob_nsect, ioaddr->nsect_addr);
  97                 outb(tf->hob_lbal, ioaddr->lbal_addr);
  98                 outb(tf->hob_lbam, ioaddr->lbam_addr);
  99                 outb(tf->hob_lbah, ioaddr->lbah_addr);
 100                 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
 101                         tf->hob_feature,
 102                         tf->hob_nsect,
 103                         tf->hob_lbal,
 104                         tf->hob_lbam,
 105                         tf->hob_lbah);
 106         }
 107
 108         if (is_addr) {
 109                 outb(tf->feature, ioaddr->feature_addr);
 110                 outb(tf->nsect, ioaddr->nsect_addr);
 111                 outb(tf->lbal, ioaddr->lbal_addr);
 112                 outb(tf->lbam, ioaddr->lbam_addr);
 113                 outb(tf->lbah, ioaddr->lbah_addr);
 114                 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
 115                         tf->feature,
 116                         tf->nsect,
 117                         tf->lbal,
 118                         tf->lbam,
 119                         tf->lbah);
 120         }
 121
 122         if (tf->flags & ATA_TFLAG_DEVICE) {
 123                 outb(tf->device, ioaddr->device_addr);
 124                 VPRINTK("device 0x%X\n", tf->device);
 125         }
 126
 127         ata_wait_idle(ap);
 128 }
 129
 130 /**
 131  *      ata_tf_load_mmio - send taskfile registers to host controller
 132  *      @ap: Port to which output is sent
 133  *      @tf: ATA taskfile register set
 134  *
 135  *      Outputs ATA taskfile to standard ATA host controller using MMIO.
 136  *
 137  *      LOCKING:
 138  *      Inherited from caller.
 139  */
 140
 141 static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
 142 {
 143         struct ata_ioports *ioaddr = &ap->ioaddr;
 144         unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
 145
 146         if (tf->ctl != ap->last_ctl) {
 147                 writeb(tf->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
 148                 ap->last_ctl = tf->ctl;
 149                 ata_wait_idle(ap);
 150         }
 151
 152         if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
 153                 writeb(tf->hob_feature, (void __iomem *) ioaddr->feature_addr);
 154                 writeb(tf->hob_nsect, (void __iomem *) ioaddr->nsect_addr);
 155                 writeb(tf->hob_lbal, (void __iomem *) ioaddr->lbal_addr);
 156                 writeb(tf->hob_lbam, (void __iomem *) ioaddr->lbam_addr);
 157                 writeb(tf->hob_lbah, (void __iomem *) ioaddr->lbah_addr);
 158                 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
 159                         tf->hob_feature,
 160                         tf->hob_nsect,
 161                         tf->hob_lbal,
 162                         tf->hob_lbam,
 163                         tf->hob_lbah);
 164         }
 165
 166         if (is_addr) {
 167                 writeb(tf->feature, (void __iomem *) ioaddr->feature_addr);
 168                 writeb(tf->nsect, (void __iomem *) ioaddr->nsect_addr);
 169                 writeb(tf->lbal, (void __iomem *) ioaddr->lbal_addr);
 170                 writeb(tf->lbam, (void __iomem *) ioaddr->lbam_addr);
 171                 writeb(tf->lbah, (void __iomem *) ioaddr->lbah_addr);
 172                 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
 173                         tf->feature,
 174                         tf->nsect,
 175                         tf->lbal,
 176                         tf->lbam,
 177                         tf->lbah);
 178         }
 179
 180         if (tf->flags & ATA_TFLAG_DEVICE) {
 181                 writeb(tf->device, (void __iomem *) ioaddr->device_addr);
 182                 VPRINTK("device 0x%X\n", tf->device);
 183         }
 184
 185         ata_wait_idle(ap);
 186 }
 187
 188 void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
 189 {
 190         if (ap->flags & ATA_FLAG_MMIO)
 191                 ata_tf_load_mmio(ap, tf);
 192         else
 193                 ata_tf_load_pio(ap, tf);
 194 }
 195
 196 /**
 197  *      ata_exec_command - issue ATA command to host controller
 198  *      @ap: port to which command is being issued
 199  *      @tf: ATA taskfile register set
 200  *
 201  *      Issues PIO/MMIO write to ATA command register, with proper
 202  *      synchronization with interrupt handler / other threads.
 203  *
 204  *      LOCKING:
 205  *      spin_lock_irqsave(host_set lock)
 206  */
 207
 208 static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
 209 {
 210         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
 211
 212         outb(tf->command, ap->ioaddr.command_addr);
 213         ata_pause(ap);
 214 }
 215
 216
 217 /**
 218  *      ata_exec_command_mmio - issue ATA command to host controller
 219  *      @ap: port to which command is being issued
 220  *      @tf: ATA taskfile register set
 221  *
 222  *      Issues MMIO write to ATA command register, with proper
 223  *      synchronization with interrupt handler / other threads.
 224  *
 225  *      LOCKING:
 226  *      spin_lock_irqsave(host_set lock)
 227  */
 228
 229 static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
 230 {
 231         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
 232
 233         writeb(tf->command, (void __iomem *) ap->ioaddr.command_addr);
 234         ata_pause(ap);
 235 }
 236
 237 void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
 238 {
 239         if (ap->flags & ATA_FLAG_MMIO)
 240                 ata_exec_command_mmio(ap, tf);
 241         else
 242                 ata_exec_command_pio(ap, tf);
 243 }
 244
 245 /**
 246  *      ata_exec - issue ATA command to host controller
 247  *      @ap: port to which command is being issued
 248  *      @tf: ATA taskfile register set
 249  *
 250  *      Issues PIO/MMIO write to ATA command register, with proper
 251  *      synchronization with interrupt handler / other threads.
 252  *
 253  *      LOCKING:
 254  *      Obtains host_set lock.
 255  */
 256
 257 static inline void ata_exec(struct ata_port *ap, struct ata_taskfile *tf)
 258 {
 259         unsigned long flags;
 260
 261         DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
 262         spin_lock_irqsave(&ap->host_set->lock, flags);
 263         ap->ops->exec_command(ap, tf);
 264         spin_unlock_irqrestore(&ap->host_set->lock, flags);
 265 }
 266
 267 /**
 268  *      ata_tf_to_host - issue ATA taskfile to host controller
 269  *      @ap: port to which command is being issued
 270  *      @tf: ATA taskfile register set
 271  *
 272  *      Issues ATA taskfile register set to ATA host controller,
 273  *      with proper synchronization with interrupt handler and
 274  *      other threads.
 275  *
 276  *      LOCKING:
 277  *      Obtains host_set lock.
 278  */
 279
 280 static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
 281 {
 282         ap->ops->tf_load(ap, tf);
 283
 284         ata_exec(ap, tf);
 285 }
 286
 287 /**
 288  *      ata_tf_to_host_nolock - issue ATA taskfile to host controller
 289  *      @ap: port to which command is being issued
 290  *      @tf: ATA taskfile register set
 291  *
 292  *      Issues ATA taskfile register set to ATA host controller,
 293  *      with proper synchronization with interrupt handler and
 294  *      other threads.
 295  *
 296  *      LOCKING:
 297  *      spin_lock_irqsave(host_set lock)
 298  */
 299
 300 void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
 301 {
 302         ap->ops->tf_load(ap, tf);
 303         ap->ops->exec_command(ap, tf);
 304 }
 305
 306 /**
 307  *      ata_tf_read - input device's ATA taskfile shadow registers
 308  *      @ap: Port from which input is read
 309  *      @tf: ATA taskfile register set for storing input
 310  *
 311  *      Reads ATA taskfile registers for currently-selected device
 312  *      into @tf.
 313  *
 314  *      LOCKING:
 315  *      Inherited from caller.
 316  */
 317
 318 static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
 319 {
 320         struct ata_ioports *ioaddr = &ap->ioaddr;
 321
 322         tf->nsect = inb(ioaddr->nsect_addr);
 323         tf->lbal = inb(ioaddr->lbal_addr);
 324         tf->lbam = inb(ioaddr->lbam_addr);
 325         tf->lbah = inb(ioaddr->lbah_addr);
 326         tf->device = inb(ioaddr->device_addr);
 327
 328         if (tf->flags & ATA_TFLAG_LBA48) {
 329                 outb(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
 330                 tf->hob_feature = inb(ioaddr->error_addr);
 331                 tf->hob_nsect = inb(ioaddr->nsect_addr);
 332                 tf->hob_lbal = inb(ioaddr->lbal_addr);
 333                 tf->hob_lbam = inb(ioaddr->lbam_addr);
 334                 tf->hob_lbah = inb(ioaddr->lbah_addr);
 335         }
 336 }
 337
 338 /**
 339  *      ata_tf_read_mmio - input device's ATA taskfile shadow registers
 340  *      @ap: Port from which input is read
 341  *      @tf: ATA taskfile register set for storing input
 342  *
 343  *      Reads ATA taskfile registers for currently-selected device
 344  *      into @tf via MMIO.
 345  *
 346  *      LOCKING:
 347  *      Inherited from caller.
 348  */
 349
 350 static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
 351 {
 352         struct ata_ioports *ioaddr = &ap->ioaddr;
 353
 354         tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
 355         tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
 356         tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
 357         tf->lbah = readb((void __iomem *)ioaddr->lbah_addr);
 358         tf->device = readb((void __iomem *)ioaddr->device_addr);
 359
 360         if (tf->flags & ATA_TFLAG_LBA48) {
 361                 writeb(tf->ctl | ATA_HOB, (void __iomem *) ap->ioaddr.ctl_addr);
 362                 tf->hob_feature = readb((void __iomem *)ioaddr->error_addr);
 363                 tf->hob_nsect = readb((void __iomem *)ioaddr->nsect_addr);
 364                 tf->hob_lbal = readb((void __iomem *)ioaddr->lbal_addr);
 365                 tf->hob_lbam = readb((void __iomem *)ioaddr->lbam_addr);
 366                 tf->hob_lbah = readb((void __iomem *)ioaddr->lbah_addr);
 367         }
 368 }
 369
 370 void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
 371 {
 372         if (ap->flags & ATA_FLAG_MMIO)
 373                 ata_tf_read_mmio(ap, tf);
 374         else
 375                 ata_tf_read_pio(ap, tf);
 376 }
 377
 378 /**
 379  *      ata_check_status - Read device status reg & clear interrupt
 380  *      @ap: port where the device is
 381  *
 382  *      Reads ATA taskfile status register for currently-selected device
 383  *      and return it's value. This also clears pending interrupts
 384  *      from this device
 385  *
 386  *      LOCKING:
 387  *      Inherited from caller.
 388  */
 389 static u8 ata_check_status_pio(struct ata_port *ap)
 390 {
 391         return inb(ap->ioaddr.status_addr);
 392 }
 393
 394 /**
 395  *      ata_check_status_mmio - Read device status reg & clear interrupt
 396  *      @ap: port where the device is
 397  *
 398  *      Reads ATA taskfile status register for currently-selected device
 399  *      via MMIO and return it's value. This also clears pending interrupts
 400  *      from this device
 401  *
 402  *      LOCKING:
 403  *      Inherited from caller.
 404  */
 405 static u8 ata_check_status_mmio(struct ata_port *ap)
 406 {
 407         return readb((void __iomem *) ap->ioaddr.status_addr);
 408 }
 409
 410 u8 ata_check_status(struct ata_port *ap)
 411 {
 412         if (ap->flags & ATA_FLAG_MMIO)
 413                 return ata_check_status_mmio(ap);
 414         return ata_check_status_pio(ap);
 415 }
 416
 417 /**
 418  *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
 419  *      @tf: Taskfile to convert
 420  *      @fis: Buffer into which data will output
 421  *      @pmp: Port multiplier port
 422  *
 423  *      Converts a standard ATA taskfile to a Serial ATA
 424  *      FIS structure (Register - Host to Device).
 425  *
 426  *      LOCKING:
 427  *      Inherited from caller.
 428  */
 429
 430 void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
 431 {
 432         fis[0] = 0x27;  /* Register - Host to Device FIS */
 433         fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
 434                                             bit 7 indicates Command FIS */
 435         fis[2] = tf->command;
 436         fis[3] = tf->feature;
 437
 438         fis[4] = tf->lbal;
 439         fis[5] = tf->lbam;
 440         fis[6] = tf->lbah;
 441         fis[7] = tf->device;
 442
 443         fis[8] = tf->hob_lbal;
 444         fis[9] = tf->hob_lbam;
 445         fis[10] = tf->hob_lbah;
 446         fis[11] = tf->hob_feature;
 447
 448         fis[12] = tf->nsect;
 449         fis[13] = tf->hob_nsect;
 450         fis[14] = 0;
 451         fis[15] = tf->ctl;
 452
 453         fis[16] = 0;
 454         fis[17] = 0;
 455         fis[18] = 0;
 456         fis[19] = 0;
 457 }
 458
 459 /**
 460  *      ata_tf_from_fis - Convert SATA FIS to ATA taskfile
 461  *      @fis: Buffer from which data will be input
 462  *      @tf: Taskfile to output
 463  *
 464  *      Converts a standard ATA taskfile to a Serial ATA
 465  *      FIS structure (Register - Host to Device).
 466  *
 467  *      LOCKING:
 468  *      Inherited from caller.
 469  */
 470
 471 void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf)
 472 {
 473         tf->command     = fis[2];       /* status */
 474         tf->feature     = fis[3];       /* error */
 475
 476         tf->lbal        = fis[4];
 477         tf->lbam        = fis[5];
 478         tf->lbah        = fis[6];
 479         tf->device      = fis[7];
 480
 481         tf->hob_lbal    = fis[8];
 482         tf->hob_lbam    = fis[9];
 483         tf->hob_lbah    = fis[10];
 484
 485         tf->nsect       = fis[12];
 486         tf->hob_nsect   = fis[13];
 487 }
 488
 489 /**
 490  *      ata_prot_to_cmd - determine which read/write opcodes to use
 491  *      @protocol: ATA_PROT_xxx taskfile protocol
 492  *      @lba48: true is lba48 is present
 493  *
 494  *      Given necessary input, determine which read/write commands
 495  *      to use to transfer data.
 496  *
 497  *      LOCKING:
 498  *      None.
 499  */
 500 static int ata_prot_to_cmd(int protocol, int lba48)
 501 {
 502         int rcmd = 0, wcmd = 0;
 503
 504         switch (protocol) {
 505         case ATA_PROT_PIO:
 506                 if (lba48) {
 507                         rcmd = ATA_CMD_PIO_READ_EXT;
 508                         wcmd = ATA_CMD_PIO_WRITE_EXT;
 509                 } else {
 510                         rcmd = ATA_CMD_PIO_READ;
 511                         wcmd = ATA_CMD_PIO_WRITE;
 512                 }
 513                 break;
 514
 515         case ATA_PROT_DMA:
 516                 if (lba48) {
 517                         rcmd = ATA_CMD_READ_EXT;
 518                         wcmd = ATA_CMD_WRITE_EXT;
 519                 } else {
 520                         rcmd = ATA_CMD_READ;
 521                         wcmd = ATA_CMD_WRITE;
 522                 }
 523                 break;
 524
 525         default:
 526                 return -1;
 527         }
 528
 529         return rcmd | (wcmd << 8);
 530 }
 531
 532 /**
 533  *      ata_dev_set_protocol - set taskfile protocol and r/w commands
 534  *      @dev: device to examine and configure
 535  *
 536  *      Examine the device configuration, after we have
 537  *      read the identify-device page and configured the
 538  *      data transfer mode.  Set internal state related to
 539  *      the ATA taskfile protocol (pio, pio mult, dma, etc.)
 540  *      and calculate the proper read/write commands to use.
 541  *
 542  *      LOCKING:
 543  *      caller.
 544  */
 545 static void ata_dev_set_protocol(struct ata_device *dev)
 546 {
 547         int pio = (dev->flags & ATA_DFLAG_PIO);
 548         int lba48 = (dev->flags & ATA_DFLAG_LBA48);
 549         int proto, cmd;
 550
 551         if (pio)
 552                 proto = dev->xfer_protocol = ATA_PROT_PIO;
 553         else
 554                 proto = dev->xfer_protocol = ATA_PROT_DMA;
 555
 556         cmd = ata_prot_to_cmd(proto, lba48);
 557         if (cmd < 0)
 558                 BUG();
 559
 560         dev->read_cmd = cmd & 0xff;
 561         dev->write_cmd = (cmd >> 8) & 0xff;
 562 }
 563
 564 static const char * xfer_mode_str[] = {
 565         "UDMA/16",
 566         "UDMA/25",
 567         "UDMA/33",
 568         "UDMA/44",
 569         "UDMA/66",
 570         "UDMA/100",
 571         "UDMA/133",
 572         "UDMA7",
 573         "MWDMA0",
 574         "MWDMA1",
 575         "MWDMA2",
 576         "PIO0",
 577         "PIO1",
 578         "PIO2",
 579         "PIO3",
 580         "PIO4",
 581 };
 582
 583 /**
 584  *      ata_udma_string - convert UDMA bit offset to string
 585  *      @mask: mask of bits supported; only highest bit counts.
 586  *
 587  *      Determine string which represents the highest speed
 588  *      (highest bit in @udma_mask).
 589  *
 590  *      LOCKING:
 591  *      None.
 592  *
 593  *      RETURNS:
 594  *      Constant C string representing highest speed listed in
 595  *      @udma_mask, or the constant C string "<n/a>".
 596  */
 597
 598 static const char *ata_mode_string(unsigned int mask)
 599 {
 600         int i;
 601
 602         for (i = 7; i >= 0; i--)
 603                 if (mask & (1 << i))
 604                         goto out;
 605         for (i = ATA_SHIFT_MWDMA + 2; i >= ATA_SHIFT_MWDMA; i--)
 606                 if (mask & (1 << i))
 607                         goto out;
 608         for (i = ATA_SHIFT_PIO + 4; i >= ATA_SHIFT_PIO; i--)
 609                 if (mask & (1 << i))
 610                         goto out;
 611
 612         return "<n/a>";
 613
 614 out:
 615         return xfer_mode_str[i];
 616 }
 617
 618 /**
 619  *      ata_pio_devchk - PATA device presence detection
 620  *      @ap: ATA channel to examine
 621  *      @device: Device to examine (starting at zero)
 622  *
 623  *      This technique was originally described in
 624  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
 625  *      later found its way into the ATA/ATAPI spec.
 626  *
 627  *      Write a pattern to the ATA shadow registers,
 628  *      and if a device is present, it will respond by
 629  *      correctly storing and echoing back the
 630  *      ATA shadow register contents.
 631  *
 632  *      LOCKING:
 633  *      caller.
 634  */
 635
 636 static unsigned int ata_pio_devchk(struct ata_port *ap,
 637                                    unsigned int device)
 638 {
 639         struct ata_ioports *ioaddr = &ap->ioaddr;
 640         u8 nsect, lbal;
 641
 642         ap->ops->dev_select(ap, device);
 643
 644         outb(0x55, ioaddr->nsect_addr);
 645         outb(0xaa, ioaddr->lbal_addr);
 646
 647         outb(0xaa, ioaddr->nsect_addr);
 648         outb(0x55, ioaddr->lbal_addr);
 649
 650         outb(0x55, ioaddr->nsect_addr);
 651         outb(0xaa, ioaddr->lbal_addr);
 652
 653         nsect = inb(ioaddr->nsect_addr);
 654         lbal = inb(ioaddr->lbal_addr);
 655
 656         if ((nsect == 0x55) && (lbal == 0xaa))
 657                 return 1;       /* we found a device */
 658
 659         return 0;               /* nothing found */
 660 }
 661
 662 /**
 663  *      ata_mmio_devchk - PATA device presence detection
 664  *      @ap: ATA channel to examine
 665  *      @device: Device to examine (starting at zero)
 666  *
 667  *      This technique was originally described in
 668  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
 669  *      later found its way into the ATA/ATAPI spec.
 670  *
 671  *      Write a pattern to the ATA shadow registers,
 672  *      and if a device is present, it will respond by
 673  *      correctly storing and echoing back the
 674  *      ATA shadow register contents.
 675  *
 676  *      LOCKING:
 677  *      caller.
 678  */
 679
 680 static unsigned int ata_mmio_devchk(struct ata_port *ap,
 681                                     unsigned int device)
 682 {
 683         struct ata_ioports *ioaddr = &ap->ioaddr;
 684         u8 nsect, lbal;
 685
 686         ap->ops->dev_select(ap, device);
 687
 688         writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
 689         writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
 690
 691         writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
 692         writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
 693
 694         writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
 695         writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
 696
 697         nsect = readb((void __iomem *) ioaddr->nsect_addr);
 698         lbal = readb((void __iomem *) ioaddr->lbal_addr);
 699
 700         if ((nsect == 0x55) && (lbal == 0xaa))
 701                 return 1;       /* we found a device */
 702
 703         return 0;               /* nothing found */
 704 }
 705
 706 /**
 707  *      ata_devchk - PATA device presence detection
 708  *      @ap: ATA channel to examine
 709  *      @device: Device to examine (starting at zero)
 710  *
 711  *      Dispatch ATA device presence detection, depending
 712  *      on whether we are using PIO or MMIO to talk to the
 713  *      ATA shadow registers.
 714  *
 715  *      LOCKING:
 716  *      caller.
 717  */
 718
 719 static unsigned int ata_devchk(struct ata_port *ap,
 720                                     unsigned int device)
 721 {
 722         if (ap->flags & ATA_FLAG_MMIO)
 723                 return ata_mmio_devchk(ap, device);
 724         return ata_pio_devchk(ap, device);
 725 }
 726
 727 /**
 728  *      ata_dev_classify - determine device type based on ATA-spec signature
 729  *      @tf: ATA taskfile register set for device to be identified
 730  *
 731  *      Determine from taskfile register contents whether a device is
 732  *      ATA or ATAPI, as per "Signature and persistence" section
 733  *      of ATA/PI spec (volume 1, sect 5.14).
 734  *
 735  *      LOCKING:
 736  *      None.
 737  *
 738  *      RETURNS:
 739  *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
 740  *      the event of failure.
 741  */
 742
 743 unsigned int ata_dev_classify(struct ata_taskfile *tf)
 744 {
 745         /* Apple's open source Darwin code hints that some devices only
 746          * put a proper signature into the LBA mid/high registers,
 747          * So, we only check those.  It's sufficient for uniqueness.
 748          */
 749
 750         if (((tf->lbam == 0) && (tf->lbah == 0)) ||
 751             ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
 752                 DPRINTK("found ATA device by sig\n");
 753                 return ATA_DEV_ATA;
 754         }
 755
 756         if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
 757             ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
 758                 DPRINTK("found ATAPI device by sig\n");
 759                 return ATA_DEV_ATAPI;
 760         }
 761
 762         DPRINTK("unknown device\n");
 763         return ATA_DEV_UNKNOWN;
 764 }
 765
 766 /**
 767  *      ata_dev_try_classify - Parse returned ATA device signature
 768  *      @ap: ATA channel to examine
 769  *      @device: Device to examine (starting at zero)
 770  *
 771  *      After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
 772  *      an ATA/ATAPI-defined set of values is placed in the ATA
 773  *      shadow registers, indicating the results of device detection
 774  *      and diagnostics.
 775  *
 776  *      Select the ATA device, and read the values from the ATA shadow
 777  *      registers.  Then parse according to the Error register value,
 778  *      and the spec-defined values examined by ata_dev_classify().
 779  *
 780  *      LOCKING:
 781  *      caller.
 782  */
 783
 784 static u8 ata_dev_try_classify(struct ata_port *ap, unsigned int device)
 785 {
 786         struct ata_device *dev = &ap->device[device];
 787         struct ata_taskfile tf;
 788         unsigned int class;
 789         u8 err;
 790
 791         ap->ops->dev_select(ap, device);
 792
 793         memset(&tf, 0, sizeof(tf));
 794
 795         err = ata_chk_err(ap);
 796         ap->ops->tf_read(ap, &tf);
 797
 798         dev->class = ATA_DEV_NONE;
 799
 800         /* see if device passed diags */
 801         if (err == 1)
 802                 /* do nothing */ ;
 803         else if ((device == 0) && (err == 0x81))
 804                 /* do nothing */ ;
 805         else
 806                 return err;
 807
 808         /* determine if device if ATA or ATAPI */
 809         class = ata_dev_classify(&tf);
 810         if (class == ATA_DEV_UNKNOWN)
 811                 return err;
 812         if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
 813                 return err;
 814
 815         dev->class = class;
 816
 817         return err;
 818 }
 819
 820 /**
 821  *      ata_dev_id_string - Convert IDENTIFY DEVICE page into string
 822  *      @id: IDENTIFY DEVICE results we will examine
 823  *      @s: string into which data is output
 824  *      @ofs: offset into identify device page
 825  *      @len: length of string to return. must be an even number.
 826  *
 827  *      The strings in the IDENTIFY DEVICE page are broken up into
 828  *      16-bit chunks.  Run through the string, and output each
 829  *      8-bit chunk linearly, regardless of platform.
 830  *
 831  *      LOCKING:
 832  *      caller.
 833  */
 834
 835 void ata_dev_id_string(u16 *id, unsigned char *s,
 836                        unsigned int ofs, unsigned int len)
 837 {
 838         unsigned int c;
 839
 840         while (len > 0) {
 841                 c = id[ofs] >> 8;
 842                 *s = c;
 843                 s++;
 844
 845                 c = id[ofs] & 0xff;
 846                 *s = c;
 847                 s++;
 848
 849                 ofs++;
 850                 len -= 2;
 851         }
 852 }
 853
 854 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
 855 {
 856 }
 857
 858 /**
 859  *      ata_std_dev_select - Select device 0/1 on ATA bus
 860  *      @ap: ATA channel to manipulate
 861  *      @device: ATA device (numbered from zero) to select
 862  *
 863  *      Use the method defined in the ATA specification to
 864  *      make either device 0, or device 1, active on the
 865  *      ATA channel.
 866  *
 867  *      LOCKING:
 868  *      caller.
 869  */
 870
 871 void ata_std_dev_select (struct ata_port *ap, unsigned int device)
 872 {
 873         u8 tmp;
 874
 875         if (device == 0)
 876                 tmp = ATA_DEVICE_OBS;
 877         else
 878                 tmp = ATA_DEVICE_OBS | ATA_DEV1;
 879
 880         if (ap->flags & ATA_FLAG_MMIO) {
 881                 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
 882         } else {
 883                 outb(tmp, ap->ioaddr.device_addr);
 884         }
 885         ata_pause(ap);          /* needed; also flushes, for mmio */
 886 }
 887
 888 /**
 889  *      ata_dev_select - Select device 0/1 on ATA bus
 890  *      @ap: ATA channel to manipulate
 891  *      @device: ATA device (numbered from zero) to select
 892  *      @wait: non-zero to wait for Status register BSY bit to clear
 893  *      @can_sleep: non-zero if context allows sleeping
 894  *
 895  *      Use the method defined in the ATA specification to
 896  *      make either device 0, or device 1, active on the
 897  *      ATA channel.
 898  *
 899  *      This is a high-level version of ata_std_dev_select(),
 900  *      which additionally provides the services of inserting
 901  *      the proper pauses and status polling, where needed.
 902  *
 903  *      LOCKING:
 904  *      caller.
 905  */
 906
 907 void ata_dev_select(struct ata_port *ap, unsigned int device,
 908                            unsigned int wait, unsigned int can_sleep)
 909 {
 910         VPRINTK("ENTER, ata%u: device %u, wait %u\n",
 911                 ap->id, device, wait);
 912
 913         if (wait)
 914                 ata_wait_idle(ap);
 915
 916         ap->ops->dev_select(ap, device);
 917
 918         if (wait) {
 919                 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
 920                         msleep(150);
 921                 ata_wait_idle(ap);
 922         }
 923 }
 924
 925 /**
 926  *      ata_dump_id - IDENTIFY DEVICE info debugging output
 927  *      @dev: Device whose IDENTIFY DEVICE page we will dump
 928  *
 929  *      Dump selected 16-bit words from a detected device's
 930  *      IDENTIFY PAGE page.
 931  *
 932  *      LOCKING:
 933  *      caller.
 934  */
 935
 936 static inline void ata_dump_id(struct ata_device *dev)
 937 {
 938         DPRINTK("49==0x%04x  "
 939                 "53==0x%04x  "
 940                 "63==0x%04x  "
 941                 "64==0x%04x  "
 942                 "75==0x%04x  \n",
 943                 dev->id[49],
 944                 dev->id[53],
 945                 dev->id[63],
 946                 dev->id[64],
 947                 dev->id[75]);
 948         DPRINTK("80==0x%04x  "
 949                 "81==0x%04x  "
 950                 "82==0x%04x  "
 951                 "83==0x%04x  "
 952                 "84==0x%04x  \n",
 953                 dev->id[80],
 954                 dev->id[81],
 955                 dev->id[82],
 956                 dev->id[83],
 957                 dev->id[84]);
 958         DPRINTK("88==0x%04x  "
 959                 "93==0x%04x\n",
 960                 dev->id[88],
 961                 dev->id[93]);
 962 }
 963
 964 /**
 965  *      ata_dev_identify - obtain IDENTIFY x DEVICE page
 966  *      @ap: port on which device we wish to probe resides
 967  *      @device: device bus address, starting at zero
 968  *
 969  *      Following bus reset, we issue the IDENTIFY [PACKET] DEVICE
 970  *      command, and read back the 512-byte device information page.
 971  *      The device information page is fed to us via the standard
 972  *      PIO-IN protocol, but we hand-code it here. (TODO: investigate
 973  *      using standard PIO-IN paths)
 974  *
 975  *      After reading the device information page, we use several
 976  *      bits of information from it to initialize data structures
 977  *      that will be used during the lifetime of the ata_device.
 978  *      Other data from the info page is used to disqualify certain
 979  *      older ATA devices we do not wish to support.
 980  *
 981  *      LOCKING:
 982  *      Inherited from caller.  Some functions called by this function
 983  *      obtain the host_set lock.
 984  */
 985
 986 static void ata_dev_identify(struct ata_port *ap, unsigned int device)
 987 {
 988         struct ata_device *dev = &ap->device[device];
 989         unsigned int i;
 990         u16 tmp;
 991         unsigned long xfer_modes;
 992         u8 status;
 993         unsigned int using_edd;
 994         DECLARE_COMPLETION(wait);
 995         struct ata_queued_cmd *qc;
 996         unsigned long flags;
 997         int rc;
 998
 999         if (!ata_dev_present(dev)) {
1000                 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
1001                         ap->id, device);
1002                 return;
1003         }
1004
1005         if (ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
1006                 using_edd = 0;
1007         else
1008                 using_edd = 1;
1009
1010         DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
1011
1012         assert (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ATAPI ||
1013                 dev->class == ATA_DEV_NONE);
1014
1015         ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
1016
1017         qc = ata_qc_new_init(ap, dev);
1018         BUG_ON(qc == NULL);
1019
1020         ata_sg_init_one(qc, dev->id, sizeof(dev->id));
1021         qc->dma_dir = DMA_FROM_DEVICE;
1022         qc->tf.protocol = ATA_PROT_PIO;
1023         qc->nsect = 1;
1024
1025 retry:
1026         if (dev->class == ATA_DEV_ATA) {
1027                 qc->tf.command = ATA_CMD_ID_ATA;
1028                 DPRINTK("do ATA identify\n");
1029         } else {
1030                 qc->tf.command = ATA_CMD_ID_ATAPI;
1031                 DPRINTK("do ATAPI identify\n");
1032         }
1033
1034         qc->waiting = &wait;
1035         qc->complete_fn = ata_qc_complete_noop;
1036
1037         spin_lock_irqsave(&ap->host_set->lock, flags);
1038         rc = ata_qc_issue(qc);
1039         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1040
1041         if (rc)
1042                 goto err_out;
1043         else
1044                 wait_for_completion(&wait);
1045
1046         status = ata_chk_status(ap);
1047         if (status & ATA_ERR) {
1048                 /*
1049                  * arg!  EDD works for all test cases, but seems to return
1050                  * the ATA signature for some ATAPI devices.  Until the
1051                  * reason for this is found and fixed, we fix up the mess
1052                  * here.  If IDENTIFY DEVICE returns command aborted
1053                  * (as ATAPI devices do), then we issue an
1054                  * IDENTIFY PACKET DEVICE.
1055                  *
1056                  * ATA software reset (SRST, the default) does not appear
1057                  * to have this problem.
1058                  */
1059                 if ((using_edd) && (qc->tf.command == ATA_CMD_ID_ATA)) {
1060                         u8 err = ata_chk_err(ap);
1061                         if (err & ATA_ABORTED) {
1062                                 dev->class = ATA_DEV_ATAPI;
1063                                 qc->cursg = 0;
1064                                 qc->cursg_ofs = 0;
1065                                 qc->cursect = 0;
1066                                 qc->nsect = 1;
1067                                 goto retry;
1068                         }
1069                 }
1070                 goto err_out;
1071         }
1072
1073         swap_buf_le16(dev->id, ATA_ID_WORDS);
1074
1075         /* print device capabilities */
1076         printk(KERN_DEBUG "ata%u: dev %u cfg "
1077                "49:%04x 82:%04x 83:%04x 84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1078                ap->id, device, dev->id[49],
1079                dev->id[82], dev->id[83], dev->id[84],
1080                dev->id[85], dev->id[86], dev->id[87],
1081                dev->id[88]);
1082
1083         /*
1084          * common ATA, ATAPI feature tests
1085          */
1086
1087         /* we require LBA and DMA support (bits 8 & 9 of word 49) */
1088         if (!ata_id_has_dma(dev->id) || !ata_id_has_lba(dev->id)) {
1089                 printk(KERN_DEBUG "ata%u: no dma/lba\n", ap->id);
1090                 goto err_out_nosup;
1091         }
1092
1093         /* quick-n-dirty find max transfer mode; for printk only */
1094         xfer_modes = dev->id[ATA_ID_UDMA_MODES];
1095         if (!xfer_modes)
1096                 xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
1097         if (!xfer_modes) {
1098                 xfer_modes = (dev->id[ATA_ID_PIO_MODES]) << (ATA_SHIFT_PIO + 3);
1099                 xfer_modes |= (0x7 << ATA_SHIFT_PIO);
1100         }
1101
1102         ata_dump_id(dev);
1103
1104         /* ATA-specific feature tests */
1105         if (dev->class == ATA_DEV_ATA) {
1106                 if (!ata_id_is_ata(dev->id))    /* sanity check */
1107                         goto err_out_nosup;
1108
1109                 tmp = dev->id[ATA_ID_MAJOR_VER];
1110                 for (i = 14; i >= 1; i--)
1111                         if (tmp & (1 << i))
1112                                 break;
1113
1114                 /* we require at least ATA-3 */
1115                 if (i < 3) {
1116                         printk(KERN_DEBUG "ata%u: no ATA-3\n", ap->id);
1117                         goto err_out_nosup;
1118                 }
1119
1120                 if (ata_id_has_lba48(dev->id)) {
1121                         dev->flags |= ATA_DFLAG_LBA48;
1122                         dev->n_sectors = ata_id_u64(dev->id, 100);
1123                 } else {
1124                         dev->n_sectors = ata_id_u32(dev->id, 60);
1125                 }
1126
1127                 ap->host->max_cmd_len = 16;
1128
1129                 /* print device info to dmesg */
1130                 printk(KERN_INFO "ata%u: dev %u ATA, max %s, %Lu sectors:%s\n",
1131                        ap->id, device,
1132                        ata_mode_string(xfer_modes),
1133                        (unsigned long long)dev->n_sectors,
1134                        dev->flags & ATA_DFLAG_LBA48 ? " lba48" : "");
1135         }
1136
1137         /* ATAPI-specific feature tests */
1138         else {
1139                 if (ata_id_is_ata(dev->id))             /* sanity check */
1140                         goto err_out_nosup;
1141
1142                 rc = atapi_cdb_len(dev->id);
1143                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1144                         printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
1145                         goto err_out_nosup;
1146                 }
1147                 ap->cdb_len = (unsigned int) rc;
1148                 ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
1149
1150                 /* print device info to dmesg */
1151                 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
1152                        ap->id, device,
1153                        ata_mode_string(xfer_modes));
1154         }
1155
1156         DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
1157         return;
1158
1159 err_out_nosup:
1160         printk(KERN_WARNING "ata%u: dev %u not supported, ignoring\n",
1161                ap->id, device);
1162 err_out:
1163         ata_irq_on(ap); /* re-enable interrupts */
1164         dev->class++;   /* converts ATA_DEV_xxx into ATA_DEV_xxx_UNSUP */
1165         DPRINTK("EXIT, err\n");
1166 }
1167
1168 /**
1169  *      ata_bus_probe - Reset and probe ATA bus
1170  *      @ap: Bus to probe
1171  *
1172  *      LOCKING:
1173  *
1174  *      RETURNS:
1175  *      Zero on success, non-zero on error.
1176  */
1177
1178 static int ata_bus_probe(struct ata_port *ap)
1179 {
1180         unsigned int i, found = 0;
1181
1182         ap->ops->phy_reset(ap);
1183         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1184                 goto err_out;
1185
1186         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1187                 ata_dev_identify(ap, i);
1188                 if (ata_dev_present(&ap->device[i])) {
1189                         found = 1;
1190                         if (ap->ops->dev_config)
1191                                 ap->ops->dev_config(ap, &ap->device[i]);
1192                 }
1193         }
1194
1195         if ((!found) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1196                 goto err_out_disable;
1197
1198         ata_set_mode(ap);
1199         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1200                 goto err_out_disable;
1201
1202         return 0;
1203
1204 err_out_disable:
1205         ap->ops->port_disable(ap);
1206 err_out:
1207         return -1;
1208 }
1209
1210 /**
1211  *      ata_port_probe -
1212  *      @ap:
1213  *
1214  *      LOCKING:
1215  */
1216
1217 void ata_port_probe(struct ata_port *ap)
1218 {
1219         ap->flags &= ~ATA_FLAG_PORT_DISABLED;
1220 }
1221
1222 /**
1223  *      __sata_phy_reset -
1224  *      @ap:
1225  *
1226  *      LOCKING:
1227  *
1228  */
1229 void __sata_phy_reset(struct ata_port *ap)
1230 {
1231         u32 sstatus;
1232         unsigned long timeout = jiffies + (HZ * 5);
1233
1234         if (ap->flags & ATA_FLAG_SATA_RESET) {
1235                 scr_write(ap, SCR_CONTROL, 0x301); /* issue phy wake/reset */
1236                 scr_read(ap, SCR_STATUS);       /* dummy read; flush */
1237                 udelay(400);                    /* FIXME: a guess */
1238         }
1239         scr_write(ap, SCR_CONTROL, 0x300);      /* issue phy wake/clear reset */
1240
1241         /* wait for phy to become ready, if necessary */
1242         do {
1243                 msleep(200);
1244                 sstatus = scr_read(ap, SCR_STATUS);
1245                 if ((sstatus & 0xf) != 1)
1246                         break;
1247         } while (time_before(jiffies, timeout));
1248
1249         /* TODO: phy layer with polling, timeouts, etc. */
1250         if (sata_dev_present(ap))
1251                 ata_port_probe(ap);
1252         else {
1253                 sstatus = scr_read(ap, SCR_STATUS);
1254                 printk(KERN_INFO "ata%u: no device found (phy stat %08x)\n",
1255                        ap->id, sstatus);
1256                 ata_port_disable(ap);
1257         }
1258
1259         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1260                 return;
1261
1262         if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1263                 ata_port_disable(ap);
1264                 return;
1265         }
1266
1267         ap->cbl = ATA_CBL_SATA;
1268 }
1269
1270 /**
1271  *      __sata_phy_reset -
1272  *      @ap:
1273  *
1274  *      LOCKING:
1275  *
1276  */
1277 void sata_phy_reset(struct ata_port *ap)
1278 {
1279         __sata_phy_reset(ap);
1280         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1281                 return;
1282         ata_bus_reset(ap);
1283 }
1284
1285 /**
1286  *      ata_port_disable -
1287  *      @ap:
1288  *
1289  *      LOCKING:
1290  */
1291
1292 void ata_port_disable(struct ata_port *ap)
1293 {
1294         ap->device[0].class = ATA_DEV_NONE;
1295         ap->device[1].class = ATA_DEV_NONE;
1296         ap->flags |= ATA_FLAG_PORT_DISABLED;
1297 }
1298
1299 static struct {
1300         unsigned int shift;
1301         u8 base;
1302 } xfer_mode_classes[] = {
1303         { ATA_SHIFT_UDMA,       XFER_UDMA_0 },
1304         { ATA_SHIFT_MWDMA,      XFER_MW_DMA_0 },
1305         { ATA_SHIFT_PIO,        XFER_PIO_0 },
1306 };
1307
1308 static inline u8 base_from_shift(unsigned int shift)
1309 {
1310         int i;
1311
1312         for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++)
1313                 if (xfer_mode_classes[i].shift == shift)
1314                         return xfer_mode_classes[i].base;
1315
1316         return 0xff;
1317 }
1318
1319 static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
1320 {
1321         int ofs, idx;
1322         u8 base;
1323
1324         if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1325                 return;
1326
1327         if (dev->xfer_shift == ATA_SHIFT_PIO)
1328                 dev->flags |= ATA_DFLAG_PIO;
1329
1330         ata_dev_set_xfermode(ap, dev);
1331
1332         base = base_from_shift(dev->xfer_shift);
1333         ofs = dev->xfer_mode - base;
1334         idx = ofs + dev->xfer_shift;
1335         WARN_ON(idx >= ARRAY_SIZE(xfer_mode_str));
1336
1337         DPRINTK("idx=%d xfer_shift=%u, xfer_mode=0x%x, base=0x%x, offset=%d\n",
1338                 idx, dev->xfer_shift, (int)dev->xfer_mode, (int)base, ofs);
1339
1340         printk(KERN_INFO "ata%u: dev %u configured for %s\n",
1341                 ap->id, dev->devno, xfer_mode_str[idx]);
1342 }
1343
1344 static int ata_host_set_pio(struct ata_port *ap)
1345 {
1346         unsigned int mask;
1347         int x, i;
1348         u8 base, xfer_mode;
1349
1350         mask = ata_get_mode_mask(ap, ATA_SHIFT_PIO);
1351         x = fgb(mask);
1352         if (x < 0) {
1353                 printk(KERN_WARNING "ata%u: no PIO support\n", ap->id);
1354                 return -1;
1355         }
1356
1357         base = base_from_shift(ATA_SHIFT_PIO);
1358         xfer_mode = base + x;
1359
1360         DPRINTK("base 0x%x xfer_mode 0x%x mask 0x%x x %d\n",
1361                 (int)base, (int)xfer_mode, mask, x);
1362
1363         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1364                 struct ata_device *dev = &ap->device[i];
1365                 if (ata_dev_present(dev)) {
1366                         dev->pio_mode = xfer_mode;
1367                         dev->xfer_mode = xfer_mode;
1368                         dev->xfer_shift = ATA_SHIFT_PIO;
1369                         if (ap->ops->set_piomode)
1370                                 ap->ops->set_piomode(ap, dev);
1371                 }
1372         }
1373
1374         return 0;
1375 }
1376
1377 static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
1378                             unsigned int xfer_shift)
1379 {
1380         int i;
1381
1382         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1383                 struct ata_device *dev = &ap->device[i];
1384                 if (ata_dev_present(dev)) {
1385                         dev->dma_mode = xfer_mode;
1386                         dev->xfer_mode = xfer_mode;
1387                         dev->xfer_shift = xfer_shift;
1388                         if (ap->ops->set_dmamode)
1389                                 ap->ops->set_dmamode(ap, dev);
1390                 }
1391         }
1392 }
1393
1394 /**
1395  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
1396  *      @ap: port on which timings will be programmed
1397  *
1398  *      LOCKING:
1399  *
1400  */
1401 static void ata_set_mode(struct ata_port *ap)
1402 {
1403         unsigned int i, xfer_shift;
1404         u8 xfer_mode;
1405         int rc;
1406
1407         /* step 1: always set host PIO timings */
1408         rc = ata_host_set_pio(ap);
1409         if (rc)
1410                 goto err_out;
1411
1412         /* step 2: choose the best data xfer mode */
1413         xfer_mode = xfer_shift = 0;
1414         rc = ata_choose_xfer_mode(ap, &xfer_mode, &xfer_shift);
1415         if (rc)
1416                 goto err_out;
1417
1418         /* step 3: if that xfer mode isn't PIO, set host DMA timings */
1419         if (xfer_shift != ATA_SHIFT_PIO)
1420                 ata_host_set_dma(ap, xfer_mode, xfer_shift);
1421
1422         /* step 4: update devices' xfer mode */
1423         ata_dev_set_mode(ap, &ap->device[0]);
1424         ata_dev_set_mode(ap, &ap->device[1]);
1425
1426         if (ap->flags & ATA_FLAG_PORT_DISABLED)
1427                 return;
1428
1429         if (ap->ops->post_set_mode)
1430                 ap->ops->post_set_mode(ap);
1431
1432         for (i = 0; i < 2; i++) {
1433                 struct ata_device *dev = &ap->device[i];
1434                 ata_dev_set_protocol(dev);
1435         }
1436
1437         return;
1438
1439 err_out:
1440         ata_port_disable(ap);
1441 }
1442
1443 /**
1444  *      ata_busy_sleep - sleep until BSY clears, or timeout
1445  *      @ap: port containing status register to be polled
1446  *      @tmout_pat: impatience timeout
1447  *      @tmout: overall timeout
1448  *
1449  *      LOCKING:
1450  *
1451  */
1452
1453 static unsigned int ata_busy_sleep (struct ata_port *ap,
1454                                     unsigned long tmout_pat,
1455                                     unsigned long tmout)
1456 {
1457         unsigned long timer_start, timeout;
1458         u8 status;
1459
1460         status = ata_busy_wait(ap, ATA_BUSY, 300);
1461         timer_start = jiffies;
1462         timeout = timer_start + tmout_pat;
1463         while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1464                 msleep(50);
1465                 status = ata_busy_wait(ap, ATA_BUSY, 3);
1466         }
1467
1468         if (status & ATA_BUSY)
1469                 printk(KERN_WARNING "ata%u is slow to respond, "
1470                        "please be patient\n", ap->id);
1471
1472         timeout = timer_start + tmout;
1473         while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1474                 msleep(50);
1475                 status = ata_chk_status(ap);
1476         }
1477
1478         if (status & ATA_BUSY) {
1479                 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
1480                        ap->id, tmout / HZ);
1481                 return 1;
1482         }
1483
1484         return 0;
1485 }
1486
1487 static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
1488 {
1489         struct ata_ioports *ioaddr = &ap->ioaddr;
1490         unsigned int dev0 = devmask & (1 << 0);
1491         unsigned int dev1 = devmask & (1 << 1);
1492         unsigned long timeout;
1493
1494         /* if device 0 was found in ata_devchk, wait for its
1495          * BSY bit to clear
1496          */
1497         if (dev0)
1498                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1499
1500         /* if device 1 was found in ata_devchk, wait for
1501          * register access, then wait for BSY to clear
1502          */
1503         timeout = jiffies + ATA_TMOUT_BOOT;
1504         while (dev1) {
1505                 u8 nsect, lbal;
1506
1507                 ap->ops->dev_select(ap, 1);
1508                 if (ap->flags & ATA_FLAG_MMIO) {
1509                         nsect = readb((void __iomem *) ioaddr->nsect_addr);
1510                         lbal = readb((void __iomem *) ioaddr->lbal_addr);
1511                 } else {
1512                         nsect = inb(ioaddr->nsect_addr);
1513                         lbal = inb(ioaddr->lbal_addr);
1514                 }
1515                 if ((nsect == 1) && (lbal == 1))
1516                         break;
1517                 if (time_after(jiffies, timeout)) {
1518                         dev1 = 0;
1519                         break;
1520                 }
1521                 msleep(50);     /* give drive a breather */
1522         }
1523         if (dev1)
1524                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1525
1526         /* is all this really necessary? */
1527         ap->ops->dev_select(ap, 0);
1528         if (dev1)
1529                 ap->ops->dev_select(ap, 1);
1530         if (dev0)
1531                 ap->ops->dev_select(ap, 0);
1532 }
1533
1534 /**
1535  *      ata_bus_edd -
1536  *      @ap:
1537  *
1538  *      LOCKING:
1539  *
1540  */
1541
1542 static unsigned int ata_bus_edd(struct ata_port *ap)
1543 {
1544         struct ata_taskfile tf;
1545
1546         /* set up execute-device-diag (bus reset) taskfile */
1547         /* also, take interrupts to a known state (disabled) */
1548         DPRINTK("execute-device-diag\n");
1549         ata_tf_init(ap, &tf, 0);
1550         tf.ctl |= ATA_NIEN;
1551         tf.command = ATA_CMD_EDD;
1552         tf.protocol = ATA_PROT_NODATA;
1553
1554         /* do bus reset */
1555         ata_tf_to_host(ap, &tf);
1556
1557         /* spec says at least 2ms.  but who knows with those
1558          * crazy ATAPI devices...
1559          */
1560         msleep(150);
1561
1562         return ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1563 }
1564
1565 static unsigned int ata_bus_softreset(struct ata_port *ap,
1566                                       unsigned int devmask)
1567 {
1568         struct ata_ioports *ioaddr = &ap->ioaddr;
1569
1570         DPRINTK("ata%u: bus reset via SRST\n", ap->id);
1571
1572         /* software reset.  causes dev0 to be selected */
1573         if (ap->flags & ATA_FLAG_MMIO) {
1574                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1575                 udelay(20);     /* FIXME: flush */
1576                 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
1577                 udelay(20);     /* FIXME: flush */
1578                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1579         } else {
1580                 outb(ap->ctl, ioaddr->ctl_addr);
1581                 udelay(10);
1582                 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
1583                 udelay(10);
1584                 outb(ap->ctl, ioaddr->ctl_addr);
1585         }
1586
1587         /* spec mandates ">= 2ms" before checking status.
1588          * We wait 150ms, because that was the magic delay used for
1589          * ATAPI devices in Hale Landis's ATADRVR, for the period of time
1590          * between when the ATA command register is written, and then
1591          * status is checked.  Because waiting for "a while" before
1592          * checking status is fine, post SRST, we perform this magic
1593          * delay here as well.
1594          */
1595         msleep(150);
1596
1597         ata_bus_post_reset(ap, devmask);
1598
1599         return 0;
1600 }
1601
1602 /**
1603  *      ata_bus_reset - reset host port and associated ATA channel
1604  *      @ap: port to reset
1605  *
1606  *      This is typically the first time we actually start issuing
1607  *      commands to the ATA channel.  We wait for BSY to clear, then
1608  *      issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
1609  *      result.  Determine what devices, if any, are on the channel
1610  *      by looking at the device 0/1 error register.  Look at the signature
1611  *      stored in each device's taskfile registers, to determine if
1612  *      the device is ATA or ATAPI.
1613  *
1614  *      LOCKING:
1615  *      Inherited from caller.  Some functions called by this function
1616  *      obtain the host_set lock.
1617  *
1618  *      SIDE EFFECTS:
1619  *      Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
1620  */
1621
1622 void ata_bus_reset(struct ata_port *ap)
1623 {
1624         struct ata_ioports *ioaddr = &ap->ioaddr;
1625         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
1626         u8 err;
1627         unsigned int dev0, dev1 = 0, rc = 0, devmask = 0;
1628
1629         DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
1630
1631         /* determine if device 0/1 are present */
1632         if (ap->flags & ATA_FLAG_SATA_RESET)
1633                 dev0 = 1;
1634         else {
1635                 dev0 = ata_devchk(ap, 0);
1636                 if (slave_possible)
1637                         dev1 = ata_devchk(ap, 1);
1638         }
1639
1640         if (dev0)
1641                 devmask |= (1 << 0);
1642         if (dev1)
1643                 devmask |= (1 << 1);
1644
1645         /* select device 0 again */
1646         ap->ops->dev_select(ap, 0);
1647
1648         /* issue bus reset */
1649         if (ap->flags & ATA_FLAG_SRST)
1650                 rc = ata_bus_softreset(ap, devmask);
1651         else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
1652                 /* set up device control */
1653                 if (ap->flags & ATA_FLAG_MMIO)
1654                         writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1655                 else
1656                         outb(ap->ctl, ioaddr->ctl_addr);
1657                 rc = ata_bus_edd(ap);
1658         }
1659
1660         if (rc)
1661                 goto err_out;
1662
1663         /*
1664          * determine by signature whether we have ATA or ATAPI devices
1665          */
1666         err = ata_dev_try_classify(ap, 0);
1667         if ((slave_possible) && (err != 0x81))
1668                 ata_dev_try_classify(ap, 1);
1669
1670         /* re-enable interrupts */
1671         ata_irq_on(ap);
1672
1673         /* is double-select really necessary? */
1674         if (ap->device[1].class != ATA_DEV_NONE)
1675                 ap->ops->dev_select(ap, 1);
1676         if (ap->device[0].class != ATA_DEV_NONE)
1677                 ap->ops->dev_select(ap, 0);
1678
1679         /* if no devices were detected, disable this port */
1680         if ((ap->device[0].class == ATA_DEV_NONE) &&
1681             (ap->device[1].class == ATA_DEV_NONE))
1682                 goto err_out;
1683
1684         if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
1685                 /* set up device control for ATA_FLAG_SATA_RESET */
1686                 if (ap->flags & ATA_FLAG_MMIO)
1687                         writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1688                 else
1689                         outb(ap->ctl, ioaddr->ctl_addr);
1690         }
1691
1692         DPRINTK("EXIT\n");
1693         return;
1694
1695 err_out:
1696         printk(KERN_ERR "ata%u: disabling port\n", ap->id);
1697         ap->ops->port_disable(ap);
1698
1699         DPRINTK("EXIT\n");
1700 }
1701
1702 static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
1703 {
1704         struct ata_device *master, *slave;
1705         unsigned int mask;
1706
1707         master = &ap->device[0];
1708         slave = &ap->device[1];
1709
1710         assert (ata_dev_present(master) || ata_dev_present(slave));
1711
1712         if (shift == ATA_SHIFT_UDMA) {
1713                 mask = ap->udma_mask;
1714                 if (ata_dev_present(master))
1715                         mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
1716                 if (ata_dev_present(slave))
1717                         mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
1718         }
1719         else if (shift == ATA_SHIFT_MWDMA) {
1720                 mask = ap->mwdma_mask;
1721                 if (ata_dev_present(master))
1722                         mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
1723                 if (ata_dev_present(slave))
1724                         mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
1725         }
1726         else if (shift == ATA_SHIFT_PIO) {
1727                 mask = ap->pio_mask;
1728                 if (ata_dev_present(master)) {
1729                         /* spec doesn't return explicit support for
1730                          * PIO0-2, so we fake it
1731                          */
1732                         u16 tmp_mode = master->id[ATA_ID_PIO_MODES] & 0x03;
1733                         tmp_mode <<= 3;
1734                         tmp_mode |= 0x7;
1735                         mask &= tmp_mode;
1736                 }
1737                 if (ata_dev_present(slave)) {
1738                         /* spec doesn't return explicit support for
1739                          * PIO0-2, so we fake it
1740                          */
1741                         u16 tmp_mode = slave->id[ATA_ID_PIO_MODES] & 0x03;
1742                         tmp_mode <<= 3;
1743                         tmp_mode |= 0x7;
1744                         mask &= tmp_mode;
1745                 }
1746         }
1747         else {
1748                 mask = 0xffffffff; /* shut up compiler warning */
1749                 BUG();
1750         }
1751
1752         return mask;
1753 }
1754
1755 /* find greatest bit */
1756 static int fgb(u32 bitmap)
1757 {
1758         unsigned int i;
1759         int x = -1;
1760
1761         for (i = 0; i < 32; i++)
1762                 if (bitmap & (1 << i))
1763                         x = i;
1764
1765         return x;
1766 }
1767
1768 /**
1769  *      ata_choose_xfer_mode - attempt to find best transfer mode
1770  *      @ap: Port for which an xfer mode will be selected
1771  *      @xfer_mode_out: (output) SET FEATURES - XFER MODE code
1772  *      @xfer_shift_out: (output) bit shift that selects this mode
1773  *
1774  *      LOCKING:
1775  *
1776  *      RETURNS:
1777  *      Zero on success, negative on error.
1778  */
1779
1780 static int ata_choose_xfer_mode(struct ata_port *ap,
1781                                 u8 *xfer_mode_out,
1782                                 unsigned int *xfer_shift_out)
1783 {
1784         unsigned int mask, shift;
1785         int x, i;
1786
1787         for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
1788                 shift = xfer_mode_classes[i].shift;
1789                 mask = ata_get_mode_mask(ap, shift);
1790
1791                 x = fgb(mask);
1792                 if (x >= 0) {
1793                         *xfer_mode_out = xfer_mode_classes[i].base + x;
1794                         *xfer_shift_out = shift;
1795                         return 0;
1796                 }
1797         }
1798
1799         return -1;
1800 }
1801
1802 /**
1803  *      ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
1804  *      @ap: Port associated with device @dev
1805  *      @dev: Device to which command will be sent
1806  *
1807  *      LOCKING:
1808  */
1809
1810 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
1811 {
1812         DECLARE_COMPLETION(wait);
1813         struct ata_queued_cmd *qc;
1814         int rc;
1815         unsigned long flags;
1816
1817         /* set up set-features taskfile */
1818         DPRINTK("set features - xfer mode\n");
1819
1820         qc = ata_qc_new_init(ap, dev);
1821         BUG_ON(qc == NULL);
1822
1823         qc->tf.command = ATA_CMD_SET_FEATURES;
1824         qc->tf.feature = SETFEATURES_XFER;
1825         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1826         qc->tf.protocol = ATA_PROT_NODATA;
1827         qc->tf.nsect = dev->xfer_mode;
1828
1829         qc->waiting = &wait;
1830         qc->complete_fn = ata_qc_complete_noop;
1831
1832         spin_lock_irqsave(&ap->host_set->lock, flags);
1833         rc = ata_qc_issue(qc);
1834         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1835
1836         if (rc)
1837                 ata_port_disable(ap);
1838         else
1839                 wait_for_completion(&wait);
1840
1841         DPRINTK("EXIT\n");
1842 }
1843
1844 /**
1845  *      ata_sg_clean -
1846  *      @qc:
1847  *
1848  *      LOCKING:
1849  */
1850
1851 static void ata_sg_clean(struct ata_queued_cmd *qc)
1852 {
1853         struct ata_port *ap = qc->ap;
1854         struct scatterlist *sg = qc->sg;
1855         int dir = qc->dma_dir;
1856
1857         assert(qc->flags & ATA_QCFLAG_DMAMAP);
1858         assert(sg != NULL);
1859
1860         if (qc->flags & ATA_QCFLAG_SINGLE)
1861                 assert(qc->n_elem == 1);
1862
1863         DPRINTK("unmapping %u sg elements\n", qc->n_elem);
1864
1865         if (qc->flags & ATA_QCFLAG_SG)
1866                 dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
1867         else
1868                 dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
1869                                  sg_dma_len(&sg[0]), dir);
1870
1871         qc->flags &= ~ATA_QCFLAG_DMAMAP;
1872         qc->sg = NULL;
1873 }
1874
1875 /**
1876  *      ata_fill_sg - Fill PCI IDE PRD table
1877  *      @qc: Metadata associated with taskfile to be transferred
1878  *
1879  *      LOCKING:
1880  *
1881  */
1882 static void ata_fill_sg(struct ata_queued_cmd *qc)
1883 {
1884         struct scatterlist *sg = qc->sg;
1885         struct ata_port *ap = qc->ap;
1886         unsigned int idx, nelem;
1887
1888         assert(sg != NULL);
1889         assert(qc->n_elem > 0);
1890
1891         idx = 0;
1892         for (nelem = qc->n_elem; nelem; nelem--,sg++) {
1893                 u32 addr, offset;
1894                 u32 sg_len, len;
1895
1896                 /* determine if physical DMA addr spans 64K boundary.
1897                  * Note h/w doesn't support 64-bit, so we unconditionally
1898                  * truncate dma_addr_t to u32.
1899                  */
1900                 addr = (u32) sg_dma_address(sg);
1901                 sg_len = sg_dma_len(sg);
1902
1903                 while (sg_len) {
1904                         offset = addr & 0xffff;
1905                         len = sg_len;
1906                         if ((offset + sg_len) > 0x10000)
1907                                 len = 0x10000 - offset;
1908
1909                         ap->prd[idx].addr = cpu_to_le32(addr);
1910                         ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
1911                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
1912
1913                         idx++;
1914                         sg_len -= len;
1915                         addr += len;
1916                 }
1917         }
1918
1919         if (idx)
1920                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
1921 }
1922
1923 /**
1924  *      ata_qc_prep - Prepare taskfile for submission
1925  *      @qc: Metadata associated with taskfile to be prepared
1926  *
1927  *      LOCKING:
1928  *      spin_lock_irqsave(host_set lock)
1929  */
1930 void ata_qc_prep(struct ata_queued_cmd *qc)
1931 {
1932         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1933                 return;
1934
1935         ata_fill_sg(qc);
1936 }
1937
1938 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
1939 {
1940         struct scatterlist *sg;
1941
1942         qc->flags |= ATA_QCFLAG_SINGLE;
1943
1944         memset(&qc->sgent, 0, sizeof(qc->sgent));
1945         qc->sg = &qc->sgent;
1946         qc->n_elem = 1;
1947         qc->buf_virt = buf;
1948
1949         sg = qc->sg;
1950         sg->page = virt_to_page(buf);
1951         sg->offset = (unsigned long) buf & ~PAGE_MASK;
1952         sg_dma_len(sg) = buflen;
1953 }
1954
1955 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
1956                  unsigned int n_elem)
1957 {
1958         qc->flags |= ATA_QCFLAG_SG;
1959         qc->sg = sg;
1960         qc->n_elem = n_elem;
1961 }
1962
1963 /**
1964  *      ata_sg_setup_one -
1965  *      @qc:
1966  *
1967  *      LOCKING:
1968  *      spin_lock_irqsave(host_set lock)
1969  *
1970  *      RETURNS:
1971  *
1972  */
1973
1974 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
1975 {
1976         struct ata_port *ap = qc->ap;
1977         int dir = qc->dma_dir;
1978         struct scatterlist *sg = qc->sg;
1979         dma_addr_t dma_address;
1980
1981         dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
1982                                      sg_dma_len(sg), dir);
1983         if (dma_mapping_error(dma_address))
1984                 return -1;
1985
1986         sg_dma_address(sg) = dma_address;
1987
1988         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
1989                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
1990
1991         return 0;
1992 }
1993
1994 /**
1995  *      ata_sg_setup -
1996  *      @qc:
1997  *
1998  *      LOCKING:
1999  *      spin_lock_irqsave(host_set lock)
2000  *
2001  *      RETURNS:
2002  *
2003  */
2004
2005 static int ata_sg_setup(struct ata_queued_cmd *qc)
2006 {
2007         struct ata_port *ap = qc->ap;
2008         struct scatterlist *sg = qc->sg;
2009         int n_elem, dir;
2010
2011         VPRINTK("ENTER, ata%u\n", ap->id);
2012         assert(qc->flags & ATA_QCFLAG_SG);
2013
2014         dir = qc->dma_dir;
2015         n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2016         if (n_elem < 1)
2017                 return -1;
2018
2019         DPRINTK("%d sg elements mapped\n", n_elem);
2020
2021         qc->n_elem = n_elem;
2022
2023         return 0;
2024 }
2025
2026 /**
2027  *      ata_pio_poll -
2028  *      @ap:
2029  *
2030  *      LOCKING:
2031  *
2032  *      RETURNS:
2033  *
2034  */
2035
2036 static unsigned long ata_pio_poll(struct ata_port *ap)
2037 {
2038         u8 status;
2039         unsigned int poll_state = PIO_ST_UNKNOWN;
2040         unsigned int reg_state = PIO_ST_UNKNOWN;
2041         const unsigned int tmout_state = PIO_ST_TMOUT;
2042
2043         switch (ap->pio_task_state) {
2044         case PIO_ST:
2045         case PIO_ST_POLL:
2046                 poll_state = PIO_ST_POLL;
2047                 reg_state = PIO_ST;
2048                 break;
2049         case PIO_ST_LAST:
2050         case PIO_ST_LAST_POLL:
2051                 poll_state = PIO_ST_LAST_POLL;
2052                 reg_state = PIO_ST_LAST;
2053                 break;
2054         default:
2055                 BUG();
2056                 break;
2057         }
2058
2059         status = ata_chk_status(ap);
2060         if (status & ATA_BUSY) {
2061                 if (time_after(jiffies, ap->pio_task_timeout)) {
2062                         ap->pio_task_state = tmout_state;
2063                         return 0;
2064                 }
2065                 ap->pio_task_state = poll_state;
2066                 return ATA_SHORT_PAUSE;
2067         }
2068
2069         ap->pio_task_state = reg_state;
2070         return 0;
2071 }
2072
2073 /**
2074  *      ata_pio_complete -
2075  *      @ap:
2076  *
2077  *      LOCKING:
2078  */
2079
2080 static void ata_pio_complete (struct ata_port *ap)
2081 {
2082         struct ata_queued_cmd *qc;
2083         u8 drv_stat;
2084
2085         /*
2086          * This is purely hueristic.  This is a fast path.
2087          * Sometimes when we enter, BSY will be cleared in
2088          * a chk-status or two.  If not, the drive is probably seeking
2089          * or something.  Snooze for a couple msecs, then
2090          * chk-status again.  If still busy, fall back to
2091          * PIO_ST_POLL state.
2092          */
2093         drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2094         if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2095                 msleep(2);
2096                 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2097                 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2098                         ap->pio_task_state = PIO_ST_LAST_POLL;
2099                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2100                         return;
2101                 }
2102         }
2103
2104         drv_stat = ata_wait_idle(ap);
2105         if (!ata_ok(drv_stat)) {
2106                 ap->pio_task_state = PIO_ST_ERR;
2107                 return;
2108         }
2109
2110         qc = ata_qc_from_tag(ap, ap->active_tag);
2111         assert(qc != NULL);
2112
2113         ap->pio_task_state = PIO_ST_IDLE;
2114
2115         ata_irq_on(ap);
2116
2117         ata_qc_complete(qc, drv_stat);
2118 }
2119
2120 void swap_buf_le16(u16 *buf, unsigned int buf_words)
2121 {
2122 #ifdef __BIG_ENDIAN
2123         unsigned int i;
2124
2125         for (i = 0; i < buf_words; i++)
2126                 buf[i] = le16_to_cpu(buf[i]);
2127 #endif /* __BIG_ENDIAN */
2128 }
2129
2130 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
2131                                unsigned int buflen, int write_data)
2132 {
2133         unsigned int i;
2134         unsigned int words = buflen >> 1;
2135         u16 *buf16 = (u16 *) buf;
2136         void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
2137
2138         if (write_data) {
2139                 for (i = 0; i < words; i++)
2140                         writew(le16_to_cpu(buf16[i]), mmio);
2141         } else {
2142                 for (i = 0; i < words; i++)
2143                         buf16[i] = cpu_to_le16(readw(mmio));
2144         }
2145 }
2146
2147 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
2148                               unsigned int buflen, int write_data)
2149 {
2150         unsigned int dwords = buflen >> 1;
2151
2152         if (write_data)
2153                 outsw(ap->ioaddr.data_addr, buf, dwords);
2154         else
2155                 insw(ap->ioaddr.data_addr, buf, dwords);
2156 }
2157
2158 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
2159                           unsigned int buflen, int do_write)
2160 {
2161         if (ap->flags & ATA_FLAG_MMIO)
2162                 ata_mmio_data_xfer(ap, buf, buflen, do_write);
2163         else
2164                 ata_pio_data_xfer(ap, buf, buflen, do_write);
2165 }
2166
2167 static void ata_pio_sector(struct ata_queued_cmd *qc)
2168 {
2169         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2170         struct scatterlist *sg = qc->sg;
2171         struct ata_port *ap = qc->ap;
2172         struct page *page;
2173         unsigned int offset;
2174         unsigned char *buf;
2175
2176         if (qc->cursect == (qc->nsect - 1))
2177                 ap->pio_task_state = PIO_ST_LAST;
2178
2179         page = sg[qc->cursg].page;
2180         offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
2181
2182         /* get the current page and offset */
2183         page = nth_page(page, (offset >> PAGE_SHIFT));
2184         offset %= PAGE_SIZE;
2185
2186         buf = kmap(page) + offset;
2187
2188         qc->cursect++;
2189         qc->cursg_ofs++;
2190
2191         if ((qc->cursg_ofs * ATA_SECT_SIZE) == sg_dma_len(&sg[qc->cursg])) {
2192                 qc->cursg++;
2193                 qc->cursg_ofs = 0;
2194         }
2195
2196         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2197
2198         /* do the actual data transfer */
2199         do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2200         ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
2201
2202         kunmap(page);
2203 }
2204
2205 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
2206 {
2207         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2208         struct scatterlist *sg = qc->sg;
2209         struct ata_port *ap = qc->ap;
2210         struct page *page;
2211         unsigned char *buf;
2212         unsigned int offset, count;
2213
2214         if (qc->curbytes == qc->nbytes - bytes)
2215                 ap->pio_task_state = PIO_ST_LAST;
2216
2217 next_sg:
2218         sg = &qc->sg[qc->cursg];
2219
2220 next_page:
2221         page = sg->page;
2222         offset = sg->offset + qc->cursg_ofs;
2223
2224         /* get the current page and offset */
2225         page = nth_page(page, (offset >> PAGE_SHIFT));
2226         offset %= PAGE_SIZE;
2227
2228         count = min(sg_dma_len(sg) - qc->cursg_ofs, bytes);
2229
2230         /* don't cross page boundaries */
2231         count = min(count, (unsigned int)PAGE_SIZE - offset);
2232
2233         buf = kmap(page) + offset;
2234
2235         bytes -= count;
2236         qc->curbytes += count;
2237         qc->cursg_ofs += count;
2238
2239         if (qc->cursg_ofs == sg_dma_len(sg)) {
2240                 qc->cursg++;
2241                 qc->cursg_ofs = 0;
2242         }
2243
2244         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2245
2246         /* do the actual data transfer */
2247         ata_data_xfer(ap, buf, count, do_write);
2248
2249         kunmap(page);
2250
2251         if (bytes) {
2252                 if (qc->cursg_ofs < sg_dma_len(sg))
2253                         goto next_page;
2254                 goto next_sg;
2255         }
2256 }
2257
2258 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
2259 {
2260         struct ata_port *ap = qc->ap;
2261         struct ata_device *dev = qc->dev;
2262         unsigned int ireason, bc_lo, bc_hi, bytes;
2263         int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
2264
2265         ap->ops->tf_read(ap, &qc->tf);
2266         ireason = qc->tf.nsect;
2267         bc_lo = qc->tf.lbam;
2268         bc_hi = qc->tf.lbah;
2269         bytes = (bc_hi << 8) | bc_lo;
2270
2271         /* shall be cleared to zero, indicating xfer of data */
2272         if (ireason & (1 << 0))
2273                 goto err_out;
2274
2275         /* make sure transfer direction matches expected */
2276         i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
2277         if (do_write != i_write)
2278                 goto err_out;
2279
2280         __atapi_pio_bytes(qc, bytes);
2281
2282         return;
2283
2284 err_out:
2285         printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
2286               ap->id, dev->devno);
2287         ap->pio_task_state = PIO_ST_ERR;
2288 }
2289
2290 /**
2291  *      ata_pio_sector -
2292  *      @ap:
2293  *
2294  *      LOCKING:
2295  */
2296
2297 static void ata_pio_block(struct ata_port *ap)
2298 {
2299         struct ata_queued_cmd *qc;
2300         u8 status;
2301
2302         /*
2303          * This is purely hueristic.  This is a fast path.
2304          * Sometimes when we enter, BSY will be cleared in
2305          * a chk-status or two.  If not, the drive is probably seeking
2306          * or something.  Snooze for a couple msecs, then
2307          * chk-status again.  If still busy, fall back to
2308          * PIO_ST_POLL state.
2309          */
2310         status = ata_busy_wait(ap, ATA_BUSY, 5);
2311         if (status & ATA_BUSY) {
2312                 msleep(2);
2313                 status = ata_busy_wait(ap, ATA_BUSY, 10);
2314                 if (status & ATA_BUSY) {
2315                         ap->pio_task_state = PIO_ST_POLL;
2316                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2317                         return;
2318                 }
2319         }
2320
2321         qc = ata_qc_from_tag(ap, ap->active_tag);
2322         assert(qc != NULL);
2323
2324         if (is_atapi_taskfile(&qc->tf)) {
2325                 /* no more data to transfer or unsupported ATAPI command */
2326                 if ((status & ATA_DRQ) == 0) {
2327                         ap->pio_task_state = PIO_ST_IDLE;
2328
2329                         ata_irq_on(ap);
2330
2331                         ata_qc_complete(qc, status);
2332                         return;
2333                 }
2334
2335                 atapi_pio_bytes(qc);
2336         } else {
2337                 /* handle BSY=0, DRQ=0 as error */
2338                 if ((status & ATA_DRQ) == 0) {
2339                         ap->pio_task_state = PIO_ST_ERR;
2340                         return;
2341                 }
2342
2343                 ata_pio_sector(qc);
2344         }
2345 }
2346
2347 static void ata_pio_error(struct ata_port *ap)
2348 {
2349         struct ata_queued_cmd *qc;
2350         u8 drv_stat;
2351
2352         qc = ata_qc_from_tag(ap, ap->active_tag);
2353         assert(qc != NULL);
2354
2355         drv_stat = ata_chk_status(ap);
2356         printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
2357                ap->id, drv_stat);
2358
2359         ap->pio_task_state = PIO_ST_IDLE;
2360
2361         ata_irq_on(ap);
2362
2363         ata_qc_complete(qc, drv_stat | ATA_ERR);
2364 }
2365
2366 static void ata_pio_task(void *_data)
2367 {
2368         struct ata_port *ap = _data;
2369         unsigned long timeout = 0;
2370
2371         switch (ap->pio_task_state) {
2372         case PIO_ST:
2373                 ata_pio_block(ap);
2374                 break;
2375
2376         case PIO_ST_LAST:
2377                 ata_pio_complete(ap);
2378                 break;
2379
2380         case PIO_ST_POLL:
2381         case PIO_ST_LAST_POLL:
2382                 timeout = ata_pio_poll(ap);
2383                 break;
2384
2385         case PIO_ST_TMOUT:
2386         case PIO_ST_ERR:
2387                 ata_pio_error(ap);
2388                 break;
2389         }
2390
2391         if ((ap->pio_task_state != PIO_ST_IDLE) &&
2392             (ap->pio_task_state != PIO_ST_TMOUT) &&
2393             (ap->pio_task_state != PIO_ST_ERR)) {
2394                 if (timeout)
2395                         queue_delayed_work(ata_wq, &ap->pio_task,
2396                                            timeout);
2397                 else
2398                         queue_work(ata_wq, &ap->pio_task);
2399         }
2400 }
2401
2402 static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
2403                                 struct scsi_cmnd *cmd)
2404 {
2405         DECLARE_COMPLETION(wait);
2406         struct ata_queued_cmd *qc;
2407         unsigned long flags;
2408         int using_pio = dev->flags & ATA_DFLAG_PIO;
2409         int rc;
2410
2411         DPRINTK("ATAPI request sense\n");
2412
2413         qc = ata_qc_new_init(ap, dev);
2414         BUG_ON(qc == NULL);
2415
2416         /* FIXME: is this needed? */
2417         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2418
2419         ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2420         qc->dma_dir = DMA_FROM_DEVICE;
2421
2422         memset(&qc->cdb, 0, sizeof(ap->cdb_len));
2423         qc->cdb[0] = REQUEST_SENSE;
2424         qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2425
2426         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2427         qc->tf.command = ATA_CMD_PACKET;
2428
2429         if (using_pio) {
2430                 qc->tf.protocol = ATA_PROT_ATAPI;
2431                 qc->tf.lbam = (8 * 1024) & 0xff;
2432                 qc->tf.lbah = (8 * 1024) >> 8;
2433
2434                 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2435         } else {
2436                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2437                 qc->tf.feature |= ATAPI_PKT_DMA;
2438         }
2439
2440         qc->waiting = &wait;
2441         qc->complete_fn = ata_qc_complete_noop;
2442
2443         spin_lock_irqsave(&ap->host_set->lock, flags);
2444         rc = ata_qc_issue(qc);
2445         spin_unlock_irqrestore(&ap->host_set->lock, flags);
2446
2447         if (rc)
2448                 ata_port_disable(ap);
2449         else
2450                 wait_for_completion(&wait);
2451
2452         DPRINTK("EXIT\n");
2453 }
2454
2455 /**
2456  *      ata_qc_timeout - Handle timeout of queued command
2457  *      @qc: Command that timed out
2458  *
2459  *      Some part of the kernel (currently, only the SCSI layer)
2460  *      has noticed that the active command on port @ap has not
2461  *      completed after a specified length of time.  Handle this
2462  *      condition by disabling DMA (if necessary) and completing
2463  *      transactions, with error if necessary.
2464  *
2465  *      This also handles the case of the "lost interrupt", where
2466  *      for some reason (possibly hardware bug, possibly driver bug)
2467  *      an interrupt was not delivered to the driver, even though the
2468  *      transaction completed successfully.
2469  *
2470  *      LOCKING:
2471  */
2472
2473 static void ata_qc_timeout(struct ata_queued_cmd *qc)
2474 {
2475         struct ata_port *ap = qc->ap;
2476         struct ata_device *dev = qc->dev;
2477         u8 host_stat = 0, drv_stat;
2478
2479         DPRINTK("ENTER\n");
2480
2481         /* FIXME: doesn't this conflict with timeout handling? */
2482         if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
2483                 struct scsi_cmnd *cmd = qc->scsicmd;
2484
2485                 if (!scsi_eh_eflags_chk(cmd, SCSI_EH_CANCEL_CMD)) {
2486
2487                         /* finish completing original command */
2488                         __ata_qc_complete(qc);
2489
2490                         atapi_request_sense(ap, dev, cmd);
2491
2492                         cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
2493                         scsi_finish_command(cmd);
2494
2495                         goto out;
2496                 }
2497         }
2498
2499         /* hack alert!  We cannot use the supplied completion
2500          * function from inside the ->eh_strategy_handler() thread.
2501          * libata is the only user of ->eh_strategy_handler() in
2502          * any kernel, so the default scsi_done() assumes it is
2503          * not being called from the SCSI EH.
2504          */
2505         qc->scsidone = scsi_finish_command;
2506
2507         switch (qc->tf.protocol) {
2508
2509         case ATA_PROT_DMA:
2510         case ATA_PROT_ATAPI_DMA:
2511                 host_stat = ata_bmdma_status(ap);
2512
2513                 /* before we do anything else, clear DMA-Start bit */
2514                 ata_bmdma_stop(ap);
2515
2516                 /* fall through */
2517
2518         default:
2519                 ata_altstatus(ap);
2520                 drv_stat = ata_chk_status(ap);
2521
2522                 /* ack bmdma irq events */
2523                 ata_bmdma_ack_irq(ap);
2524
2525                 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
2526                        ap->id, qc->tf.command, drv_stat, host_stat);
2527
2528                 /* complete taskfile transaction */
2529                 ata_qc_complete(qc, drv_stat);
2530                 break;
2531         }
2532 out:
2533         DPRINTK("EXIT\n");
2534 }
2535
2536 /**
2537  *      ata_eng_timeout - Handle timeout of queued command
2538  *      @ap: Port on which timed-out command is active
2539  *
2540  *      Some part of the kernel (currently, only the SCSI layer)
2541  *      has noticed that the active command on port @ap has not
2542  *      completed after a specified length of time.  Handle this
2543  *      condition by disabling DMA (if necessary) and completing
2544  *      transactions, with error if necessary.
2545  *
2546  *      This also handles the case of the "lost interrupt", where
2547  *      for some reason (possibly hardware bug, possibly driver bug)
2548  *      an interrupt was not delivered to the driver, even though the
2549  *      transaction completed successfully.
2550  *
2551  *      LOCKING:
2552  *      Inherited from SCSI layer (none, can sleep)
2553  */
2554
2555 void ata_eng_timeout(struct ata_port *ap)
2556 {
2557         struct ata_queued_cmd *qc;
2558
2559         DPRINTK("ENTER\n");
2560
2561         qc = ata_qc_from_tag(ap, ap->active_tag);
2562         if (!qc) {
2563                 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
2564                        ap->id);
2565                 goto out;
2566         }
2567
2568         ata_qc_timeout(qc);
2569
2570 out:
2571         DPRINTK("EXIT\n");
2572 }
2573
2574 /**
2575  *      ata_qc_new - Request an available ATA command, for queueing
2576  *      @ap: Port associated with device @dev
2577  *      @dev: Device from whom we request an available command structure
2578  *
2579  *      LOCKING:
2580  */
2581
2582 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
2583 {
2584         struct ata_queued_cmd *qc = NULL;
2585         unsigned int i;
2586
2587         for (i = 0; i < ATA_MAX_QUEUE; i++)
2588                 if (!test_and_set_bit(i, &ap->qactive)) {
2589                         qc = ata_qc_from_tag(ap, i);
2590                         break;
2591                 }
2592
2593         if (qc)
2594                 qc->tag = i;
2595
2596         return qc;
2597 }
2598
2599 /**
2600  *      ata_qc_new_init - Request an available ATA command, and initialize it
2601  *      @ap: Port associated with device @dev
2602  *      @dev: Device from whom we request an available command structure
2603  *
2604  *      LOCKING:
2605  */
2606
2607 struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
2608                                       struct ata_device *dev)
2609 {
2610         struct ata_queued_cmd *qc;
2611
2612         qc = ata_qc_new(ap);
2613         if (qc) {
2614                 qc->sg = NULL;
2615                 qc->flags = 0;
2616                 qc->scsicmd = NULL;
2617                 qc->ap = ap;
2618                 qc->dev = dev;
2619                 qc->cursect = qc->cursg = qc->cursg_ofs = 0;
2620                 qc->nsect = 0;
2621                 qc->nbytes = qc->curbytes = 0;
2622
2623                 ata_tf_init(ap, &qc->tf, dev->devno);
2624
2625                 if (dev->flags & ATA_DFLAG_LBA48)
2626                         qc->tf.flags |= ATA_TFLAG_LBA48;
2627         }
2628
2629         return qc;
2630 }
2631
2632 static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
2633 {
2634         return 0;
2635 }
2636
2637 static void __ata_qc_complete(struct ata_queued_cmd *qc)
2638 {
2639         struct ata_port *ap = qc->ap;
2640         unsigned int tag, do_clear = 0;
2641
2642         qc->flags = 0;
2643         tag = qc->tag;
2644         if (likely(ata_tag_valid(tag))) {
2645                 if (tag == ap->active_tag)
2646                         ap->active_tag = ATA_TAG_POISON;
2647                 qc->tag = ATA_TAG_POISON;
2648                 do_clear = 1;
2649         }
2650
2651         if (qc->waiting) {
2652                 struct completion *waiting = qc->waiting;
2653                 qc->waiting = NULL;
2654                 complete(waiting);
2655         }
2656
2657         if (likely(do_clear))
2658                 clear_bit(tag, &ap->qactive);
2659 }
2660
2661 /**
2662  *      ata_qc_complete - Complete an active ATA command
2663  *      @qc: Command to complete
2664  *      @drv_stat: ATA status register contents
2665  *
2666  *      LOCKING:
2667  *
2668  */
2669
2670 void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
2671 {
2672         int rc;
2673
2674         assert(qc != NULL);     /* ata_qc_from_tag _might_ return NULL */
2675         assert(qc->flags & ATA_QCFLAG_ACTIVE);
2676
2677         if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
2678                 ata_sg_clean(qc);
2679
2680         /* call completion callback */
2681         rc = qc->complete_fn(qc, drv_stat);
2682
2683         /* if callback indicates not to complete command (non-zero),
2684          * return immediately
2685          */
2686         if (rc != 0)
2687                 return;
2688
2689         __ata_qc_complete(qc);
2690
2691         VPRINTK("EXIT\n");
2692 }
2693
2694 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
2695 {
2696         struct ata_port *ap = qc->ap;
2697
2698         switch (qc->tf.protocol) {
2699         case ATA_PROT_DMA:
2700         case ATA_PROT_ATAPI_DMA:
2701                 return 1;
2702
2703         case ATA_PROT_ATAPI:
2704         case ATA_PROT_PIO:
2705         case ATA_PROT_PIO_MULT:
2706                 if (ap->flags & ATA_FLAG_PIO_DMA)
2707                         return 1;
2708
2709                 /* fall through */
2710
2711         default:
2712                 return 0;
2713         }
2714
2715         /* never reached */
2716 }
2717
2718 /**
2719  *      ata_qc_issue - issue taskfile to device
2720  *      @qc: command to issue to device
2721  *
2722  *      Prepare an ATA command to submission to device.
2723  *      This includes mapping the data into a DMA-able
2724  *      area, filling in the S/G table, and finally
2725  *      writing the taskfile to hardware, starting the command.
2726  *
2727  *      LOCKING:
2728  *      spin_lock_irqsave(host_set lock)
2729  *
2730  *      RETURNS:
2731  *      Zero on success, negative on error.
2732  */
2733
2734 int ata_qc_issue(struct ata_queued_cmd *qc)
2735 {
2736         struct ata_port *ap = qc->ap;
2737
2738         if (ata_should_dma_map(qc)) {
2739                 if (qc->flags & ATA_QCFLAG_SG) {
2740                         if (ata_sg_setup(qc))
2741                                 goto err_out;
2742                 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
2743                         if (ata_sg_setup_one(qc))
2744                                 goto err_out;
2745                 }
2746         } else {
2747                 qc->flags &= ~ATA_QCFLAG_DMAMAP;
2748         }
2749
2750         ap->ops->qc_prep(qc);
2751
2752         qc->ap->active_tag = qc->tag;
2753         qc->flags |= ATA_QCFLAG_ACTIVE;
2754
2755         return ap->ops->qc_issue(qc);
2756
2757 err_out:
2758         return -1;
2759 }
2760
2761 /**
2762  *      ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
2763  *      @qc: command to issue to device
2764  *
2765  *      Using various libata functions and hooks, this function
2766  *      starts an ATA command.  ATA commands are grouped into
2767  *      classes called "protocols", and issuing each type of protocol
2768  *      is slightly different.
2769  *
2770  *      LOCKING:
2771  *      spin_lock_irqsave(host_set lock)
2772  *
2773  *      RETURNS:
2774  *      Zero on success, negative on error.
2775  */
2776
2777 int ata_qc_issue_prot(struct ata_queued_cmd *qc)
2778 {
2779         struct ata_port *ap = qc->ap;
2780
2781         ata_dev_select(ap, qc->dev->devno, 1, 0);
2782
2783         switch (qc->tf.protocol) {
2784         case ATA_PROT_NODATA:
2785                 ata_tf_to_host_nolock(ap, &qc->tf);
2786                 break;
2787
2788         case ATA_PROT_DMA:
2789                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
2790                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
2791                 ap->ops->bmdma_start(qc);           /* initiate bmdma */
2792                 break;
2793
2794         case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
2795                 ata_qc_set_polling(qc);
2796                 ata_tf_to_host_nolock(ap, &qc->tf);
2797                 ap->pio_task_state = PIO_ST;
2798                 queue_work(ata_wq, &ap->pio_task);
2799                 break;
2800
2801         case ATA_PROT_ATAPI:
2802                 ata_qc_set_polling(qc);
2803                 ata_tf_to_host_nolock(ap, &qc->tf);
2804                 queue_work(ata_wq, &ap->packet_task);
2805                 break;
2806
2807         case ATA_PROT_ATAPI_NODATA:
2808                 ata_tf_to_host_nolock(ap, &qc->tf);
2809                 queue_work(ata_wq, &ap->packet_task);
2810                 break;
2811
2812         case ATA_PROT_ATAPI_DMA:
2813                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
2814                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
2815                 queue_work(ata_wq, &ap->packet_task);
2816                 break;
2817
2818         default:
2819                 WARN_ON(1);
2820                 return -1;
2821         }
2822
2823         return 0;
2824 }
2825
2826 /**
2827  *      ata_bmdma_setup - Set up PCI IDE BMDMA transaction
2828  *      @qc: Info associated with this ATA transaction.
2829  *
2830  *      LOCKING:
2831  *      spin_lock_irqsave(host_set lock)
2832  */
2833
2834 static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
2835 {
2836         struct ata_port *ap = qc->ap;
2837         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
2838         u8 dmactl;
2839         void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
2840
2841         /* load PRD table addr. */
2842         mb();   /* make sure PRD table writes are visible to controller */
2843         writel(ap->prd_dma, mmio + ATA_DMA_TABLE_OFS);
2844
2845         /* specify data direction, triple-check start bit is clear */
2846         dmactl = readb(mmio + ATA_DMA_CMD);
2847         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
2848         if (!rw)
2849                 dmactl |= ATA_DMA_WR;
2850         writeb(dmactl, mmio + ATA_DMA_CMD);
2851
2852         /* issue r/w command */
2853         ap->ops->exec_command(ap, &qc->tf);
2854 }
2855
2856 /**
2857  *      ata_bmdma_start - Start a PCI IDE BMDMA transaction
2858  *      @qc: Info associated with this ATA transaction.
2859  *
2860  *      LOCKING:
2861  *      spin_lock_irqsave(host_set lock)
2862  */
2863
2864 static void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
2865 {
2866         struct ata_port *ap = qc->ap;
2867         void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
2868         u8 dmactl;
2869
2870         /* start host DMA transaction */
2871         dmactl = readb(mmio + ATA_DMA_CMD);
2872         writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
2873
2874         /* Strictly, one may wish to issue a readb() here, to
2875          * flush the mmio write.  However, control also passes
2876          * to the hardware at this point, and it will interrupt
2877          * us when we are to resume control.  So, in effect,
2878          * we don't care when the mmio write flushes.
2879          * Further, a read of the DMA status register _immediately_
2880          * following the write may not be what certain flaky hardware
2881          * is expected, so I think it is best to not add a readb()
2882          * without first all the MMIO ATA cards/mobos.
2883          * Or maybe I'm just being paranoid.
2884          */
2885 }
2886
2887 /**
2888  *      ata_bmdma_setup_pio - Set up PCI IDE BMDMA transaction (PIO)
2889  *      @qc: Info associated with this ATA transaction.
2890  *
2891  *      LOCKING:
2892  *      spin_lock_irqsave(host_set lock)
2893  */
2894
2895 static void ata_bmdma_setup_pio (struct ata_queued_cmd *qc)
2896 {
2897         struct ata_port *ap = qc->ap;
2898         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
2899         u8 dmactl;
2900
2901         /* load PRD table addr. */
2902         outl(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
2903
2904         /* specify data direction, triple-check start bit is clear */
2905         dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2906         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
2907         if (!rw)
2908                 dmactl |= ATA_DMA_WR;
2909         outb(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2910
2911         /* issue r/w command */
2912         ap->ops->exec_command(ap, &qc->tf);
2913 }
2914
2915 /**
2916  *      ata_bmdma_start_pio - Start a PCI IDE BMDMA transaction (PIO)
2917  *      @qc: Info associated with this ATA transaction.
2918  *
2919  *      LOCKING:
2920  *      spin_lock_irqsave(host_set lock)
2921  */
2922
2923 static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
2924 {
2925         struct ata_port *ap = qc->ap;
2926         u8 dmactl;
2927
2928         /* start host DMA transaction */
2929         dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2930         outb(dmactl | ATA_DMA_START,
2931              ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2932 }
2933
2934 void ata_bmdma_start(struct ata_queued_cmd *qc)
2935 {
2936         if (qc->ap->flags & ATA_FLAG_MMIO)
2937                 ata_bmdma_start_mmio(qc);
2938         else
2939                 ata_bmdma_start_pio(qc);
2940 }
2941
2942 void ata_bmdma_setup(struct ata_queued_cmd *qc)
2943 {
2944         if (qc->ap->flags & ATA_FLAG_MMIO)
2945                 ata_bmdma_setup_mmio(qc);
2946         else
2947                 ata_bmdma_setup_pio(qc);
2948 }
2949
2950 void ata_bmdma_irq_clear(struct ata_port *ap)
2951 {
2952         ata_bmdma_ack_irq(ap);
2953 }
2954
2955 /**
2956  *      ata_host_intr - Handle host interrupt for given (port, task)
2957  *      @ap: Port on which interrupt arrived (possibly...)
2958  *      @qc: Taskfile currently active in engine
2959  *
2960  *      Handle host interrupt for given queued command.  Currently,
2961  *      only DMA interrupts are handled.  All other commands are
2962  *      handled via polling with interrupts disabled (nIEN bit).
2963  *
2964  *      LOCKING:
2965  *      spin_lock_irqsave(host_set lock)
2966  *
2967  *      RETURNS:
2968  *      One if interrupt was handled, zero if not (shared irq).
2969  */
2970
2971 inline unsigned int ata_host_intr (struct ata_port *ap,
2972                                    struct ata_queued_cmd *qc)
2973 {
2974         u8 status, host_stat;
2975
2976         switch (qc->tf.protocol) {
2977
2978         case ATA_PROT_DMA:
2979         case ATA_PROT_ATAPI_DMA:
2980         case ATA_PROT_ATAPI:
2981                 /* check status of DMA engine */
2982                 host_stat = ata_bmdma_status(ap);
2983                 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
2984
2985                 /* if it's not our irq... */
2986                 if (!(host_stat & ATA_DMA_INTR))
2987                         goto idle_irq;
2988
2989                 /* before we do anything else, clear DMA-Start bit */
2990                 ata_bmdma_stop(ap);
2991
2992                 /* fall through */
2993
2994         case ATA_PROT_ATAPI_NODATA:
2995         case ATA_PROT_NODATA:
2996                 /* check altstatus */
2997                 status = ata_altstatus(ap);
2998                 if (status & ATA_BUSY)
2999                         goto idle_irq;
3000
3001                 /* check main status, clearing INTRQ */
3002                 status = ata_chk_status(ap);
3003                 if (unlikely(status & ATA_BUSY))
3004                         goto idle_irq;
3005                 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
3006                         ap->id, qc->tf.protocol, status);
3007
3008                 /* ack bmdma irq events */
3009                 ata_bmdma_ack_irq(ap);
3010
3011                 /* complete taskfile transaction */
3012                 ata_qc_complete(qc, status);
3013                 break;
3014
3015         default:
3016                 goto idle_irq;
3017         }
3018
3019         return 1;       /* irq handled */
3020
3021 idle_irq:
3022         ap->stats.idle_irq++;
3023
3024 #ifdef ATA_IRQ_TRAP
3025         if ((ap->stats.idle_irq % 1000) == 0) {
3026                 handled = 1;
3027                 ata_irq_ack(ap, 0); /* debug trap */
3028                 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
3029         }
3030 #endif
3031         return 0;       /* irq not handled */
3032 }
3033
3034 /**
3035  *      ata_interrupt - Default ATA host interrupt handler
3036  *      @irq: irq line
3037  *      @dev_instance: pointer to our host information structure
3038  *      @regs: unused
3039  *
3040  *      LOCKING:
3041  *
3042  *      RETURNS:
3043  *
3044  */
3045
3046 irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
3047 {
3048         struct ata_host_set *host_set = dev_instance;
3049         unsigned int i;
3050         unsigned int handled = 0;
3051         unsigned long flags;
3052
3053         /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
3054         spin_lock_irqsave(&host_set->lock, flags);
3055
3056         for (i = 0; i < host_set->n_ports; i++) {
3057                 struct ata_port *ap;
3058
3059                 ap = host_set->ports[i];
3060                 if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
3061                         struct ata_queued_cmd *qc;
3062
3063                         qc = ata_qc_from_tag(ap, ap->active_tag);
3064                         if (qc && (!(qc->tf.ctl & ATA_NIEN)))
3065                                 handled |= ata_host_intr(ap, qc);
3066                 }
3067         }
3068
3069         spin_unlock_irqrestore(&host_set->lock, flags);
3070
3071         return IRQ_RETVAL(handled);
3072 }
3073
3074 /**
3075  *      atapi_packet_task - Write CDB bytes to hardware
3076  *      @_data: Port to which ATAPI device is attached.
3077  *
3078  *      When device has indicated its readiness to accept
3079  *      a CDB, this function is called.  Send the CDB.
3080  *      If DMA is to be performed, exit immediately.
3081  *      Otherwise, we are in polling mode, so poll
3082  *      status under operation succeeds or fails.
3083  *
3084  *      LOCKING:
3085  *      Kernel thread context (may sleep)
3086  */
3087
3088 static void atapi_packet_task(void *_data)
3089 {
3090         struct ata_port *ap = _data;
3091         struct ata_queued_cmd *qc;
3092         u8 status;
3093
3094         qc = ata_qc_from_tag(ap, ap->active_tag);
3095         assert(qc != NULL);
3096         assert(qc->flags & ATA_QCFLAG_ACTIVE);
3097
3098         /* sleep-wait for BSY to clear */
3099         DPRINTK("busy wait\n");
3100         if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
3101                 goto err_out;
3102
3103         /* make sure DRQ is set */
3104         status = ata_chk_status(ap);
3105         if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
3106                 goto err_out;
3107
3108         /* send SCSI cdb */
3109         DPRINTK("send cdb\n");
3110         assert(ap->cdb_len >= 12);
3111         ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
3112
3113         /* if we are DMA'ing, irq handler takes over from here */
3114         if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3115                 ap->ops->bmdma_start(qc);           /* initiate bmdma */
3116
3117         /* non-data commands are also handled via irq */
3118         else if (qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3119                 /* do nothing */
3120         }
3121
3122         /* PIO commands are handled by polling */
3123         else {
3124                 ap->pio_task_state = PIO_ST;
3125                 queue_work(ata_wq, &ap->pio_task);
3126         }
3127
3128         return;
3129
3130 err_out:
3131         ata_qc_complete(qc, ATA_ERR);
3132 }
3133
3134 int ata_port_start (struct ata_port *ap)
3135 {
3136         struct device *dev = ap->host_set->dev;
3137
3138         ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
3139         if (!ap->prd)
3140                 return -ENOMEM;
3141
3142         DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
3143
3144         return 0;
3145 }
3146
3147 void ata_port_stop (struct ata_port *ap)
3148 {
3149         struct device *dev = ap->host_set->dev;
3150
3151         dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
3152 }
3153
3154 /**
3155  *      ata_host_remove - Unregister SCSI host structure with upper layers
3156  *      @ap: Port to unregister
3157  *      @do_unregister: 1 if we fully unregister, 0 to just stop the port
3158  *
3159  *      LOCKING:
3160  */
3161
3162 static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
3163 {
3164         struct Scsi_Host *sh = ap->host;
3165
3166         DPRINTK("ENTER\n");
3167
3168         if (do_unregister)
3169                 scsi_remove_host(sh);
3170
3171         ap->ops->port_stop(ap);
3172 }
3173
3174 /**
3175  *      ata_host_init - Initialize an ata_port structure
3176  *      @ap: Structure to initialize
3177  *      @host: associated SCSI mid-layer structure
3178  *      @host_set: Collection of hosts to which @ap belongs
3179  *      @ent: Probe information provided by low-level driver
3180  *      @port_no: Port number associated with this ata_port
3181  *
3182  *      LOCKING:
3183  *
3184  */
3185
3186 static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
3187                           struct ata_host_set *host_set,
3188                           struct ata_probe_ent *ent, unsigned int port_no)
3189 {
3190         unsigned int i;
3191
3192         host->max_id = 16;
3193         host->max_lun = 1;
3194         host->max_channel = 1;
3195         host->unique_id = ata_unique_id++;
3196         host->max_cmd_len = 12;
3197         scsi_set_device(host, ent->dev);
3198         scsi_assign_lock(host, &host_set->lock);
3199
3200         ap->flags = ATA_FLAG_PORT_DISABLED;
3201         ap->id = host->unique_id;
3202         ap->host = host;
3203         ap->ctl = ATA_DEVCTL_OBS;
3204         ap->host_set = host_set;
3205         ap->port_no = port_no;
3206         ap->hard_port_no =
3207                 ent->legacy_mode ? ent->hard_port_no : port_no;
3208         ap->pio_mask = ent->pio_mask;
3209         ap->mwdma_mask = ent->mwdma_mask;
3210         ap->udma_mask = ent->udma_mask;
3211         ap->flags |= ent->host_flags;
3212         ap->ops = ent->port_ops;
3213         ap->cbl = ATA_CBL_NONE;
3214         ap->active_tag = ATA_TAG_POISON;
3215         ap->last_ctl = 0xFF;
3216
3217         INIT_WORK(&ap->packet_task, atapi_packet_task, ap);
3218         INIT_WORK(&ap->pio_task, ata_pio_task, ap);
3219
3220         for (i = 0; i < ATA_MAX_DEVICES; i++)
3221                 ap->device[i].devno = i;
3222
3223 #ifdef ATA_IRQ_TRAP
3224         ap->stats.unhandled_irq = 1;
3225         ap->stats.idle_irq = 1;
3226 #endif
3227
3228         memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
3229 }
3230
3231 /**
3232  *      ata_host_add - Attach low-level ATA driver to system
3233  *      @ent: Information provided by low-level driver
3234  *      @host_set: Collections of ports to which we add
3235  *      @port_no: Port number associated with this host
3236  *
3237  *      LOCKING:
3238  *
3239  *      RETURNS:
3240  *
3241  */
3242
3243 static struct ata_port * ata_host_add(struct ata_probe_ent *ent,
3244                                       struct ata_host_set *host_set,
3245                                       unsigned int port_no)
3246 {
3247         struct Scsi_Host *host;
3248         struct ata_port *ap;
3249         int rc;
3250
3251         DPRINTK("ENTER\n");
3252         host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
3253         if (!host)
3254                 return NULL;
3255
3256         ap = (struct ata_port *) &host->hostdata[0];
3257
3258         ata_host_init(ap, host, host_set, ent, port_no);
3259
3260         rc = ap->ops->port_start(ap);
3261         if (rc)
3262                 goto err_out;
3263
3264         return ap;
3265
3266 err_out:
3267         scsi_host_put(host);
3268         return NULL;
3269 }
3270
3271 /**
3272  *      ata_device_add -
3273  *      @ent:
3274  *
3275  *      LOCKING:
3276  *
3277  *      RETURNS:
3278  *
3279  */
3280
3281 int ata_device_add(struct ata_probe_ent *ent)
3282 {
3283         unsigned int count = 0, i;
3284         struct device *dev = ent->dev;
3285         struct ata_host_set *host_set;
3286
3287         DPRINTK("ENTER\n");
3288         /* alloc a container for our list of ATA ports (buses) */
3289         host_set = kmalloc(sizeof(struct ata_host_set) +
3290                            (ent->n_ports * sizeof(void *)), GFP_KERNEL);
3291         if (!host_set)
3292                 return 0;
3293         memset(host_set, 0, sizeof(struct ata_host_set) + (ent->n_ports * sizeof(void *)));
3294         spin_lock_init(&host_set->lock);
3295
3296         host_set->dev = dev;
3297         host_set->n_ports = ent->n_ports;
3298         host_set->irq = ent->irq;
3299         host_set->mmio_base = ent->mmio_base;
3300         host_set->private_data = ent->private_data;
3301         host_set->ops = ent->port_ops;
3302
3303         /* register each port bound to this device */
3304         for (i = 0; i < ent->n_ports; i++) {
3305                 struct ata_port *ap;
3306                 unsigned long xfer_mode_mask;
3307
3308                 ap = ata_host_add(ent, host_set, i);
3309                 if (!ap)
3310                         goto err_out;
3311
3312                 host_set->ports[i] = ap;
3313                 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
3314                                 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
3315                                 (ap->pio_mask << ATA_SHIFT_PIO);
3316
3317                 /* print per-port info to dmesg */
3318                 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
3319                                  "bmdma 0x%lX irq %lu\n",
3320                         ap->id,
3321                         ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
3322                         ata_mode_string(xfer_mode_mask),
3323                         ap->ioaddr.cmd_addr,
3324                         ap->ioaddr.ctl_addr,
3325                         ap->ioaddr.bmdma_addr,
3326                         ent->irq);
3327
3328                 ata_chk_status(ap);
3329                 host_set->ops->irq_clear(ap);
3330                 count++;
3331         }
3332
3333         if (!count) {
3334                 kfree(host_set);
3335                 return 0;
3336         }
3337
3338         /* obtain irq, that is shared between channels */
3339         if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
3340                         DRV_NAME, host_set))
3341                 goto err_out;
3342
3343         /* perform each probe synchronously */
3344         DPRINTK("probe begin\n");
3345         for (i = 0; i < count; i++) {
3346                 struct ata_port *ap;
3347                 int rc;
3348
3349                 ap = host_set->ports[i];
3350
3351                 DPRINTK("ata%u: probe begin\n", ap->id);
3352                 rc = ata_bus_probe(ap);
3353                 DPRINTK("ata%u: probe end\n", ap->id);
3354
3355                 if (rc) {
3356                         /* FIXME: do something useful here?
3357                          * Current libata behavior will
3358                          * tear down everything when
3359                          * the module is removed
3360                          * or the h/w is unplugged.
3361                          */
3362                 }
3363
3364                 rc = scsi_add_host(ap->host, dev);
3365                 if (rc) {
3366                         printk(KERN_ERR "ata%u: scsi_add_host failed\n",
3367                                ap->id);
3368                         /* FIXME: do something useful here */
3369                         /* FIXME: handle unconditional calls to
3370                          * scsi_scan_host and ata_host_remove, below,
3371                          * at the very least
3372                          */
3373                 }
3374         }
3375
3376         /* probes are done, now scan each port's disk(s) */
3377         DPRINTK("probe begin\n");
3378         for (i = 0; i < count; i++) {
3379                 struct ata_port *ap = host_set->ports[i];
3380
3381                 scsi_scan_host(ap->host);
3382         }
3383
3384         dev_set_drvdata(dev, host_set);
3385
3386         VPRINTK("EXIT, returning %u\n", ent->n_ports);
3387         return ent->n_ports; /* success */
3388
3389 err_out:
3390         for (i = 0; i < count; i++) {
3391                 ata_host_remove(host_set->ports[i], 1);
3392                 scsi_host_put(host_set->ports[i]->host);
3393         }
3394         kfree(host_set);
3395         VPRINTK("EXIT, returning 0\n");
3396         return 0;
3397 }
3398
3399 /**
3400  *      ata_scsi_release - SCSI layer callback hook for host unload
3401  *      @host: libata host to be unloaded
3402  *
3403  *      Performs all duties necessary to shut down a libata port...
3404  *      Kill port kthread, disable port, and release resources.
3405  *
3406  *      LOCKING:
3407  *      Inherited from SCSI layer.
3408  *
3409  *      RETURNS:
3410  *      One.
3411  */
3412
3413 int ata_scsi_release(struct Scsi_Host *host)
3414 {
3415         struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
3416
3417         DPRINTK("ENTER\n");
3418
3419         ap->ops->port_disable(ap);
3420         ata_host_remove(ap, 0);
3421
3422         DPRINTK("EXIT\n");
3423         return 1;
3424 }
3425
3426 /**
3427  *      ata_std_ports - initialize ioaddr with standard port offsets.
3428  *      @ioaddr: IO address structure to be initialized
3429  */
3430 void ata_std_ports(struct ata_ioports *ioaddr)
3431 {
3432         ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
3433         ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
3434         ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
3435         ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
3436         ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
3437         ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
3438         ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
3439         ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
3440         ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
3441         ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
3442 }
3443
3444 static struct ata_probe_ent *
3445 ata_probe_ent_alloc(int n, struct device *dev, struct ata_port_info **port)
3446 {
3447         struct ata_probe_ent *probe_ent;
3448         int i;
3449
3450         probe_ent = kmalloc(sizeof(*probe_ent) * n, GFP_KERNEL);
3451         if (!probe_ent) {
3452                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
3453                        kobject_name(&(dev->kobj)));
3454                 return NULL;
3455         }
3456
3457         memset(probe_ent, 0, sizeof(*probe_ent) * n);
3458
3459         for (i = 0; i < n; i++) {
3460                 INIT_LIST_HEAD(&probe_ent[i].node);
3461                 probe_ent[i].dev = dev;
3462
3463                 probe_ent[i].sht = port[i]->sht;
3464                 probe_ent[i].host_flags = port[i]->host_flags;
3465                 probe_ent[i].pio_mask = port[i]->pio_mask;
3466                 probe_ent[i].mwdma_mask = port[i]->mwdma_mask;
3467                 probe_ent[i].udma_mask = port[i]->udma_mask;
3468                 probe_ent[i].port_ops = port[i]->port_ops;
3469
3470         }
3471
3472         return probe_ent;
3473 }
3474
3475 #ifdef CONFIG_PCI
3476 struct ata_probe_ent *
3477 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
3478 {
3479         struct ata_probe_ent *probe_ent =
3480                 ata_probe_ent_alloc(1, pci_dev_to_dev(pdev), port);
3481         if (!probe_ent)
3482                 return NULL;
3483
3484         probe_ent->n_ports = 2;
3485         probe_ent->irq = pdev->irq;
3486         probe_ent->irq_flags = SA_SHIRQ;
3487
3488         probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
3489         probe_ent->port[0].altstatus_addr =
3490         probe_ent->port[0].ctl_addr =
3491                 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
3492         probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
3493
3494         probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
3495         probe_ent->port[1].altstatus_addr =
3496         probe_ent->port[1].ctl_addr =
3497                 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
3498         probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
3499
3500         ata_std_ports(&probe_ent->port[0]);
3501         ata_std_ports(&probe_ent->port[1]);
3502
3503         return probe_ent;
3504 }
3505
3506 struct ata_probe_ent *
3507 ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port)
3508 {
3509         struct ata_probe_ent *probe_ent =
3510                 ata_probe_ent_alloc(2, pci_dev_to_dev(pdev), port);
3511         if (!probe_ent)
3512                 return NULL;
3513
3514         probe_ent[0].n_ports = 1;
3515         probe_ent[0].irq = 14;
3516
3517         probe_ent[0].hard_port_no = 0;
3518         probe_ent[0].legacy_mode = 1;
3519
3520         probe_ent[1].n_ports = 1;
3521         probe_ent[1].irq = 15;
3522
3523         probe_ent[1].hard_port_no = 1;
3524         probe_ent[1].legacy_mode = 1;
3525
3526         probe_ent[0].port[0].cmd_addr = 0x1f0;
3527         probe_ent[0].port[0].altstatus_addr =
3528         probe_ent[0].port[0].ctl_addr = 0x3f6;
3529         probe_ent[0].port[0].bmdma_addr = pci_resource_start(pdev, 4);
3530
3531         probe_ent[1].port[0].cmd_addr = 0x170;
3532         probe_ent[1].port[0].altstatus_addr =
3533         probe_ent[1].port[0].ctl_addr = 0x376;
3534         probe_ent[1].port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
3535
3536         ata_std_ports(&probe_ent[0].port[0]);
3537         ata_std_ports(&probe_ent[1].port[0]);
3538
3539         return probe_ent;
3540 }
3541
3542 /**
3543  *      ata_pci_init_one - Initialize/register PCI IDE host controller
3544  *      @pdev: Controller to be initialized
3545  *      @port_info: Information from low-level host driver
3546  *      @n_ports: Number of ports attached to host controller
3547  *
3548  *      LOCKING:
3549  *      Inherited from PCI layer (may sleep).
3550  *
3551  *      RETURNS:
3552  *
3553  */
3554
3555 int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
3556                       unsigned int n_ports)
3557 {
3558         struct ata_probe_ent *probe_ent, *probe_ent2 = NULL;
3559         struct ata_port_info *port[2];
3560         u8 tmp8, mask;
3561         unsigned int legacy_mode = 0;
3562         int rc;
3563
3564         DPRINTK("ENTER\n");
3565
3566         port[0] = port_info[0];
3567         if (n_ports > 1)
3568                 port[1] = port_info[1];
3569         else
3570                 port[1] = port[0];
3571
3572         if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0) {
3573                 /* TODO: support transitioning to native mode? */
3574                 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
3575                 mask = (1 << 2) | (1 << 0);
3576                 if ((tmp8 & mask) != mask)
3577                         legacy_mode = (1 << 3);
3578         }
3579
3580         /* FIXME... */
3581         if ((!legacy_mode) && (n_ports > 1)) {
3582                 printk(KERN_ERR "ata: BUG: native mode, n_ports > 1\n");
3583                 return -EINVAL;
3584         }
3585
3586         rc = pci_enable_device(pdev);
3587         if (rc)
3588                 return rc;
3589
3590         rc = pci_request_regions(pdev, DRV_NAME);
3591         if (rc)
3592                 goto err_out;
3593
3594         if (legacy_mode) {
3595                 if (!request_region(0x1f0, 8, "libata")) {
3596                         struct resource *conflict, res;
3597                         res.start = 0x1f0;
3598                         res.end = 0x1f0 + 8 - 1;
3599                         conflict = ____request_resource(&ioport_resource, &res);
3600                         if (!strcmp(conflict->name, "libata"))
3601                                 legacy_mode |= (1 << 0);
3602                         else
3603                                 printk(KERN_WARNING "ata: 0x1f0 IDE port busy\n");
3604                 } else
3605                         legacy_mode |= (1 << 0);
3606
3607                 if (!request_region(0x170, 8, "libata")) {
3608                         struct resource *conflict, res;
3609                         res.start = 0x170;
3610                         res.end = 0x170 + 8 - 1;
3611                         conflict = ____request_resource(&ioport_resource, &res);
3612                         if (!strcmp(conflict->name, "libata"))
3613                                 legacy_mode |= (1 << 1);
3614                         else
3615                                 printk(KERN_WARNING "ata: 0x170 IDE port busy\n");
3616                 } else
3617                         legacy_mode |= (1 << 1);
3618         }
3619
3620         /* we have legacy mode, but all ports are unavailable */
3621         if (legacy_mode == (1 << 3)) {
3622                 rc = -EBUSY;
3623                 goto err_out_regions;
3624         }
3625
3626         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
3627         if (rc)
3628                 goto err_out_regions;
3629         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
3630         if (rc)
3631                 goto err_out_regions;
3632
3633         if (legacy_mode) {
3634                 probe_ent = ata_pci_init_legacy_mode(pdev, port);
3635                 if (probe_ent)
3636                         probe_ent2 = &probe_ent[1];
3637         } else
3638                 probe_ent = ata_pci_init_native_mode(pdev, port);
3639         if (!probe_ent) {
3640                 rc = -ENOMEM;
3641                 goto err_out_regions;
3642         }
3643
3644         pci_set_master(pdev);
3645
3646         /* FIXME: check ata_device_add return */
3647         if (legacy_mode) {
3648                 if (legacy_mode & (1 << 0))
3649                         ata_device_add(probe_ent);
3650                 if (legacy_mode & (1 << 1))
3651                         ata_device_add(probe_ent2);
3652         } else {
3653                 ata_device_add(probe_ent);
3654         }
3655         kfree(probe_ent);
3656
3657         return 0;
3658
3659 err_out_regions:
3660         if (legacy_mode & (1 << 0))
3661                 release_region(0x1f0, 8);
3662         if (legacy_mode & (1 << 1))
3663                 release_region(0x170, 8);
3664         pci_release_regions(pdev);
3665 err_out:
3666         pci_disable_device(pdev);
3667         return rc;
3668 }
3669
3670 /**
3671  *      ata_pci_remove_one - PCI layer callback for device removal
3672  *      @pdev: PCI device that was removed
3673  *
3674  *      PCI layer indicates to libata via this hook that
3675  *      hot-unplug or module unload event has occured.
3676  *      Handle this by unregistering all objects associated
3677  *      with this PCI device.  Free those objects.  Then finally
3678  *      release PCI resources and disable device.
3679  *
3680  *      LOCKING:
3681  *      Inherited from PCI layer (may sleep).
3682  */
3683
3684 void ata_pci_remove_one (struct pci_dev *pdev)
3685 {
3686         struct device *dev = pci_dev_to_dev(pdev);
3687         struct ata_host_set *host_set = dev_get_drvdata(dev);
3688         struct ata_port *ap;
3689         unsigned int i;
3690
3691         for (i = 0; i < host_set->n_ports; i++) {
3692                 ap = host_set->ports[i];
3693
3694                 scsi_remove_host(ap->host);
3695         }
3696
3697         free_irq(host_set->irq, host_set);
3698         if (host_set->ops->host_stop)
3699                 host_set->ops->host_stop(host_set);
3700         if (host_set->mmio_base)
3701                 iounmap(host_set->mmio_base);
3702
3703         for (i = 0; i < host_set->n_ports; i++) {
3704                 ap = host_set->ports[i];
3705
3706                 ata_scsi_release(ap->host);
3707                 scsi_host_put(ap->host);
3708         }
3709
3710         pci_release_regions(pdev);
3711
3712         for (i = 0; i < host_set->n_ports; i++) {
3713                 struct ata_ioports *ioaddr;
3714
3715                 ap = host_set->ports[i];
3716                 ioaddr = &ap->ioaddr;
3717
3718                 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
3719                         if (ioaddr->cmd_addr == 0x1f0)
3720                                 release_region(0x1f0, 8);
3721                         else if (ioaddr->cmd_addr == 0x170)
3722                                 release_region(0x170, 8);
3723                 }
3724         }
3725
3726         kfree(host_set);
3727         pci_disable_device(pdev);
3728         dev_set_drvdata(dev, NULL);
3729 }
3730
3731 /* move to PCI subsystem */
3732 int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
3733 {
3734         unsigned long tmp = 0;
3735
3736         switch (bits->width) {
3737         case 1: {
3738                 u8 tmp8 = 0;
3739                 pci_read_config_byte(pdev, bits->reg, &tmp8);
3740                 tmp = tmp8;
3741                 break;
3742         }
3743         case 2: {
3744                 u16 tmp16 = 0;
3745                 pci_read_config_word(pdev, bits->reg, &tmp16);
3746                 tmp = tmp16;
3747                 break;
3748         }
3749         case 4: {
3750                 u32 tmp32 = 0;
3751                 pci_read_config_dword(pdev, bits->reg, &tmp32);
3752                 tmp = tmp32;
3753                 break;
3754         }
3755
3756         default:
3757                 return -EINVAL;
3758         }
3759
3760         tmp &= bits->mask;
3761
3762         return (tmp == bits->val) ? 1 : 0;
3763 }
3764 #endif /* CONFIG_PCI */
3765
3766
3767 /**
3768  *      ata_init -
3769  *
3770  *      LOCKING:
3771  *
3772  *      RETURNS:
3773  *
3774  */
3775
3776 static int __init ata_init(void)
3777 {
3778         ata_wq = create_workqueue("ata");
3779         if (!ata_wq)
3780                 return -ENOMEM;
3781
3782         printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
3783         return 0;
3784 }
3785
3786 static void __exit ata_exit(void)
3787 {
3788         destroy_workqueue(ata_wq);
3789 }
3790
3791 module_init(ata_init);
3792 module_exit(ata_exit);
3793
3794 /*
3795  * libata is essentially a library of internal helper functions for
3796  * low-level ATA host controller drivers.  As such, the API/ABI is
3797  * likely to change as new drivers are added and updated.
3798  * Do not depend on ABI/API stability.
3799  */
3800
3801 EXPORT_SYMBOL_GPL(ata_std_bios_param);
3802 EXPORT_SYMBOL_GPL(ata_std_ports);
3803 EXPORT_SYMBOL_GPL(ata_device_add);
3804 EXPORT_SYMBOL_GPL(ata_sg_init);
3805 EXPORT_SYMBOL_GPL(ata_sg_init_one);
3806 EXPORT_SYMBOL_GPL(ata_qc_complete);
3807 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
3808 EXPORT_SYMBOL_GPL(ata_eng_timeout);
3809 EXPORT_SYMBOL_GPL(ata_tf_load);
3810 EXPORT_SYMBOL_GPL(ata_tf_read);
3811 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
3812 EXPORT_SYMBOL_GPL(ata_std_dev_select);
3813 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
3814 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
3815 EXPORT_SYMBOL_GPL(ata_check_status);
3816 EXPORT_SYMBOL_GPL(ata_exec_command);
3817 EXPORT_SYMBOL_GPL(ata_port_start);
3818 EXPORT_SYMBOL_GPL(ata_port_stop);
3819 EXPORT_SYMBOL_GPL(ata_interrupt);
3820 EXPORT_SYMBOL_GPL(ata_qc_prep);
3821 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
3822 EXPORT_SYMBOL_GPL(ata_bmdma_start);
3823 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
3824 EXPORT_SYMBOL_GPL(ata_port_probe);
3825 EXPORT_SYMBOL_GPL(sata_phy_reset);
3826 EXPORT_SYMBOL_GPL(__sata_phy_reset);
3827 EXPORT_SYMBOL_GPL(ata_bus_reset);
3828 EXPORT_SYMBOL_GPL(ata_port_disable);
3829 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
3830 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
3831 EXPORT_SYMBOL_GPL(ata_scsi_error);
3832 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
3833 EXPORT_SYMBOL_GPL(ata_scsi_release);
3834 EXPORT_SYMBOL_GPL(ata_host_intr);
3835 EXPORT_SYMBOL_GPL(ata_dev_classify);
3836 EXPORT_SYMBOL_GPL(ata_dev_id_string);
3837 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
3838
3839 #ifdef CONFIG_PCI
3840 EXPORT_SYMBOL_GPL(pci_test_config_bits);
3841 EXPORT_SYMBOL_GPL(ata_pci_init_legacy_mode);
3842 EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
3843 EXPORT_SYMBOL_GPL(ata_pci_init_one);
3844 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
3845 #endif /* CONFIG_PCI */