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  *      @udma_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  *      @dev: Device whose 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->pci_dma_dir = PCI_DMA_FROMDEVICE;
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 -
1770  *      @ap:
1771  *
1772  *      LOCKING:
1773  *
1774  *      RETURNS:
1775  *      Zero on success, negative on error.
1776  */
1777
1778 static int ata_choose_xfer_mode(struct ata_port *ap,
1779                                 u8 *xfer_mode_out,
1780                                 unsigned int *xfer_shift_out)
1781 {
1782         unsigned int mask, shift;
1783         int x, i;
1784
1785         for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
1786                 shift = xfer_mode_classes[i].shift;
1787                 mask = ata_get_mode_mask(ap, shift);
1788
1789                 x = fgb(mask);
1790                 if (x >= 0) {
1791                         *xfer_mode_out = xfer_mode_classes[i].base + x;
1792                         *xfer_shift_out = shift;
1793                         return 0;
1794                 }
1795         }
1796
1797         return -1;
1798 }
1799
1800 /**
1801  *      ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
1802  *      @ap: Port associated with device @dev
1803  *      @dev: Device to which command will be sent
1804  *
1805  *      LOCKING:
1806  */
1807
1808 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
1809 {
1810         DECLARE_COMPLETION(wait);
1811         struct ata_queued_cmd *qc;
1812         int rc;
1813         unsigned long flags;
1814
1815         /* set up set-features taskfile */
1816         DPRINTK("set features - xfer mode\n");
1817
1818         qc = ata_qc_new_init(ap, dev);
1819         BUG_ON(qc == NULL);
1820
1821         qc->tf.command = ATA_CMD_SET_FEATURES;
1822         qc->tf.feature = SETFEATURES_XFER;
1823         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1824         qc->tf.protocol = ATA_PROT_NODATA;
1825         qc->tf.nsect = dev->xfer_mode;
1826
1827         qc->waiting = &wait;
1828         qc->complete_fn = ata_qc_complete_noop;
1829
1830         spin_lock_irqsave(&ap->host_set->lock, flags);
1831         rc = ata_qc_issue(qc);
1832         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1833
1834         if (rc)
1835                 ata_port_disable(ap);
1836         else
1837                 wait_for_completion(&wait);
1838
1839         DPRINTK("EXIT\n");
1840 }
1841
1842 /**
1843  *      ata_sg_clean -
1844  *      @qc:
1845  *
1846  *      LOCKING:
1847  */
1848
1849 static void ata_sg_clean(struct ata_queued_cmd *qc)
1850 {
1851         struct ata_port *ap = qc->ap;
1852         struct scatterlist *sg = qc->sg;
1853         int dir = qc->pci_dma_dir;
1854
1855         assert(qc->flags & ATA_QCFLAG_DMAMAP);
1856         assert(sg != NULL);
1857
1858         if (qc->flags & ATA_QCFLAG_SINGLE)
1859                 assert(qc->n_elem == 1);
1860
1861         DPRINTK("unmapping %u sg elements\n", qc->n_elem);
1862
1863         if (qc->flags & ATA_QCFLAG_SG)
1864                 pci_unmap_sg(ap->host_set->pdev, sg, qc->n_elem, dir);
1865         else
1866                 pci_unmap_single(ap->host_set->pdev, sg_dma_address(&sg[0]),
1867                                  sg_dma_len(&sg[0]), dir);
1868
1869         qc->flags &= ~ATA_QCFLAG_DMAMAP;
1870         qc->sg = NULL;
1871 }
1872
1873 /**
1874  *      ata_fill_sg - Fill PCI IDE PRD table
1875  *      @qc: Metadata associated with taskfile to be transferred
1876  *
1877  *      LOCKING:
1878  *
1879  */
1880 static void ata_fill_sg(struct ata_queued_cmd *qc)
1881 {
1882         struct scatterlist *sg = qc->sg;
1883         struct ata_port *ap = qc->ap;
1884         unsigned int idx, nelem;
1885
1886         assert(sg != NULL);
1887         assert(qc->n_elem > 0);
1888
1889         idx = 0;
1890         for (nelem = qc->n_elem; nelem; nelem--,sg++) {
1891                 u32 addr, offset;
1892                 u32 sg_len, len;
1893
1894                 /* determine if physical DMA addr spans 64K boundary.
1895                  * Note h/w doesn't support 64-bit, so we unconditionally
1896                  * truncate dma_addr_t to u32.
1897                  */
1898                 addr = (u32) sg_dma_address(sg);
1899                 sg_len = sg_dma_len(sg);
1900
1901                 while (sg_len) {
1902                         offset = addr & 0xffff;
1903                         len = sg_len;
1904                         if ((offset + sg_len) > 0x10000)
1905                                 len = 0x10000 - offset;
1906
1907                         ap->prd[idx].addr = cpu_to_le32(addr);
1908                         ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
1909                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
1910
1911                         idx++;
1912                         sg_len -= len;
1913                         addr += len;
1914                 }
1915         }
1916
1917         if (idx)
1918                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
1919 }
1920
1921 /**
1922  *      ata_qc_prep - Prepare taskfile for submission
1923  *      @qc: Metadata associated with taskfile to be prepared
1924  *
1925  *      LOCKING:
1926  *      spin_lock_irqsave(host_set lock)
1927  */
1928 void ata_qc_prep(struct ata_queued_cmd *qc)
1929 {
1930         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
1931                 return;
1932
1933         ata_fill_sg(qc);
1934 }
1935
1936 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
1937 {
1938         struct scatterlist *sg;
1939
1940         qc->flags |= ATA_QCFLAG_SINGLE;
1941
1942         memset(&qc->sgent, 0, sizeof(qc->sgent));
1943         qc->sg = &qc->sgent;
1944         qc->n_elem = 1;
1945         qc->buf_virt = buf;
1946
1947         sg = qc->sg;
1948         sg->page = virt_to_page(buf);
1949         sg->offset = (unsigned long) buf & ~PAGE_MASK;
1950         sg_dma_len(sg) = buflen;
1951 }
1952
1953 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
1954                  unsigned int n_elem)
1955 {
1956         qc->flags |= ATA_QCFLAG_SG;
1957         qc->sg = sg;
1958         qc->n_elem = n_elem;
1959 }
1960
1961 /**
1962  *      ata_sg_setup_one -
1963  *      @qc:
1964  *
1965  *      LOCKING:
1966  *      spin_lock_irqsave(host_set lock)
1967  *
1968  *      RETURNS:
1969  *
1970  */
1971
1972 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
1973 {
1974         struct ata_port *ap = qc->ap;
1975         int dir = qc->pci_dma_dir;
1976         struct scatterlist *sg = qc->sg;
1977         dma_addr_t dma_address;
1978
1979         dma_address = pci_map_single(ap->host_set->pdev, qc->buf_virt,
1980                                      sg_dma_len(sg), dir);
1981         if (pci_dma_mapping_error(dma_address))
1982                 return -1;
1983
1984         sg_dma_address(sg) = dma_address;
1985
1986         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
1987                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
1988
1989         return 0;
1990 }
1991
1992 /**
1993  *      ata_sg_setup -
1994  *      @qc:
1995  *
1996  *      LOCKING:
1997  *      spin_lock_irqsave(host_set lock)
1998  *
1999  *      RETURNS:
2000  *
2001  */
2002
2003 static int ata_sg_setup(struct ata_queued_cmd *qc)
2004 {
2005         struct ata_port *ap = qc->ap;
2006         struct scatterlist *sg = qc->sg;
2007         int n_elem, dir;
2008
2009         VPRINTK("ENTER, ata%u\n", ap->id);
2010         assert(qc->flags & ATA_QCFLAG_SG);
2011
2012         dir = qc->pci_dma_dir;
2013         n_elem = pci_map_sg(ap->host_set->pdev, sg, qc->n_elem, dir);
2014         if (n_elem < 1)
2015                 return -1;
2016
2017         DPRINTK("%d sg elements mapped\n", n_elem);
2018
2019         qc->n_elem = n_elem;
2020
2021         return 0;
2022 }
2023
2024 /**
2025  *      ata_pio_poll -
2026  *      @ap:
2027  *
2028  *      LOCKING:
2029  *
2030  *      RETURNS:
2031  *
2032  */
2033
2034 static unsigned long ata_pio_poll(struct ata_port *ap)
2035 {
2036         u8 status;
2037         unsigned int poll_state = PIO_ST_UNKNOWN;
2038         unsigned int reg_state = PIO_ST_UNKNOWN;
2039         const unsigned int tmout_state = PIO_ST_TMOUT;
2040
2041         switch (ap->pio_task_state) {
2042         case PIO_ST:
2043         case PIO_ST_POLL:
2044                 poll_state = PIO_ST_POLL;
2045                 reg_state = PIO_ST;
2046                 break;
2047         case PIO_ST_LAST:
2048         case PIO_ST_LAST_POLL:
2049                 poll_state = PIO_ST_LAST_POLL;
2050                 reg_state = PIO_ST_LAST;
2051                 break;
2052         default:
2053                 BUG();
2054                 break;
2055         }
2056
2057         status = ata_chk_status(ap);
2058         if (status & ATA_BUSY) {
2059                 if (time_after(jiffies, ap->pio_task_timeout)) {
2060                         ap->pio_task_state = tmout_state;
2061                         return 0;
2062                 }
2063                 ap->pio_task_state = poll_state;
2064                 return ATA_SHORT_PAUSE;
2065         }
2066
2067         ap->pio_task_state = reg_state;
2068         return 0;
2069 }
2070
2071 /**
2072  *      ata_pio_complete -
2073  *      @ap:
2074  *
2075  *      LOCKING:
2076  */
2077
2078 static void ata_pio_complete (struct ata_port *ap)
2079 {
2080         struct ata_queued_cmd *qc;
2081         u8 drv_stat;
2082
2083         /*
2084          * This is purely hueristic.  This is a fast path.
2085          * Sometimes when we enter, BSY will be cleared in
2086          * a chk-status or two.  If not, the drive is probably seeking
2087          * or something.  Snooze for a couple msecs, then
2088          * chk-status again.  If still busy, fall back to
2089          * PIO_ST_POLL state.
2090          */
2091         drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2092         if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2093                 msleep(2);
2094                 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2095                 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2096                         ap->pio_task_state = PIO_ST_LAST_POLL;
2097                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2098                         return;
2099                 }
2100         }
2101
2102         drv_stat = ata_wait_idle(ap);
2103         if (!ata_ok(drv_stat)) {
2104                 ap->pio_task_state = PIO_ST_ERR;
2105                 return;
2106         }
2107
2108         qc = ata_qc_from_tag(ap, ap->active_tag);
2109         assert(qc != NULL);
2110
2111         ap->pio_task_state = PIO_ST_IDLE;
2112
2113         ata_irq_on(ap);
2114
2115         ata_qc_complete(qc, drv_stat);
2116 }
2117
2118 void swap_buf_le16(u16 *buf, unsigned int buf_words)
2119 {
2120 #ifdef __BIG_ENDIAN
2121         unsigned int i;
2122
2123         for (i = 0; i < buf_words; i++)
2124                 buf[i] = le16_to_cpu(buf[i]);
2125 #endif /* __BIG_ENDIAN */
2126 }
2127
2128 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
2129                                unsigned int buflen, int write_data)
2130 {
2131         unsigned int i;
2132         unsigned int words = buflen >> 1;
2133         u16 *buf16 = (u16 *) buf;
2134         void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
2135
2136         if (write_data) {
2137                 for (i = 0; i < words; i++)
2138                         writew(le16_to_cpu(buf16[i]), mmio);
2139         } else {
2140                 for (i = 0; i < words; i++)
2141                         buf16[i] = cpu_to_le16(readw(mmio));
2142         }
2143 }
2144
2145 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
2146                               unsigned int buflen, int write_data)
2147 {
2148         unsigned int dwords = buflen >> 1;
2149
2150         if (write_data)
2151                 outsw(ap->ioaddr.data_addr, buf, dwords);
2152         else
2153                 insw(ap->ioaddr.data_addr, buf, dwords);
2154 }
2155
2156 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
2157                           unsigned int buflen, int do_write)
2158 {
2159         if (ap->flags & ATA_FLAG_MMIO)
2160                 ata_mmio_data_xfer(ap, buf, buflen, do_write);
2161         else
2162                 ata_pio_data_xfer(ap, buf, buflen, do_write);
2163 }
2164
2165 static void ata_pio_sector(struct ata_queued_cmd *qc)
2166 {
2167         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2168         struct scatterlist *sg = qc->sg;
2169         struct ata_port *ap = qc->ap;
2170         struct page *page;
2171         unsigned int offset;
2172         unsigned char *buf;
2173
2174         if (qc->cursect == (qc->nsect - 1))
2175                 ap->pio_task_state = PIO_ST_LAST;
2176
2177         page = sg[qc->cursg].page;
2178         offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
2179
2180         /* get the current page and offset */
2181         page = nth_page(page, (offset >> PAGE_SHIFT));
2182         offset %= PAGE_SIZE;
2183
2184         buf = kmap(page) + offset;
2185
2186         qc->cursect++;
2187         qc->cursg_ofs++;
2188
2189         if ((qc->cursg_ofs * ATA_SECT_SIZE) == sg_dma_len(&sg[qc->cursg])) {
2190                 qc->cursg++;
2191                 qc->cursg_ofs = 0;
2192         }
2193
2194         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2195
2196         /* do the actual data transfer */
2197         do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2198         ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
2199
2200         kunmap(page);
2201 }
2202
2203 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
2204 {
2205         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2206         struct scatterlist *sg = qc->sg;
2207         struct ata_port *ap = qc->ap;
2208         struct page *page;
2209         unsigned char *buf;
2210         unsigned int offset, count;
2211
2212         if (qc->curbytes == qc->nbytes - bytes)
2213                 ap->pio_task_state = PIO_ST_LAST;
2214
2215 next_sg:
2216         sg = &qc->sg[qc->cursg];
2217
2218 next_page:
2219         page = sg->page;
2220         offset = sg->offset + qc->cursg_ofs;
2221
2222         /* get the current page and offset */
2223         page = nth_page(page, (offset >> PAGE_SHIFT));
2224         offset %= PAGE_SIZE;
2225
2226         count = min(sg_dma_len(sg) - qc->cursg_ofs, bytes);
2227
2228         /* don't cross page boundaries */
2229         count = min(count, (unsigned int)PAGE_SIZE - offset);
2230
2231         buf = kmap(page) + offset;
2232
2233         bytes -= count;
2234         qc->curbytes += count;
2235         qc->cursg_ofs += count;
2236
2237         if (qc->cursg_ofs == sg_dma_len(sg)) {
2238                 qc->cursg++;
2239                 qc->cursg_ofs = 0;
2240         }
2241
2242         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2243
2244         /* do the actual data transfer */
2245         ata_data_xfer(ap, buf, count, do_write);
2246
2247         kunmap(page);
2248
2249         if (bytes) {
2250                 if (qc->cursg_ofs < sg_dma_len(sg))
2251                         goto next_page;
2252                 goto next_sg;
2253         }
2254 }
2255
2256 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
2257 {
2258         struct ata_port *ap = qc->ap;
2259         struct ata_device *dev = qc->dev;
2260         unsigned int ireason, bc_lo, bc_hi, bytes;
2261         int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
2262
2263         ap->ops->tf_read(ap, &qc->tf);
2264         ireason = qc->tf.nsect;
2265         bc_lo = qc->tf.lbam;
2266         bc_hi = qc->tf.lbah;
2267         bytes = (bc_hi << 8) | bc_lo;
2268
2269         /* shall be cleared to zero, indicating xfer of data */
2270         if (ireason & (1 << 0))
2271                 goto err_out;
2272
2273         /* make sure transfer direction matches expected */
2274         i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
2275         if (do_write != i_write)
2276                 goto err_out;
2277
2278         __atapi_pio_bytes(qc, bytes);
2279
2280         return;
2281
2282 err_out:
2283         printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
2284               ap->id, dev->devno);
2285         ap->pio_task_state = PIO_ST_ERR;
2286 }
2287
2288 /**
2289  *      ata_pio_sector -
2290  *      @ap:
2291  *
2292  *      LOCKING:
2293  */
2294
2295 static void ata_pio_block(struct ata_port *ap)
2296 {
2297         struct ata_queued_cmd *qc;
2298         u8 status;
2299
2300         /*
2301          * This is purely hueristic.  This is a fast path.
2302          * Sometimes when we enter, BSY will be cleared in
2303          * a chk-status or two.  If not, the drive is probably seeking
2304          * or something.  Snooze for a couple msecs, then
2305          * chk-status again.  If still busy, fall back to
2306          * PIO_ST_POLL state.
2307          */
2308         status = ata_busy_wait(ap, ATA_BUSY, 5);
2309         if (status & ATA_BUSY) {
2310                 msleep(2);
2311                 status = ata_busy_wait(ap, ATA_BUSY, 10);
2312                 if (status & ATA_BUSY) {
2313                         ap->pio_task_state = PIO_ST_POLL;
2314                         ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2315                         return;
2316                 }
2317         }
2318
2319         qc = ata_qc_from_tag(ap, ap->active_tag);
2320         assert(qc != NULL);
2321
2322         if (is_atapi_taskfile(&qc->tf)) {
2323                 /* no more data to transfer or unsupported ATAPI command */
2324                 if ((status & ATA_DRQ) == 0) {
2325                         ap->pio_task_state = PIO_ST_IDLE;
2326
2327                         ata_irq_on(ap);
2328
2329                         ata_qc_complete(qc, status);
2330                         return;
2331                 }
2332
2333                 atapi_pio_bytes(qc);
2334         } else {
2335                 /* handle BSY=0, DRQ=0 as error */
2336                 if ((status & ATA_DRQ) == 0) {
2337                         ap->pio_task_state = PIO_ST_ERR;
2338                         return;
2339                 }
2340
2341                 ata_pio_sector(qc);
2342         }
2343 }
2344
2345 static void ata_pio_error(struct ata_port *ap)
2346 {
2347         struct ata_queued_cmd *qc;
2348         u8 drv_stat;
2349
2350         qc = ata_qc_from_tag(ap, ap->active_tag);
2351         assert(qc != NULL);
2352
2353         drv_stat = ata_chk_status(ap);
2354         printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
2355                ap->id, drv_stat);
2356
2357         ap->pio_task_state = PIO_ST_IDLE;
2358
2359         ata_irq_on(ap);
2360
2361         ata_qc_complete(qc, drv_stat | ATA_ERR);
2362 }
2363
2364 static void ata_pio_task(void *_data)
2365 {
2366         struct ata_port *ap = _data;
2367         unsigned long timeout = 0;
2368
2369         switch (ap->pio_task_state) {
2370         case PIO_ST:
2371                 ata_pio_block(ap);
2372                 break;
2373
2374         case PIO_ST_LAST:
2375                 ata_pio_complete(ap);
2376                 break;
2377
2378         case PIO_ST_POLL:
2379         case PIO_ST_LAST_POLL:
2380                 timeout = ata_pio_poll(ap);
2381                 break;
2382
2383         case PIO_ST_TMOUT:
2384         case PIO_ST_ERR:
2385                 ata_pio_error(ap);
2386                 break;
2387         }
2388
2389         if ((ap->pio_task_state != PIO_ST_IDLE) &&
2390             (ap->pio_task_state != PIO_ST_TMOUT) &&
2391             (ap->pio_task_state != PIO_ST_ERR)) {
2392                 if (timeout)
2393                         queue_delayed_work(ata_wq, &ap->pio_task,
2394                                            timeout);
2395                 else
2396                         queue_work(ata_wq, &ap->pio_task);
2397         }
2398 }
2399
2400 static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
2401                                 struct scsi_cmnd *cmd)
2402 {
2403         DECLARE_COMPLETION(wait);
2404         struct ata_queued_cmd *qc;
2405         unsigned long flags;
2406         int using_pio = dev->flags & ATA_DFLAG_PIO;
2407         int rc;
2408
2409         DPRINTK("ATAPI request sense\n");
2410
2411         qc = ata_qc_new_init(ap, dev);
2412         BUG_ON(qc == NULL);
2413
2414         /* FIXME: is this needed? */
2415         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2416
2417         ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2418         qc->pci_dma_dir = PCI_DMA_FROMDEVICE;
2419
2420         memset(&qc->cdb, 0, sizeof(ap->cdb_len));
2421         qc->cdb[0] = REQUEST_SENSE;
2422         qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2423
2424         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2425         qc->tf.command = ATA_CMD_PACKET;
2426
2427         if (using_pio) {
2428                 qc->tf.protocol = ATA_PROT_ATAPI;
2429                 qc->tf.lbam = (8 * 1024) & 0xff;
2430                 qc->tf.lbah = (8 * 1024) >> 8;
2431
2432                 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2433         } else {
2434                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2435                 qc->tf.feature |= ATAPI_PKT_DMA;
2436         }
2437
2438         qc->waiting = &wait;
2439         qc->complete_fn = ata_qc_complete_noop;
2440
2441         spin_lock_irqsave(&ap->host_set->lock, flags);
2442         rc = ata_qc_issue(qc);
2443         spin_unlock_irqrestore(&ap->host_set->lock, flags);
2444
2445         if (rc)
2446                 ata_port_disable(ap);
2447         else
2448                 wait_for_completion(&wait);
2449
2450         DPRINTK("EXIT\n");
2451 }
2452
2453 /**
2454  *      ata_qc_timeout - Handle timeout of queued command
2455  *      @qc: Command that timed out
2456  *
2457  *      Some part of the kernel (currently, only the SCSI layer)
2458  *      has noticed that the active command on port @ap has not
2459  *      completed after a specified length of time.  Handle this
2460  *      condition by disabling DMA (if necessary) and completing
2461  *      transactions, with error if necessary.
2462  *
2463  *      This also handles the case of the "lost interrupt", where
2464  *      for some reason (possibly hardware bug, possibly driver bug)
2465  *      an interrupt was not delivered to the driver, even though the
2466  *      transaction completed successfully.
2467  *
2468  *      LOCKING:
2469  */
2470
2471 static void ata_qc_timeout(struct ata_queued_cmd *qc)
2472 {
2473         struct ata_port *ap = qc->ap;
2474         struct ata_device *dev = qc->dev;
2475         u8 host_stat = 0, drv_stat;
2476
2477         DPRINTK("ENTER\n");
2478
2479         /* FIXME: doesn't this conflict with timeout handling? */
2480         if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
2481                 struct scsi_cmnd *cmd = qc->scsicmd;
2482
2483                 if (!scsi_eh_eflags_chk(cmd, SCSI_EH_CANCEL_CMD)) {
2484
2485                         /* finish completing original command */
2486                         __ata_qc_complete(qc);
2487
2488                         atapi_request_sense(ap, dev, cmd);
2489
2490                         cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
2491                         scsi_finish_command(cmd);
2492
2493                         goto out;
2494                 }
2495         }
2496
2497         /* hack alert!  We cannot use the supplied completion
2498          * function from inside the ->eh_strategy_handler() thread.
2499          * libata is the only user of ->eh_strategy_handler() in
2500          * any kernel, so the default scsi_done() assumes it is
2501          * not being called from the SCSI EH.
2502          */
2503         qc->scsidone = scsi_finish_command;
2504
2505         switch (qc->tf.protocol) {
2506
2507         case ATA_PROT_DMA:
2508         case ATA_PROT_ATAPI_DMA:
2509                 host_stat = ata_bmdma_status(ap);
2510
2511                 /* before we do anything else, clear DMA-Start bit */
2512                 ata_bmdma_stop(ap);
2513
2514                 /* fall through */
2515
2516         default:
2517                 ata_altstatus(ap);
2518                 drv_stat = ata_chk_status(ap);
2519
2520                 /* ack bmdma irq events */
2521                 ata_bmdma_ack_irq(ap);
2522
2523                 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
2524                        ap->id, qc->tf.command, drv_stat, host_stat);
2525
2526                 /* complete taskfile transaction */
2527                 ata_qc_complete(qc, drv_stat);
2528                 break;
2529         }
2530 out:
2531         DPRINTK("EXIT\n");
2532 }
2533
2534 /**
2535  *      ata_eng_timeout - Handle timeout of queued command
2536  *      @ap: Port on which timed-out command is active
2537  *
2538  *      Some part of the kernel (currently, only the SCSI layer)
2539  *      has noticed that the active command on port @ap has not
2540  *      completed after a specified length of time.  Handle this
2541  *      condition by disabling DMA (if necessary) and completing
2542  *      transactions, with error if necessary.
2543  *
2544  *      This also handles the case of the "lost interrupt", where
2545  *      for some reason (possibly hardware bug, possibly driver bug)
2546  *      an interrupt was not delivered to the driver, even though the
2547  *      transaction completed successfully.
2548  *
2549  *      LOCKING:
2550  *      Inherited from SCSI layer (none, can sleep)
2551  */
2552
2553 void ata_eng_timeout(struct ata_port *ap)
2554 {
2555         struct ata_queued_cmd *qc;
2556
2557         DPRINTK("ENTER\n");
2558
2559         qc = ata_qc_from_tag(ap, ap->active_tag);
2560         if (!qc) {
2561                 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
2562                        ap->id);
2563                 goto out;
2564         }
2565
2566         ata_qc_timeout(qc);
2567
2568 out:
2569         DPRINTK("EXIT\n");
2570 }
2571
2572 /**
2573  *      ata_qc_new - Request an available ATA command, for queueing
2574  *      @ap: Port associated with device @dev
2575  *      @dev: Device from whom we request an available command structure
2576  *
2577  *      LOCKING:
2578  */
2579
2580 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
2581 {
2582         struct ata_queued_cmd *qc = NULL;
2583         unsigned int i;
2584
2585         for (i = 0; i < ATA_MAX_QUEUE; i++)
2586                 if (!test_and_set_bit(i, &ap->qactive)) {
2587                         qc = ata_qc_from_tag(ap, i);
2588                         break;
2589                 }
2590
2591         if (qc)
2592                 qc->tag = i;
2593
2594         return qc;
2595 }
2596
2597 /**
2598  *      ata_qc_new_init - Request an available ATA command, and initialize it
2599  *      @ap: Port associated with device @dev
2600  *      @dev: Device from whom we request an available command structure
2601  *
2602  *      LOCKING:
2603  */
2604
2605 struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
2606                                       struct ata_device *dev)
2607 {
2608         struct ata_queued_cmd *qc;
2609
2610         qc = ata_qc_new(ap);
2611         if (qc) {
2612                 qc->sg = NULL;
2613                 qc->flags = 0;
2614                 qc->scsicmd = NULL;
2615                 qc->ap = ap;
2616                 qc->dev = dev;
2617                 qc->cursect = qc->cursg = qc->cursg_ofs = 0;
2618                 qc->nsect = 0;
2619                 qc->nbytes = qc->curbytes = 0;
2620
2621                 ata_tf_init(ap, &qc->tf, dev->devno);
2622
2623                 if (dev->flags & ATA_DFLAG_LBA48)
2624                         qc->tf.flags |= ATA_TFLAG_LBA48;
2625         }
2626
2627         return qc;
2628 }
2629
2630 static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
2631 {
2632         return 0;
2633 }
2634
2635 static void __ata_qc_complete(struct ata_queued_cmd *qc)
2636 {
2637         struct ata_port *ap = qc->ap;
2638         unsigned int tag, do_clear = 0;
2639
2640         qc->flags = 0;
2641         tag = qc->tag;
2642         if (likely(ata_tag_valid(tag))) {
2643                 if (tag == ap->active_tag)
2644                         ap->active_tag = ATA_TAG_POISON;
2645                 qc->tag = ATA_TAG_POISON;
2646                 do_clear = 1;
2647         }
2648
2649         if (qc->waiting) {
2650                 struct completion *waiting = qc->waiting;
2651                 qc->waiting = NULL;
2652                 complete(waiting);
2653         }
2654
2655         if (likely(do_clear))
2656                 clear_bit(tag, &ap->qactive);
2657 }
2658
2659 /**
2660  *      ata_qc_complete - Complete an active ATA command
2661  *      @qc: Command to complete
2662  *      @drv_stat: ATA status register contents
2663  *
2664  *      LOCKING:
2665  *
2666  */
2667
2668 void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
2669 {
2670         int rc;
2671
2672         assert(qc != NULL);     /* ata_qc_from_tag _might_ return NULL */
2673         assert(qc->flags & ATA_QCFLAG_ACTIVE);
2674
2675         if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
2676                 ata_sg_clean(qc);
2677
2678         /* call completion callback */
2679         rc = qc->complete_fn(qc, drv_stat);
2680
2681         /* if callback indicates not to complete command (non-zero),
2682          * return immediately
2683          */
2684         if (rc != 0)
2685                 return;
2686
2687         __ata_qc_complete(qc);
2688
2689         VPRINTK("EXIT\n");
2690 }
2691
2692 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
2693 {
2694         struct ata_port *ap = qc->ap;
2695
2696         switch (qc->tf.protocol) {
2697         case ATA_PROT_DMA:
2698         case ATA_PROT_ATAPI_DMA:
2699                 return 1;
2700
2701         case ATA_PROT_ATAPI:
2702         case ATA_PROT_PIO:
2703         case ATA_PROT_PIO_MULT:
2704                 if (ap->flags & ATA_FLAG_PIO_DMA)
2705                         return 1;
2706
2707                 /* fall through */
2708
2709         default:
2710                 return 0;
2711         }
2712
2713         /* never reached */
2714 }
2715
2716 /**
2717  *      ata_qc_issue - issue taskfile to device
2718  *      @qc: command to issue to device
2719  *
2720  *      Prepare an ATA command to submission to device.
2721  *      This includes mapping the data into a DMA-able
2722  *      area, filling in the S/G table, and finally
2723  *      writing the taskfile to hardware, starting the command.
2724  *
2725  *      LOCKING:
2726  *      spin_lock_irqsave(host_set lock)
2727  *
2728  *      RETURNS:
2729  *      Zero on success, negative on error.
2730  */
2731
2732 int ata_qc_issue(struct ata_queued_cmd *qc)
2733 {
2734         struct ata_port *ap = qc->ap;
2735
2736         if (ata_should_dma_map(qc)) {
2737                 if (qc->flags & ATA_QCFLAG_SG) {
2738                         if (ata_sg_setup(qc))
2739                                 goto err_out;
2740                 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
2741                         if (ata_sg_setup_one(qc))
2742                                 goto err_out;
2743                 }
2744         } else {
2745                 qc->flags &= ~ATA_QCFLAG_DMAMAP;
2746         }
2747
2748         ap->ops->qc_prep(qc);
2749
2750         qc->ap->active_tag = qc->tag;
2751         qc->flags |= ATA_QCFLAG_ACTIVE;
2752
2753         return ap->ops->qc_issue(qc);
2754
2755 err_out:
2756         return -1;
2757 }
2758
2759 /**
2760  *      ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
2761  *      @qc: command to issue to device
2762  *
2763  *      Using various libata functions and hooks, this function
2764  *      starts an ATA command.  ATA commands are grouped into
2765  *      classes called "protocols", and issuing each type of protocol
2766  *      is slightly different.
2767  *
2768  *      LOCKING:
2769  *      spin_lock_irqsave(host_set lock)
2770  *
2771  *      RETURNS:
2772  *      Zero on success, negative on error.
2773  */
2774
2775 int ata_qc_issue_prot(struct ata_queued_cmd *qc)
2776 {
2777         struct ata_port *ap = qc->ap;
2778
2779         ata_dev_select(ap, qc->dev->devno, 1, 0);
2780
2781         switch (qc->tf.protocol) {
2782         case ATA_PROT_NODATA:
2783                 ata_tf_to_host_nolock(ap, &qc->tf);
2784                 break;
2785
2786         case ATA_PROT_DMA:
2787                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
2788                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
2789                 ap->ops->bmdma_start(qc);           /* initiate bmdma */
2790                 break;
2791
2792         case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
2793                 ata_qc_set_polling(qc);
2794                 ata_tf_to_host_nolock(ap, &qc->tf);
2795                 ap->pio_task_state = PIO_ST;
2796                 queue_work(ata_wq, &ap->pio_task);
2797                 break;
2798
2799         case ATA_PROT_ATAPI:
2800                 ata_qc_set_polling(qc);
2801                 ata_tf_to_host_nolock(ap, &qc->tf);
2802                 queue_work(ata_wq, &ap->packet_task);
2803                 break;
2804
2805         case ATA_PROT_ATAPI_NODATA:
2806                 ata_tf_to_host_nolock(ap, &qc->tf);
2807                 queue_work(ata_wq, &ap->packet_task);
2808                 break;
2809
2810         case ATA_PROT_ATAPI_DMA:
2811                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
2812                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
2813                 queue_work(ata_wq, &ap->packet_task);
2814                 break;
2815
2816         default:
2817                 WARN_ON(1);
2818                 return -1;
2819         }
2820
2821         return 0;
2822 }
2823
2824 /**
2825  *      ata_bmdma_setup - Set up PCI IDE BMDMA transaction
2826  *      @qc: Info associated with this ATA transaction.
2827  *
2828  *      LOCKING:
2829  *      spin_lock_irqsave(host_set lock)
2830  */
2831
2832 static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
2833 {
2834         struct ata_port *ap = qc->ap;
2835         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
2836         u8 dmactl;
2837         void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
2838
2839         /* load PRD table addr. */
2840         mb();   /* make sure PRD table writes are visible to controller */
2841         writel(ap->prd_dma, mmio + ATA_DMA_TABLE_OFS);
2842
2843         /* specify data direction, triple-check start bit is clear */
2844         dmactl = readb(mmio + ATA_DMA_CMD);
2845         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
2846         if (!rw)
2847                 dmactl |= ATA_DMA_WR;
2848         writeb(dmactl, mmio + ATA_DMA_CMD);
2849
2850         /* issue r/w command */
2851         ap->ops->exec_command(ap, &qc->tf);
2852 }
2853
2854 /**
2855  *      ata_bmdma_start - Start a PCI IDE BMDMA transaction
2856  *      @qc: Info associated with this ATA transaction.
2857  *
2858  *      LOCKING:
2859  *      spin_lock_irqsave(host_set lock)
2860  */
2861
2862 static void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
2863 {
2864         struct ata_port *ap = qc->ap;
2865         void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
2866         u8 dmactl;
2867
2868         /* start host DMA transaction */
2869         dmactl = readb(mmio + ATA_DMA_CMD);
2870         writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
2871
2872         /* Strictly, one may wish to issue a readb() here, to
2873          * flush the mmio write.  However, control also passes
2874          * to the hardware at this point, and it will interrupt
2875          * us when we are to resume control.  So, in effect,
2876          * we don't care when the mmio write flushes.
2877          * Further, a read of the DMA status register _immediately_
2878          * following the write may not be what certain flaky hardware
2879          * is expected, so I think it is best to not add a readb()
2880          * without first all the MMIO ATA cards/mobos.
2881          * Or maybe I'm just being paranoid.
2882          */
2883 }
2884
2885 /**
2886  *      ata_bmdma_setup_pio - Set up PCI IDE BMDMA transaction (PIO)
2887  *      @qc: Info associated with this ATA transaction.
2888  *
2889  *      LOCKING:
2890  *      spin_lock_irqsave(host_set lock)
2891  */
2892
2893 static void ata_bmdma_setup_pio (struct ata_queued_cmd *qc)
2894 {
2895         struct ata_port *ap = qc->ap;
2896         unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
2897         u8 dmactl;
2898
2899         /* load PRD table addr. */
2900         outl(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
2901
2902         /* specify data direction, triple-check start bit is clear */
2903         dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2904         dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
2905         if (!rw)
2906                 dmactl |= ATA_DMA_WR;
2907         outb(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2908
2909         /* issue r/w command */
2910         ap->ops->exec_command(ap, &qc->tf);
2911 }
2912
2913 /**
2914  *      ata_bmdma_start_pio - Start a PCI IDE BMDMA transaction (PIO)
2915  *      @qc: Info associated with this ATA transaction.
2916  *
2917  *      LOCKING:
2918  *      spin_lock_irqsave(host_set lock)
2919  */
2920
2921 static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
2922 {
2923         struct ata_port *ap = qc->ap;
2924         u8 dmactl;
2925
2926         /* start host DMA transaction */
2927         dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2928         outb(dmactl | ATA_DMA_START,
2929              ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
2930 }
2931
2932 void ata_bmdma_start(struct ata_queued_cmd *qc)
2933 {
2934         if (qc->ap->flags & ATA_FLAG_MMIO)
2935                 ata_bmdma_start_mmio(qc);
2936         else
2937                 ata_bmdma_start_pio(qc);
2938 }
2939
2940 void ata_bmdma_setup(struct ata_queued_cmd *qc)
2941 {
2942         if (qc->ap->flags & ATA_FLAG_MMIO)
2943                 ata_bmdma_setup_mmio(qc);
2944         else
2945                 ata_bmdma_setup_pio(qc);
2946 }
2947
2948 void ata_bmdma_irq_clear(struct ata_port *ap)
2949 {
2950         ata_bmdma_ack_irq(ap);
2951 }
2952
2953 /**
2954  *      ata_host_intr - Handle host interrupt for given (port, task)
2955  *      @ap: Port on which interrupt arrived (possibly...)
2956  *      @qc: Taskfile currently active in engine
2957  *
2958  *      Handle host interrupt for given queued command.  Currently,
2959  *      only DMA interrupts are handled.  All other commands are
2960  *      handled via polling with interrupts disabled (nIEN bit).
2961  *
2962  *      LOCKING:
2963  *      spin_lock_irqsave(host_set lock)
2964  *
2965  *      RETURNS:
2966  *      One if interrupt was handled, zero if not (shared irq).
2967  */
2968
2969 inline unsigned int ata_host_intr (struct ata_port *ap,
2970                                    struct ata_queued_cmd *qc)
2971 {
2972         u8 status, host_stat;
2973
2974         switch (qc->tf.protocol) {
2975
2976         case ATA_PROT_DMA:
2977         case ATA_PROT_ATAPI_DMA:
2978         case ATA_PROT_ATAPI:
2979                 /* check status of DMA engine */
2980                 host_stat = ata_bmdma_status(ap);
2981                 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
2982
2983                 /* if it's not our irq... */
2984                 if (!(host_stat & ATA_DMA_INTR))
2985                         goto idle_irq;
2986
2987                 /* before we do anything else, clear DMA-Start bit */
2988                 ata_bmdma_stop(ap);
2989
2990                 /* fall through */
2991
2992         case ATA_PROT_ATAPI_NODATA:
2993         case ATA_PROT_NODATA:
2994                 /* check altstatus */
2995                 status = ata_altstatus(ap);
2996                 if (status & ATA_BUSY)
2997                         goto idle_irq;
2998
2999                 /* check main status, clearing INTRQ */
3000                 status = ata_chk_status(ap);
3001                 if (unlikely(status & ATA_BUSY))
3002                         goto idle_irq;
3003                 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
3004                         ap->id, qc->tf.protocol, status);
3005
3006                 /* ack bmdma irq events */
3007                 ata_bmdma_ack_irq(ap);
3008
3009                 /* complete taskfile transaction */
3010                 ata_qc_complete(qc, status);
3011                 break;
3012
3013         default:
3014                 goto idle_irq;
3015         }
3016
3017         return 1;       /* irq handled */
3018
3019 idle_irq:
3020         ap->stats.idle_irq++;
3021
3022 #ifdef ATA_IRQ_TRAP
3023         if ((ap->stats.idle_irq % 1000) == 0) {
3024                 handled = 1;
3025                 ata_irq_ack(ap, 0); /* debug trap */
3026                 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
3027         }
3028 #endif
3029         return 0;       /* irq not handled */
3030 }
3031
3032 /**
3033  *      ata_interrupt - Default ATA host interrupt handler
3034  *      @irq: irq line
3035  *      @dev_instance: pointer to our host information structure
3036  *      @regs: unused
3037  *
3038  *      LOCKING:
3039  *
3040  *      RETURNS:
3041  *
3042  */
3043
3044 irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
3045 {
3046         struct ata_host_set *host_set = dev_instance;
3047         unsigned int i;
3048         unsigned int handled = 0;
3049         unsigned long flags;
3050
3051         /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
3052         spin_lock_irqsave(&host_set->lock, flags);
3053
3054         for (i = 0; i < host_set->n_ports; i++) {
3055                 struct ata_port *ap;
3056
3057                 ap = host_set->ports[i];
3058                 if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
3059                         struct ata_queued_cmd *qc;
3060
3061                         qc = ata_qc_from_tag(ap, ap->active_tag);
3062                         if (qc && (!(qc->tf.ctl & ATA_NIEN)))
3063                                 handled |= ata_host_intr(ap, qc);
3064                 }
3065         }
3066
3067         spin_unlock_irqrestore(&host_set->lock, flags);
3068
3069         return IRQ_RETVAL(handled);
3070 }
3071
3072 /**
3073  *      atapi_packet_task - Write CDB bytes to hardware
3074  *      @_data: Port to which ATAPI device is attached.
3075  *
3076  *      When device has indicated its readiness to accept
3077  *      a CDB, this function is called.  Send the CDB.
3078  *      If DMA is to be performed, exit immediately.
3079  *      Otherwise, we are in polling mode, so poll
3080  *      status under operation succeeds or fails.
3081  *
3082  *      LOCKING:
3083  *      Kernel thread context (may sleep)
3084  */
3085
3086 static void atapi_packet_task(void *_data)
3087 {
3088         struct ata_port *ap = _data;
3089         struct ata_queued_cmd *qc;
3090         u8 status;
3091
3092         qc = ata_qc_from_tag(ap, ap->active_tag);
3093         assert(qc != NULL);
3094         assert(qc->flags & ATA_QCFLAG_ACTIVE);
3095
3096         /* sleep-wait for BSY to clear */
3097         DPRINTK("busy wait\n");
3098         if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
3099                 goto err_out;
3100
3101         /* make sure DRQ is set */
3102         status = ata_chk_status(ap);
3103         if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
3104                 goto err_out;
3105
3106         /* send SCSI cdb */
3107         DPRINTK("send cdb\n");
3108         assert(ap->cdb_len >= 12);
3109         ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
3110
3111         /* if we are DMA'ing, irq handler takes over from here */
3112         if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3113                 ap->ops->bmdma_start(qc);           /* initiate bmdma */
3114
3115         /* non-data commands are also handled via irq */
3116         else if (qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3117                 /* do nothing */
3118         }
3119
3120         /* PIO commands are handled by polling */
3121         else {
3122                 ap->pio_task_state = PIO_ST;
3123                 queue_work(ata_wq, &ap->pio_task);
3124         }
3125
3126         return;
3127
3128 err_out:
3129         ata_qc_complete(qc, ATA_ERR);
3130 }
3131
3132 int ata_port_start (struct ata_port *ap)
3133 {
3134         struct pci_dev *pdev = ap->host_set->pdev;
3135
3136         ap->prd = pci_alloc_consistent(pdev, ATA_PRD_TBL_SZ, &ap->prd_dma);
3137         if (!ap->prd)
3138                 return -ENOMEM;
3139
3140         DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
3141
3142         return 0;
3143 }
3144
3145 void ata_port_stop (struct ata_port *ap)
3146 {
3147         struct pci_dev *pdev = ap->host_set->pdev;
3148
3149         pci_free_consistent(pdev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
3150 }
3151
3152 /**
3153  *      ata_host_remove - Unregister SCSI host structure with upper layers
3154  *      @ap: Port to unregister
3155  *      @do_unregister: 1 if we fully unregister, 0 to just stop the port
3156  *
3157  *      LOCKING:
3158  */
3159
3160 static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
3161 {
3162         struct Scsi_Host *sh = ap->host;
3163
3164         DPRINTK("ENTER\n");
3165
3166         if (do_unregister)
3167                 scsi_remove_host(sh);
3168
3169         ap->ops->port_stop(ap);
3170 }
3171
3172 /**
3173  *      ata_host_init - Initialize an ata_port structure
3174  *      @ap: Structure to initialize
3175  *      @host: associated SCSI mid-layer structure
3176  *      @host_set: Collection of hosts to which @ap belongs
3177  *      @ent: Probe information provided by low-level driver
3178  *      @port_no: Port number associated with this ata_port
3179  *
3180  *      LOCKING:
3181  *
3182  */
3183
3184 static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
3185                           struct ata_host_set *host_set,
3186                           struct ata_probe_ent *ent, unsigned int port_no)
3187 {
3188         unsigned int i;
3189
3190         host->max_id = 16;
3191         host->max_lun = 1;
3192         host->max_channel = 1;
3193         host->unique_id = ata_unique_id++;
3194         host->max_cmd_len = 12;
3195         scsi_set_device(host, &ent->pdev->dev);
3196         scsi_assign_lock(host, &host_set->lock);
3197
3198         ap->flags = ATA_FLAG_PORT_DISABLED;
3199         ap->id = host->unique_id;
3200         ap->host = host;
3201         ap->ctl = ATA_DEVCTL_OBS;
3202         ap->host_set = host_set;
3203         ap->port_no = port_no;
3204         ap->hard_port_no =
3205                 ent->legacy_mode ? ent->hard_port_no : port_no;
3206         ap->pio_mask = ent->pio_mask;
3207         ap->mwdma_mask = ent->mwdma_mask;
3208         ap->udma_mask = ent->udma_mask;
3209         ap->flags |= ent->host_flags;
3210         ap->ops = ent->port_ops;
3211         ap->cbl = ATA_CBL_NONE;
3212         ap->active_tag = ATA_TAG_POISON;
3213         ap->last_ctl = 0xFF;
3214
3215         INIT_WORK(&ap->packet_task, atapi_packet_task, ap);
3216         INIT_WORK(&ap->pio_task, ata_pio_task, ap);
3217
3218         for (i = 0; i < ATA_MAX_DEVICES; i++)
3219                 ap->device[i].devno = i;
3220
3221 #ifdef ATA_IRQ_TRAP
3222         ap->stats.unhandled_irq = 1;
3223         ap->stats.idle_irq = 1;
3224 #endif
3225
3226         memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
3227 }
3228
3229 /**
3230  *      ata_host_add - Attach low-level ATA driver to system
3231  *      @ent: Information provided by low-level driver
3232  *      @host_set: Collections of ports to which we add
3233  *      @port_no: Port number associated with this host
3234  *
3235  *      LOCKING:
3236  *
3237  *      RETURNS:
3238  *
3239  */
3240
3241 static struct ata_port * ata_host_add(struct ata_probe_ent *ent,
3242                                       struct ata_host_set *host_set,
3243                                       unsigned int port_no)
3244 {
3245         struct Scsi_Host *host;
3246         struct ata_port *ap;
3247         int rc;
3248
3249         DPRINTK("ENTER\n");
3250         host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
3251         if (!host)
3252                 return NULL;
3253
3254         ap = (struct ata_port *) &host->hostdata[0];
3255
3256         ata_host_init(ap, host, host_set, ent, port_no);
3257
3258         rc = ap->ops->port_start(ap);
3259         if (rc)
3260                 goto err_out;
3261
3262         return ap;
3263
3264 err_out:
3265         scsi_host_put(host);
3266         return NULL;
3267 }
3268
3269 /**
3270  *      ata_device_add -
3271  *      @ent:
3272  *
3273  *      LOCKING:
3274  *
3275  *      RETURNS:
3276  *
3277  */
3278
3279 int ata_device_add(struct ata_probe_ent *ent)
3280 {
3281         unsigned int count = 0, i;
3282         struct pci_dev *pdev = ent->pdev;
3283         struct ata_host_set *host_set;
3284
3285         DPRINTK("ENTER\n");
3286         /* alloc a container for our list of ATA ports (buses) */
3287         host_set = kmalloc(sizeof(struct ata_host_set) +
3288                            (ent->n_ports * sizeof(void *)), GFP_KERNEL);
3289         if (!host_set)
3290                 return 0;
3291         memset(host_set, 0, sizeof(struct ata_host_set) + (ent->n_ports * sizeof(void *)));
3292         spin_lock_init(&host_set->lock);
3293
3294         host_set->pdev = pdev;
3295         host_set->n_ports = ent->n_ports;
3296         host_set->irq = ent->irq;
3297         host_set->mmio_base = ent->mmio_base;
3298         host_set->private_data = ent->private_data;
3299         host_set->ops = ent->port_ops;
3300
3301         /* register each port bound to this device */
3302         for (i = 0; i < ent->n_ports; i++) {
3303                 struct ata_port *ap;
3304                 unsigned long xfer_mode_mask;
3305
3306                 ap = ata_host_add(ent, host_set, i);
3307                 if (!ap)
3308                         goto err_out;
3309
3310                 host_set->ports[i] = ap;
3311                 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
3312                                 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
3313                                 (ap->pio_mask << ATA_SHIFT_PIO);
3314
3315                 /* print per-port info to dmesg */
3316                 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
3317                                  "bmdma 0x%lX irq %lu\n",
3318                         ap->id,
3319                         ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
3320                         ata_mode_string(xfer_mode_mask),
3321                         ap->ioaddr.cmd_addr,
3322                         ap->ioaddr.ctl_addr,
3323                         ap->ioaddr.bmdma_addr,
3324                         ent->irq);
3325
3326                 ata_chk_status(ap);
3327                 host_set->ops->irq_clear(ap);
3328                 count++;
3329         }
3330
3331         if (!count) {
3332                 kfree(host_set);
3333                 return 0;
3334         }
3335
3336         /* obtain irq, that is shared between channels */
3337         if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
3338                         DRV_NAME, host_set))
3339                 goto err_out;
3340
3341         /* perform each probe synchronously */
3342         DPRINTK("probe begin\n");
3343         for (i = 0; i < count; i++) {
3344                 struct ata_port *ap;
3345                 int rc;
3346
3347                 ap = host_set->ports[i];
3348
3349                 DPRINTK("ata%u: probe begin\n", ap->id);
3350                 rc = ata_bus_probe(ap);
3351                 DPRINTK("ata%u: probe end\n", ap->id);
3352
3353                 if (rc) {
3354                         /* FIXME: do something useful here?
3355                          * Current libata behavior will
3356                          * tear down everything when
3357                          * the module is removed
3358                          * or the h/w is unplugged.
3359                          */
3360                 }
3361
3362                 rc = scsi_add_host(ap->host, &pdev->dev);
3363                 if (rc) {
3364                         printk(KERN_ERR "ata%u: scsi_add_host failed\n",
3365                                ap->id);
3366                         /* FIXME: do something useful here */
3367                         /* FIXME: handle unconditional calls to
3368                          * scsi_scan_host and ata_host_remove, below,
3369                          * at the very least
3370                          */
3371                 }
3372         }
3373
3374         /* probes are done, now scan each port's disk(s) */
3375         DPRINTK("probe begin\n");
3376         for (i = 0; i < count; i++) {
3377                 struct ata_port *ap = host_set->ports[i];
3378
3379                 scsi_scan_host(ap->host);
3380         }
3381
3382         pci_set_drvdata(pdev, host_set);
3383
3384         VPRINTK("EXIT, returning %u\n", ent->n_ports);
3385         return ent->n_ports; /* success */
3386
3387 err_out:
3388         for (i = 0; i < count; i++) {
3389                 ata_host_remove(host_set->ports[i], 1);
3390                 scsi_host_put(host_set->ports[i]->host);
3391         }
3392         kfree(host_set);
3393         VPRINTK("EXIT, returning 0\n");
3394         return 0;
3395 }
3396
3397 /**
3398  *      ata_scsi_release - SCSI layer callback hook for host unload
3399  *      @host: libata host to be unloaded
3400  *
3401  *      Performs all duties necessary to shut down a libata port...
3402  *      Kill port kthread, disable port, and release resources.
3403  *
3404  *      LOCKING:
3405  *      Inherited from SCSI layer.
3406  *
3407  *      RETURNS:
3408  *      One.
3409  */
3410
3411 int ata_scsi_release(struct Scsi_Host *host)
3412 {
3413         struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
3414
3415         DPRINTK("ENTER\n");
3416
3417         ap->ops->port_disable(ap);
3418         ata_host_remove(ap, 0);
3419
3420         DPRINTK("EXIT\n");
3421         return 1;
3422 }
3423
3424 /**
3425  *      ata_std_ports - initialize ioaddr with standard port offsets.
3426  *      @ioaddr: IO address structure to be initialized
3427  */
3428 void ata_std_ports(struct ata_ioports *ioaddr)
3429 {
3430         ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
3431         ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
3432         ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
3433         ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
3434         ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
3435         ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
3436         ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
3437         ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
3438         ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
3439         ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
3440 }
3441
3442 static struct ata_probe_ent *
3443 ata_probe_ent_alloc(int n, struct pci_dev *pdev, struct ata_port_info **port)
3444 {
3445         struct ata_probe_ent *probe_ent;
3446         int i;
3447
3448         probe_ent = kmalloc(sizeof(*probe_ent) * n, GFP_KERNEL);
3449         if (!probe_ent) {
3450                 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
3451                        pci_name(pdev));
3452                 return NULL;
3453         }
3454
3455         memset(probe_ent, 0, sizeof(*probe_ent) * n);
3456
3457         for (i = 0; i < n; i++) {
3458                 INIT_LIST_HEAD(&probe_ent[i].node);
3459                 probe_ent[i].pdev = pdev;
3460
3461                 probe_ent[i].sht = port[i]->sht;
3462                 probe_ent[i].host_flags = port[i]->host_flags;
3463                 probe_ent[i].pio_mask = port[i]->pio_mask;
3464                 probe_ent[i].mwdma_mask = port[i]->mwdma_mask;
3465                 probe_ent[i].udma_mask = port[i]->udma_mask;
3466                 probe_ent[i].port_ops = port[i]->port_ops;
3467
3468         }
3469
3470         return probe_ent;
3471 }
3472
3473 struct ata_probe_ent *
3474 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
3475 {
3476         struct ata_probe_ent *probe_ent = ata_probe_ent_alloc(1, pdev, port);
3477         if (!probe_ent)
3478                 return NULL;
3479
3480         probe_ent->n_ports = 2;
3481         probe_ent->irq = pdev->irq;
3482         probe_ent->irq_flags = SA_SHIRQ;
3483
3484         probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
3485         probe_ent->port[0].altstatus_addr =
3486         probe_ent->port[0].ctl_addr =
3487                 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
3488         probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
3489
3490         probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
3491         probe_ent->port[1].altstatus_addr =
3492         probe_ent->port[1].ctl_addr =
3493                 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
3494         probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
3495
3496         ata_std_ports(&probe_ent->port[0]);
3497         ata_std_ports(&probe_ent->port[1]);
3498
3499         return probe_ent;
3500 }
3501
3502 struct ata_probe_ent *
3503 ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port)
3504 {
3505         struct ata_probe_ent *probe_ent = ata_probe_ent_alloc(2, pdev, port);
3506         if (!probe_ent)
3507                 return NULL;
3508
3509         probe_ent[0].n_ports = 1;
3510         probe_ent[0].irq = 14;
3511
3512         probe_ent[0].hard_port_no = 0;
3513         probe_ent[0].legacy_mode = 1;
3514
3515         probe_ent[1].n_ports = 1;
3516         probe_ent[1].irq = 15;
3517
3518         probe_ent[1].hard_port_no = 1;
3519         probe_ent[1].legacy_mode = 1;
3520
3521         probe_ent[0].port[0].cmd_addr = 0x1f0;
3522         probe_ent[0].port[0].altstatus_addr =
3523         probe_ent[0].port[0].ctl_addr = 0x3f6;
3524         probe_ent[0].port[0].bmdma_addr = pci_resource_start(pdev, 4);
3525
3526         probe_ent[1].port[0].cmd_addr = 0x170;
3527         probe_ent[1].port[0].altstatus_addr =
3528         probe_ent[1].port[0].ctl_addr = 0x376;
3529         probe_ent[1].port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
3530
3531         ata_std_ports(&probe_ent[0].port[0]);
3532         ata_std_ports(&probe_ent[1].port[0]);
3533
3534         return probe_ent;
3535 }
3536
3537 /**
3538  *      ata_pci_init_one - Initialize/register PCI IDE host controller
3539  *      @pdev: Controller to be initialized
3540  *      @port_info: Information from low-level host driver
3541  *      @n_ports: Number of ports attached to host controller
3542  *
3543  *      LOCKING:
3544  *      Inherited from PCI layer (may sleep).
3545  *
3546  *      RETURNS:
3547  *
3548  */
3549
3550 int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
3551                       unsigned int n_ports)
3552 {
3553         struct ata_probe_ent *probe_ent, *probe_ent2 = NULL;
3554         struct ata_port_info *port[2];
3555         u8 tmp8, mask;
3556         unsigned int legacy_mode = 0;
3557         int rc;
3558
3559         DPRINTK("ENTER\n");
3560
3561         port[0] = port_info[0];
3562         if (n_ports > 1)
3563                 port[1] = port_info[1];
3564         else
3565                 port[1] = port[0];
3566
3567         if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0) {
3568                 /* TODO: support transitioning to native mode? */
3569                 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
3570                 mask = (1 << 2) | (1 << 0);
3571                 if ((tmp8 & mask) != mask)
3572                         legacy_mode = (1 << 3);
3573         }
3574
3575         /* FIXME... */
3576         if ((!legacy_mode) && (n_ports > 1)) {
3577                 printk(KERN_ERR "ata: BUG: native mode, n_ports > 1\n");
3578                 return -EINVAL;
3579         }
3580
3581         rc = pci_enable_device(pdev);
3582         if (rc)
3583                 return rc;
3584
3585         rc = pci_request_regions(pdev, DRV_NAME);
3586         if (rc)
3587                 goto err_out;
3588
3589         if (legacy_mode) {
3590                 if (!request_region(0x1f0, 8, "libata")) {
3591                         struct resource *conflict, res;
3592                         res.start = 0x1f0;
3593                         res.end = 0x1f0 + 8 - 1;
3594                         conflict = ____request_resource(&ioport_resource, &res);
3595                         if (!strcmp(conflict->name, "libata"))
3596                                 legacy_mode |= (1 << 0);
3597                         else
3598                                 printk(KERN_WARNING "ata: 0x1f0 IDE port busy\n");
3599                 } else
3600                         legacy_mode |= (1 << 0);
3601
3602                 if (!request_region(0x170, 8, "libata")) {
3603                         struct resource *conflict, res;
3604                         res.start = 0x170;
3605                         res.end = 0x170 + 8 - 1;
3606                         conflict = ____request_resource(&ioport_resource, &res);
3607                         if (!strcmp(conflict->name, "libata"))
3608                                 legacy_mode |= (1 << 1);
3609                         else
3610                                 printk(KERN_WARNING "ata: 0x170 IDE port busy\n");
3611                 } else
3612                         legacy_mode |= (1 << 1);
3613         }
3614
3615         /* we have legacy mode, but all ports are unavailable */
3616         if (legacy_mode == (1 << 3)) {
3617                 rc = -EBUSY;
3618                 goto err_out_regions;
3619         }
3620
3621         rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
3622         if (rc)
3623                 goto err_out_regions;
3624         rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
3625         if (rc)
3626                 goto err_out_regions;
3627
3628         if (legacy_mode) {
3629                 probe_ent = ata_pci_init_legacy_mode(pdev, port);
3630                 if (probe_ent)
3631                         probe_ent2 = &probe_ent[1];
3632         } else
3633                 probe_ent = ata_pci_init_native_mode(pdev, port);
3634         if (!probe_ent) {
3635                 rc = -ENOMEM;
3636                 goto err_out_regions;
3637         }
3638
3639         pci_set_master(pdev);
3640
3641         /* FIXME: check ata_device_add return */
3642         if (legacy_mode) {
3643                 if (legacy_mode & (1 << 0))
3644                         ata_device_add(probe_ent);
3645                 if (legacy_mode & (1 << 1))
3646                         ata_device_add(probe_ent2);
3647         } else {
3648                 ata_device_add(probe_ent);
3649         }
3650         kfree(probe_ent);
3651
3652         return 0;
3653
3654 err_out_regions:
3655         if (legacy_mode & (1 << 0))
3656                 release_region(0x1f0, 8);
3657         if (legacy_mode & (1 << 1))
3658                 release_region(0x170, 8);
3659         pci_release_regions(pdev);
3660 err_out:
3661         pci_disable_device(pdev);
3662         return rc;
3663 }
3664
3665 /**
3666  *      ata_pci_remove_one - PCI layer callback for device removal
3667  *      @pdev: PCI device that was removed
3668  *
3669  *      PCI layer indicates to libata via this hook that
3670  *      hot-unplug or module unload event has occured.
3671  *      Handle this by unregistering all objects associated
3672  *      with this PCI device.  Free those objects.  Then finally
3673  *      release PCI resources and disable device.
3674  *
3675  *      LOCKING:
3676  *      Inherited from PCI layer (may sleep).
3677  */
3678
3679 void ata_pci_remove_one (struct pci_dev *pdev)
3680 {
3681         struct ata_host_set *host_set = pci_get_drvdata(pdev);
3682         struct ata_port *ap;
3683         unsigned int i;
3684
3685         for (i = 0; i < host_set->n_ports; i++) {
3686                 ap = host_set->ports[i];
3687
3688                 scsi_remove_host(ap->host);
3689         }
3690
3691         free_irq(host_set->irq, host_set);
3692         if (host_set->ops->host_stop)
3693                 host_set->ops->host_stop(host_set);
3694         if (host_set->mmio_base)
3695                 iounmap(host_set->mmio_base);
3696
3697         for (i = 0; i < host_set->n_ports; i++) {
3698                 ap = host_set->ports[i];
3699
3700                 ata_scsi_release(ap->host);
3701                 scsi_host_put(ap->host);
3702         }
3703
3704         pci_release_regions(pdev);
3705
3706         for (i = 0; i < host_set->n_ports; i++) {
3707                 struct ata_ioports *ioaddr;
3708
3709                 ap = host_set->ports[i];
3710                 ioaddr = &ap->ioaddr;
3711
3712                 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
3713                         if (ioaddr->cmd_addr == 0x1f0)
3714                                 release_region(0x1f0, 8);
3715                         else if (ioaddr->cmd_addr == 0x170)
3716                                 release_region(0x170, 8);
3717                 }
3718         }
3719
3720         kfree(host_set);
3721         pci_disable_device(pdev);
3722         pci_set_drvdata(pdev, NULL);
3723 }
3724
3725 /* move to PCI subsystem */
3726 int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
3727 {
3728         unsigned long tmp = 0;
3729
3730         switch (bits->width) {
3731         case 1: {
3732                 u8 tmp8 = 0;
3733                 pci_read_config_byte(pdev, bits->reg, &tmp8);
3734                 tmp = tmp8;
3735                 break;
3736         }
3737         case 2: {
3738                 u16 tmp16 = 0;
3739                 pci_read_config_word(pdev, bits->reg, &tmp16);
3740                 tmp = tmp16;
3741                 break;
3742         }
3743         case 4: {
3744                 u32 tmp32 = 0;
3745                 pci_read_config_dword(pdev, bits->reg, &tmp32);
3746                 tmp = tmp32;
3747                 break;
3748         }
3749
3750         default:
3751                 return -EINVAL;
3752         }
3753
3754         tmp &= bits->mask;
3755
3756         return (tmp == bits->val) ? 1 : 0;
3757 }
3758
3759
3760 /**
3761  *      ata_init -
3762  *
3763  *      LOCKING:
3764  *
3765  *      RETURNS:
3766  *
3767  */
3768
3769 static int __init ata_init(void)
3770 {
3771         ata_wq = create_workqueue("ata");
3772         if (!ata_wq)
3773                 return -ENOMEM;
3774
3775         printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
3776         return 0;
3777 }
3778
3779 static void __exit ata_exit(void)
3780 {
3781         destroy_workqueue(ata_wq);
3782 }
3783
3784 module_init(ata_init);
3785 module_exit(ata_exit);
3786
3787 /*
3788  * libata is essentially a library of internal helper functions for
3789  * low-level ATA host controller drivers.  As such, the API/ABI is
3790  * likely to change as new drivers are added and updated.
3791  * Do not depend on ABI/API stability.
3792  */
3793
3794 EXPORT_SYMBOL_GPL(pci_test_config_bits);
3795 EXPORT_SYMBOL_GPL(ata_std_bios_param);
3796 EXPORT_SYMBOL_GPL(ata_std_ports);
3797 EXPORT_SYMBOL_GPL(ata_device_add);
3798 EXPORT_SYMBOL_GPL(ata_sg_init);
3799 EXPORT_SYMBOL_GPL(ata_sg_init_one);
3800 EXPORT_SYMBOL_GPL(ata_qc_complete);
3801 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
3802 EXPORT_SYMBOL_GPL(ata_eng_timeout);
3803 EXPORT_SYMBOL_GPL(ata_tf_load);
3804 EXPORT_SYMBOL_GPL(ata_tf_read);
3805 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
3806 EXPORT_SYMBOL_GPL(ata_std_dev_select);
3807 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
3808 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
3809 EXPORT_SYMBOL_GPL(ata_pci_init_legacy_mode);
3810 EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
3811 EXPORT_SYMBOL_GPL(ata_check_status);
3812 EXPORT_SYMBOL_GPL(ata_exec_command);
3813 EXPORT_SYMBOL_GPL(ata_port_start);
3814 EXPORT_SYMBOL_GPL(ata_port_stop);
3815 EXPORT_SYMBOL_GPL(ata_interrupt);
3816 EXPORT_SYMBOL_GPL(ata_qc_prep);
3817 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
3818 EXPORT_SYMBOL_GPL(ata_bmdma_start);
3819 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
3820 EXPORT_SYMBOL_GPL(ata_port_probe);
3821 EXPORT_SYMBOL_GPL(sata_phy_reset);
3822 EXPORT_SYMBOL_GPL(__sata_phy_reset);
3823 EXPORT_SYMBOL_GPL(ata_bus_reset);
3824 EXPORT_SYMBOL_GPL(ata_port_disable);
3825 EXPORT_SYMBOL_GPL(ata_pci_init_one);
3826 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
3827 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
3828 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
3829 EXPORT_SYMBOL_GPL(ata_scsi_error);
3830 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
3831 EXPORT_SYMBOL_GPL(ata_scsi_release);
3832 EXPORT_SYMBOL_GPL(ata_host_intr);
3833 EXPORT_SYMBOL_GPL(ata_dev_classify);
3834 EXPORT_SYMBOL_GPL(ata_dev_id_string);
3835 EXPORT_SYMBOL_GPL(ata_scsi_simulate);