drivers/scsi/libata-core.c

   1 /*
   2  *  libata-core.c - helper library for ATA
   3  *
   4  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
   5  *                  Please ALWAYS copy linux-ide@vger.kernel.org
   6  *                  on emails.
   7  *
   8  *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   9  *  Copyright 2003-2004 Jeff Garzik
  10  *
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2, or (at your option)
  15  *  any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; see the file COPYING.  If not, write to
  24  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25  *
  26  *
  27  *  libata documentation is available via 'make {ps|pdf}docs',
  28  *  as Documentation/DocBook/libata.*
  29  *
  30  *  Hardware documentation available from http://www.t13.org/ and
  31  *  http://www.sata-io.org/
  32  *
  33  */
  34
  35 #include <linux/config.h>
  36 #include <linux/kernel.h>
  37 #include <linux/module.h>
  38 #include <linux/pci.h>
  39 #include <linux/init.h>
  40 #include <linux/list.h>
  41 #include <linux/mm.h>
  42 #include <linux/highmem.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/blkdev.h>
  45 #include <linux/delay.h>
  46 #include <linux/timer.h>
  47 #include <linux/interrupt.h>
  48 #include <linux/completion.h>
  49 #include <linux/suspend.h>
  50 #include <linux/workqueue.h>
  51 #include <linux/jiffies.h>
  52 #include <linux/scatterlist.h>
  53 #include <scsi/scsi.h>
  54 #include "scsi_priv.h"
  55 #include <scsi/scsi_cmnd.h>
  56 #include <scsi/scsi_host.h>
  57 #include <linux/libata.h>
  58 #include <asm/io.h>
  59 #include <asm/semaphore.h>
  60 #include <asm/byteorder.h>
  61
  62 #include "libata.h"
  63
  64 /* debounce timing parameters in msecs { interval, duration, timeout } */
  65 const unsigned long sata_deb_timing_boot[]              = {   5,  100, 2000 };
  66 const unsigned long sata_deb_timing_eh[]                = {  25,  500, 2000 };
  67 const unsigned long sata_deb_timing_before_fsrst[]      = { 100, 2000, 5000 };
  68
  69 static unsigned int ata_dev_init_params(struct ata_device *dev,
  70                                         u16 heads, u16 sectors);
  71 static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
  72 static void ata_dev_xfermask(struct ata_device *dev);
  73
  74 static unsigned int ata_unique_id = 1;
  75 static struct workqueue_struct *ata_wq;
  76
  77 struct workqueue_struct *ata_aux_wq;
  78
  79 int atapi_enabled = 1;
  80 module_param(atapi_enabled, int, 0444);
  81 MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
  82
  83 int atapi_dmadir = 0;
  84 module_param(atapi_dmadir, int, 0444);
  85 MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
  86
  87 int libata_fua = 0;
  88 module_param_named(fua, libata_fua, int, 0444);
  89 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
  90
  91 MODULE_AUTHOR("Jeff Garzik");
  92 MODULE_DESCRIPTION("Library module for ATA devices");
  93 MODULE_LICENSE("GPL");
  94 MODULE_VERSION(DRV_VERSION);
  95
  96
  97 /**
  98  *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
  99  *      @tf: Taskfile to convert
 100  *      @fis: Buffer into which data will output
 101  *      @pmp: Port multiplier port
 102  *
 103  *      Converts a standard ATA taskfile to a Serial ATA
 104  *      FIS structure (Register - Host to Device).
 105  *
 106  *      LOCKING:
 107  *      Inherited from caller.
 108  */
 109
 110 void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
 111 {
 112         fis[0] = 0x27;  /* Register - Host to Device FIS */
 113         fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
 114                                             bit 7 indicates Command FIS */
 115         fis[2] = tf->command;
 116         fis[3] = tf->feature;
 117
 118         fis[4] = tf->lbal;
 119         fis[5] = tf->lbam;
 120         fis[6] = tf->lbah;
 121         fis[7] = tf->device;
 122
 123         fis[8] = tf->hob_lbal;
 124         fis[9] = tf->hob_lbam;
 125         fis[10] = tf->hob_lbah;
 126         fis[11] = tf->hob_feature;
 127
 128         fis[12] = tf->nsect;
 129         fis[13] = tf->hob_nsect;
 130         fis[14] = 0;
 131         fis[15] = tf->ctl;
 132
 133         fis[16] = 0;
 134         fis[17] = 0;
 135         fis[18] = 0;
 136         fis[19] = 0;
 137 }
 138
 139 /**
 140  *      ata_tf_from_fis - Convert SATA FIS to ATA taskfile
 141  *      @fis: Buffer from which data will be input
 142  *      @tf: Taskfile to output
 143  *
 144  *      Converts a serial ATA FIS structure to a standard ATA taskfile.
 145  *
 146  *      LOCKING:
 147  *      Inherited from caller.
 148  */
 149
 150 void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
 151 {
 152         tf->command     = fis[2];       /* status */
 153         tf->feature     = fis[3];       /* error */
 154
 155         tf->lbal        = fis[4];
 156         tf->lbam        = fis[5];
 157         tf->lbah        = fis[6];
 158         tf->device      = fis[7];
 159
 160         tf->hob_lbal    = fis[8];
 161         tf->hob_lbam    = fis[9];
 162         tf->hob_lbah    = fis[10];
 163
 164         tf->nsect       = fis[12];
 165         tf->hob_nsect   = fis[13];
 166 }
 167
 168 static const u8 ata_rw_cmds[] = {
 169         /* pio multi */
 170         ATA_CMD_READ_MULTI,
 171         ATA_CMD_WRITE_MULTI,
 172         ATA_CMD_READ_MULTI_EXT,
 173         ATA_CMD_WRITE_MULTI_EXT,
 174         0,
 175         0,
 176         0,
 177         ATA_CMD_WRITE_MULTI_FUA_EXT,
 178         /* pio */
 179         ATA_CMD_PIO_READ,
 180         ATA_CMD_PIO_WRITE,
 181         ATA_CMD_PIO_READ_EXT,
 182         ATA_CMD_PIO_WRITE_EXT,
 183         0,
 184         0,
 185         0,
 186         0,
 187         /* dma */
 188         ATA_CMD_READ,
 189         ATA_CMD_WRITE,
 190         ATA_CMD_READ_EXT,
 191         ATA_CMD_WRITE_EXT,
 192         0,
 193         0,
 194         0,
 195         ATA_CMD_WRITE_FUA_EXT
 196 };
 197
 198 /**
 199  *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
 200  *      @qc: command to examine and configure
 201  *
 202  *      Examine the device configuration and tf->flags to calculate
 203  *      the proper read/write commands and protocol to use.
 204  *
 205  *      LOCKING:
 206  *      caller.
 207  */
 208 int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
 209 {
 210         struct ata_taskfile *tf = &qc->tf;
 211         struct ata_device *dev = qc->dev;
 212         u8 cmd;
 213
 214         int index, fua, lba48, write;
 215
 216         fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
 217         lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
 218         write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
 219
 220         if (dev->flags & ATA_DFLAG_PIO) {
 221                 tf->protocol = ATA_PROT_PIO;
 222                 index = dev->multi_count ? 0 : 8;
 223         } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
 224                 /* Unable to use DMA due to host limitation */
 225                 tf->protocol = ATA_PROT_PIO;
 226                 index = dev->multi_count ? 0 : 8;
 227         } else {
 228                 tf->protocol = ATA_PROT_DMA;
 229                 index = 16;
 230         }
 231
 232         cmd = ata_rw_cmds[index + fua + lba48 + write];
 233         if (cmd) {
 234                 tf->command = cmd;
 235                 return 0;
 236         }
 237         return -1;
 238 }
 239
 240 /**
 241  *      ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
 242  *      @pio_mask: pio_mask
 243  *      @mwdma_mask: mwdma_mask
 244  *      @udma_mask: udma_mask
 245  *
 246  *      Pack @pio_mask, @mwdma_mask and @udma_mask into a single
 247  *      unsigned int xfer_mask.
 248  *
 249  *      LOCKING:
 250  *      None.
 251  *
 252  *      RETURNS:
 253  *      Packed xfer_mask.
 254  */
 255 static unsigned int ata_pack_xfermask(unsigned int pio_mask,
 256                                       unsigned int mwdma_mask,
 257                                       unsigned int udma_mask)
 258 {
 259         return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
 260                 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
 261                 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
 262 }
 263
 264 /**
 265  *      ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
 266  *      @xfer_mask: xfer_mask to unpack
 267  *      @pio_mask: resulting pio_mask
 268  *      @mwdma_mask: resulting mwdma_mask
 269  *      @udma_mask: resulting udma_mask
 270  *
 271  *      Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
 272  *      Any NULL distination masks will be ignored.
 273  */
 274 static void ata_unpack_xfermask(unsigned int xfer_mask,
 275                                 unsigned int *pio_mask,
 276                                 unsigned int *mwdma_mask,
 277                                 unsigned int *udma_mask)
 278 {
 279         if (pio_mask)
 280                 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
 281         if (mwdma_mask)
 282                 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
 283         if (udma_mask)
 284                 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
 285 }
 286
 287 static const struct ata_xfer_ent {
 288         int shift, bits;
 289         u8 base;
 290 } ata_xfer_tbl[] = {
 291         { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
 292         { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
 293         { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
 294         { -1, },
 295 };
 296
 297 /**
 298  *      ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
 299  *      @xfer_mask: xfer_mask of interest
 300  *
 301  *      Return matching XFER_* value for @xfer_mask.  Only the highest
 302  *      bit of @xfer_mask is considered.
 303  *
 304  *      LOCKING:
 305  *      None.
 306  *
 307  *      RETURNS:
 308  *      Matching XFER_* value, 0 if no match found.
 309  */
 310 static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
 311 {
 312         int highbit = fls(xfer_mask) - 1;
 313         const struct ata_xfer_ent *ent;
 314
 315         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 316                 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
 317                         return ent->base + highbit - ent->shift;
 318         return 0;
 319 }
 320
 321 /**
 322  *      ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
 323  *      @xfer_mode: XFER_* of interest
 324  *
 325  *      Return matching xfer_mask for @xfer_mode.
 326  *
 327  *      LOCKING:
 328  *      None.
 329  *
 330  *      RETURNS:
 331  *      Matching xfer_mask, 0 if no match found.
 332  */
 333 static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
 334 {
 335         const struct ata_xfer_ent *ent;
 336
 337         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 338                 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
 339                         return 1 << (ent->shift + xfer_mode - ent->base);
 340         return 0;
 341 }
 342
 343 /**
 344  *      ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
 345  *      @xfer_mode: XFER_* of interest
 346  *
 347  *      Return matching xfer_shift for @xfer_mode.
 348  *
 349  *      LOCKING:
 350  *      None.
 351  *
 352  *      RETURNS:
 353  *      Matching xfer_shift, -1 if no match found.
 354  */
 355 static int ata_xfer_mode2shift(unsigned int xfer_mode)
 356 {
 357         const struct ata_xfer_ent *ent;
 358
 359         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 360                 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
 361                         return ent->shift;
 362         return -1;
 363 }
 364
 365 /**
 366  *      ata_mode_string - convert xfer_mask to string
 367  *      @xfer_mask: mask of bits supported; only highest bit counts.
 368  *
 369  *      Determine string which represents the highest speed
 370  *      (highest bit in @modemask).
 371  *
 372  *      LOCKING:
 373  *      None.
 374  *
 375  *      RETURNS:
 376  *      Constant C string representing highest speed listed in
 377  *      @mode_mask, or the constant C string "<n/a>".
 378  */
 379 static const char *ata_mode_string(unsigned int xfer_mask)
 380 {
 381         static const char * const xfer_mode_str[] = {
 382                 "PIO0",
 383                 "PIO1",
 384                 "PIO2",
 385                 "PIO3",
 386                 "PIO4",
 387                 "MWDMA0",
 388                 "MWDMA1",
 389                 "MWDMA2",
 390                 "UDMA/16",
 391                 "UDMA/25",
 392                 "UDMA/33",
 393                 "UDMA/44",
 394                 "UDMA/66",
 395                 "UDMA/100",
 396                 "UDMA/133",
 397                 "UDMA7",
 398         };
 399         int highbit;
 400
 401         highbit = fls(xfer_mask) - 1;
 402         if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
 403                 return xfer_mode_str[highbit];
 404         return "<n/a>";
 405 }
 406
 407 static const char *sata_spd_string(unsigned int spd)
 408 {
 409         static const char * const spd_str[] = {
 410                 "1.5 Gbps",
 411                 "3.0 Gbps",
 412         };
 413
 414         if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
 415                 return "<unknown>";
 416         return spd_str[spd - 1];
 417 }
 418
 419 void ata_dev_disable(struct ata_device *dev)
 420 {
 421         if (ata_dev_enabled(dev)) {
 422                 ata_dev_printk(dev, KERN_WARNING, "disabled\n");
 423                 dev->class++;
 424         }
 425 }
 426
 427 /**
 428  *      ata_pio_devchk - PATA device presence detection
 429  *      @ap: ATA channel to examine
 430  *      @device: Device to examine (starting at zero)
 431  *
 432  *      This technique was originally described in
 433  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
 434  *      later found its way into the ATA/ATAPI spec.
 435  *
 436  *      Write a pattern to the ATA shadow registers,
 437  *      and if a device is present, it will respond by
 438  *      correctly storing and echoing back the
 439  *      ATA shadow register contents.
 440  *
 441  *      LOCKING:
 442  *      caller.
 443  */
 444
 445 static unsigned int ata_pio_devchk(struct ata_port *ap,
 446                                    unsigned int device)
 447 {
 448         struct ata_ioports *ioaddr = &ap->ioaddr;
 449         u8 nsect, lbal;
 450
 451         ap->ops->dev_select(ap, device);
 452
 453         outb(0x55, ioaddr->nsect_addr);
 454         outb(0xaa, ioaddr->lbal_addr);
 455
 456         outb(0xaa, ioaddr->nsect_addr);
 457         outb(0x55, ioaddr->lbal_addr);
 458
 459         outb(0x55, ioaddr->nsect_addr);
 460         outb(0xaa, ioaddr->lbal_addr);
 461
 462         nsect = inb(ioaddr->nsect_addr);
 463         lbal = inb(ioaddr->lbal_addr);
 464
 465         if ((nsect == 0x55) && (lbal == 0xaa))
 466                 return 1;       /* we found a device */
 467
 468         return 0;               /* nothing found */
 469 }
 470
 471 /**
 472  *      ata_mmio_devchk - PATA device presence detection
 473  *      @ap: ATA channel to examine
 474  *      @device: Device to examine (starting at zero)
 475  *
 476  *      This technique was originally described in
 477  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
 478  *      later found its way into the ATA/ATAPI spec.
 479  *
 480  *      Write a pattern to the ATA shadow registers,
 481  *      and if a device is present, it will respond by
 482  *      correctly storing and echoing back the
 483  *      ATA shadow register contents.
 484  *
 485  *      LOCKING:
 486  *      caller.
 487  */
 488
 489 static unsigned int ata_mmio_devchk(struct ata_port *ap,
 490                                     unsigned int device)
 491 {
 492         struct ata_ioports *ioaddr = &ap->ioaddr;
 493         u8 nsect, lbal;
 494
 495         ap->ops->dev_select(ap, device);
 496
 497         writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
 498         writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
 499
 500         writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
 501         writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
 502
 503         writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
 504         writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
 505
 506         nsect = readb((void __iomem *) ioaddr->nsect_addr);
 507         lbal = readb((void __iomem *) ioaddr->lbal_addr);
 508
 509         if ((nsect == 0x55) && (lbal == 0xaa))
 510                 return 1;       /* we found a device */
 511
 512         return 0;               /* nothing found */
 513 }
 514
 515 /**
 516  *      ata_devchk - PATA device presence detection
 517  *      @ap: ATA channel to examine
 518  *      @device: Device to examine (starting at zero)
 519  *
 520  *      Dispatch ATA device presence detection, depending
 521  *      on whether we are using PIO or MMIO to talk to the
 522  *      ATA shadow registers.
 523  *
 524  *      LOCKING:
 525  *      caller.
 526  */
 527
 528 static unsigned int ata_devchk(struct ata_port *ap,
 529                                     unsigned int device)
 530 {
 531         if (ap->flags & ATA_FLAG_MMIO)
 532                 return ata_mmio_devchk(ap, device);
 533         return ata_pio_devchk(ap, device);
 534 }
 535
 536 /**
 537  *      ata_dev_classify - determine device type based on ATA-spec signature
 538  *      @tf: ATA taskfile register set for device to be identified
 539  *
 540  *      Determine from taskfile register contents whether a device is
 541  *      ATA or ATAPI, as per "Signature and persistence" section
 542  *      of ATA/PI spec (volume 1, sect 5.14).
 543  *
 544  *      LOCKING:
 545  *      None.
 546  *
 547  *      RETURNS:
 548  *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
 549  *      the event of failure.
 550  */
 551
 552 unsigned int ata_dev_classify(const struct ata_taskfile *tf)
 553 {
 554         /* Apple's open source Darwin code hints that some devices only
 555          * put a proper signature into the LBA mid/high registers,
 556          * So, we only check those.  It's sufficient for uniqueness.
 557          */
 558
 559         if (((tf->lbam == 0) && (tf->lbah == 0)) ||
 560             ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
 561                 DPRINTK("found ATA device by sig\n");
 562                 return ATA_DEV_ATA;
 563         }
 564
 565         if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
 566             ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
 567                 DPRINTK("found ATAPI device by sig\n");
 568                 return ATA_DEV_ATAPI;
 569         }
 570
 571         DPRINTK("unknown device\n");
 572         return ATA_DEV_UNKNOWN;
 573 }
 574
 575 /**
 576  *      ata_dev_try_classify - Parse returned ATA device signature
 577  *      @ap: ATA channel to examine
 578  *      @device: Device to examine (starting at zero)
 579  *      @r_err: Value of error register on completion
 580  *
 581  *      After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
 582  *      an ATA/ATAPI-defined set of values is placed in the ATA
 583  *      shadow registers, indicating the results of device detection
 584  *      and diagnostics.
 585  *
 586  *      Select the ATA device, and read the values from the ATA shadow
 587  *      registers.  Then parse according to the Error register value,
 588  *      and the spec-defined values examined by ata_dev_classify().
 589  *
 590  *      LOCKING:
 591  *      caller.
 592  *
 593  *      RETURNS:
 594  *      Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
 595  */
 596
 597 static unsigned int
 598 ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
 599 {
 600         struct ata_taskfile tf;
 601         unsigned int class;
 602         u8 err;
 603
 604         ap->ops->dev_select(ap, device);
 605
 606         memset(&tf, 0, sizeof(tf));
 607
 608         ap->ops->tf_read(ap, &tf);
 609         err = tf.feature;
 610         if (r_err)
 611                 *r_err = err;
 612
 613         /* see if device passed diags */
 614         if (err == 1)
 615                 /* do nothing */ ;
 616         else if ((device == 0) && (err == 0x81))
 617                 /* do nothing */ ;
 618         else
 619                 return ATA_DEV_NONE;
 620
 621         /* determine if device is ATA or ATAPI */
 622         class = ata_dev_classify(&tf);
 623
 624         if (class == ATA_DEV_UNKNOWN)
 625                 return ATA_DEV_NONE;
 626         if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
 627                 return ATA_DEV_NONE;
 628         return class;
 629 }
 630
 631 /**
 632  *      ata_id_string - Convert IDENTIFY DEVICE page into string
 633  *      @id: IDENTIFY DEVICE results we will examine
 634  *      @s: string into which data is output
 635  *      @ofs: offset into identify device page
 636  *      @len: length of string to return. must be an even number.
 637  *
 638  *      The strings in the IDENTIFY DEVICE page are broken up into
 639  *      16-bit chunks.  Run through the string, and output each
 640  *      8-bit chunk linearly, regardless of platform.
 641  *
 642  *      LOCKING:
 643  *      caller.
 644  */
 645
 646 void ata_id_string(const u16 *id, unsigned char *s,
 647                    unsigned int ofs, unsigned int len)
 648 {
 649         unsigned int c;
 650
 651         while (len > 0) {
 652                 c = id[ofs] >> 8;
 653                 *s = c;
 654                 s++;
 655
 656                 c = id[ofs] & 0xff;
 657                 *s = c;
 658                 s++;
 659
 660                 ofs++;
 661                 len -= 2;
 662         }
 663 }
 664
 665 /**
 666  *      ata_id_c_string - Convert IDENTIFY DEVICE page into C string
 667  *      @id: IDENTIFY DEVICE results we will examine
 668  *      @s: string into which data is output
 669  *      @ofs: offset into identify device page
 670  *      @len: length of string to return. must be an odd number.
 671  *
 672  *      This function is identical to ata_id_string except that it
 673  *      trims trailing spaces and terminates the resulting string with
 674  *      null.  @len must be actual maximum length (even number) + 1.
 675  *
 676  *      LOCKING:
 677  *      caller.
 678  */
 679 void ata_id_c_string(const u16 *id, unsigned char *s,
 680                      unsigned int ofs, unsigned int len)
 681 {
 682         unsigned char *p;
 683
 684         WARN_ON(!(len & 1));
 685
 686         ata_id_string(id, s, ofs, len - 1);
 687
 688         p = s + strnlen(s, len - 1);
 689         while (p > s && p[-1] == ' ')
 690                 p--;
 691         *p = '\0';
 692 }
 693
 694 static u64 ata_id_n_sectors(const u16 *id)
 695 {
 696         if (ata_id_has_lba(id)) {
 697                 if (ata_id_has_lba48(id))
 698                         return ata_id_u64(id, 100);
 699                 else
 700                         return ata_id_u32(id, 60);
 701         } else {
 702                 if (ata_id_current_chs_valid(id))
 703                         return ata_id_u32(id, 57);
 704                 else
 705                         return id[1] * id[3] * id[6];
 706         }
 707 }
 708
 709 /**
 710  *      ata_noop_dev_select - Select device 0/1 on ATA bus
 711  *      @ap: ATA channel to manipulate
 712  *      @device: ATA device (numbered from zero) to select
 713  *
 714  *      This function performs no actual function.
 715  *
 716  *      May be used as the dev_select() entry in ata_port_operations.
 717  *
 718  *      LOCKING:
 719  *      caller.
 720  */
 721 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
 722 {
 723 }
 724
 725
 726 /**
 727  *      ata_std_dev_select - Select device 0/1 on ATA bus
 728  *      @ap: ATA channel to manipulate
 729  *      @device: ATA device (numbered from zero) to select
 730  *
 731  *      Use the method defined in the ATA specification to
 732  *      make either device 0, or device 1, active on the
 733  *      ATA channel.  Works with both PIO and MMIO.
 734  *
 735  *      May be used as the dev_select() entry in ata_port_operations.
 736  *
 737  *      LOCKING:
 738  *      caller.
 739  */
 740
 741 void ata_std_dev_select (struct ata_port *ap, unsigned int device)
 742 {
 743         u8 tmp;
 744
 745         if (device == 0)
 746                 tmp = ATA_DEVICE_OBS;
 747         else
 748                 tmp = ATA_DEVICE_OBS | ATA_DEV1;
 749
 750         if (ap->flags & ATA_FLAG_MMIO) {
 751                 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
 752         } else {
 753                 outb(tmp, ap->ioaddr.device_addr);
 754         }
 755         ata_pause(ap);          /* needed; also flushes, for mmio */
 756 }
 757
 758 /**
 759  *      ata_dev_select - Select device 0/1 on ATA bus
 760  *      @ap: ATA channel to manipulate
 761  *      @device: ATA device (numbered from zero) to select
 762  *      @wait: non-zero to wait for Status register BSY bit to clear
 763  *      @can_sleep: non-zero if context allows sleeping
 764  *
 765  *      Use the method defined in the ATA specification to
 766  *      make either device 0, or device 1, active on the
 767  *      ATA channel.
 768  *
 769  *      This is a high-level version of ata_std_dev_select(),
 770  *      which additionally provides the services of inserting
 771  *      the proper pauses and status polling, where needed.
 772  *
 773  *      LOCKING:
 774  *      caller.
 775  */
 776
 777 void ata_dev_select(struct ata_port *ap, unsigned int device,
 778                            unsigned int wait, unsigned int can_sleep)
 779 {
 780         VPRINTK("ENTER, ata%u: device %u, wait %u\n",
 781                 ap->id, device, wait);
 782
 783         if (wait)
 784                 ata_wait_idle(ap);
 785
 786         ap->ops->dev_select(ap, device);
 787
 788         if (wait) {
 789                 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
 790                         msleep(150);
 791                 ata_wait_idle(ap);
 792         }
 793 }
 794
 795 /**
 796  *      ata_dump_id - IDENTIFY DEVICE info debugging output
 797  *      @id: IDENTIFY DEVICE page to dump
 798  *
 799  *      Dump selected 16-bit words from the given IDENTIFY DEVICE
 800  *      page.
 801  *
 802  *      LOCKING:
 803  *      caller.
 804  */
 805
 806 static inline void ata_dump_id(const u16 *id)
 807 {
 808         DPRINTK("49==0x%04x  "
 809                 "53==0x%04x  "
 810                 "63==0x%04x  "
 811                 "64==0x%04x  "
 812                 "75==0x%04x  \n",
 813                 id[49],
 814                 id[53],
 815                 id[63],
 816                 id[64],
 817                 id[75]);
 818         DPRINTK("80==0x%04x  "
 819                 "81==0x%04x  "
 820                 "82==0x%04x  "
 821                 "83==0x%04x  "
 822                 "84==0x%04x  \n",
 823                 id[80],
 824                 id[81],
 825                 id[82],
 826                 id[83],
 827                 id[84]);
 828         DPRINTK("88==0x%04x  "
 829                 "93==0x%04x\n",
 830                 id[88],
 831                 id[93]);
 832 }
 833
 834 /**
 835  *      ata_id_xfermask - Compute xfermask from the given IDENTIFY data
 836  *      @id: IDENTIFY data to compute xfer mask from
 837  *
 838  *      Compute the xfermask for this device. This is not as trivial
 839  *      as it seems if we must consider early devices correctly.
 840  *
 841  *      FIXME: pre IDE drive timing (do we care ?).
 842  *
 843  *      LOCKING:
 844  *      None.
 845  *
 846  *      RETURNS:
 847  *      Computed xfermask
 848  */
 849 static unsigned int ata_id_xfermask(const u16 *id)
 850 {
 851         unsigned int pio_mask, mwdma_mask, udma_mask;
 852
 853         /* Usual case. Word 53 indicates word 64 is valid */
 854         if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
 855                 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
 856                 pio_mask <<= 3;
 857                 pio_mask |= 0x7;
 858         } else {
 859                 /* If word 64 isn't valid then Word 51 high byte holds
 860                  * the PIO timing number for the maximum. Turn it into
 861                  * a mask.
 862                  */
 863                 pio_mask = (2 << (id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
 864
 865                 /* But wait.. there's more. Design your standards by
 866                  * committee and you too can get a free iordy field to
 867                  * process. However its the speeds not the modes that
 868                  * are supported... Note drivers using the timing API
 869                  * will get this right anyway
 870                  */
 871         }
 872
 873         mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
 874
 875         udma_mask = 0;
 876         if (id[ATA_ID_FIELD_VALID] & (1 << 2))
 877                 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
 878
 879         return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
 880 }
 881
 882 /**
 883  *      ata_port_queue_task - Queue port_task
 884  *      @ap: The ata_port to queue port_task for
 885  *      @fn: workqueue function to be scheduled
 886  *      @data: data value to pass to workqueue function
 887  *      @delay: delay time for workqueue function
 888  *
 889  *      Schedule @fn(@data) for execution after @delay jiffies using
 890  *      port_task.  There is one port_task per port and it's the
 891  *      user(low level driver)'s responsibility to make sure that only
 892  *      one task is active at any given time.
 893  *
 894  *      libata core layer takes care of synchronization between
 895  *      port_task and EH.  ata_port_queue_task() may be ignored for EH
 896  *      synchronization.
 897  *
 898  *      LOCKING:
 899  *      Inherited from caller.
 900  */
 901 void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *), void *data,
 902                          unsigned long delay)
 903 {
 904         int rc;
 905
 906         if (ap->flags & ATA_FLAG_FLUSH_PORT_TASK)
 907                 return;
 908
 909         PREPARE_WORK(&ap->port_task, fn, data);
 910
 911         if (!delay)
 912                 rc = queue_work(ata_wq, &ap->port_task);
 913         else
 914                 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
 915
 916         /* rc == 0 means that another user is using port task */
 917         WARN_ON(rc == 0);
 918 }
 919
 920 /**
 921  *      ata_port_flush_task - Flush port_task
 922  *      @ap: The ata_port to flush port_task for
 923  *
 924  *      After this function completes, port_task is guranteed not to
 925  *      be running or scheduled.
 926  *
 927  *      LOCKING:
 928  *      Kernel thread context (may sleep)
 929  */
 930 void ata_port_flush_task(struct ata_port *ap)
 931 {
 932         unsigned long flags;
 933
 934         DPRINTK("ENTER\n");
 935
 936         spin_lock_irqsave(&ap->host_set->lock, flags);
 937         ap->flags |= ATA_FLAG_FLUSH_PORT_TASK;
 938         spin_unlock_irqrestore(&ap->host_set->lock, flags);
 939
 940         DPRINTK("flush #1\n");
 941         flush_workqueue(ata_wq);
 942
 943         /*
 944          * At this point, if a task is running, it's guaranteed to see
 945          * the FLUSH flag; thus, it will never queue pio tasks again.
 946          * Cancel and flush.
 947          */
 948         if (!cancel_delayed_work(&ap->port_task)) {
 949                 DPRINTK("flush #2\n");
 950                 flush_workqueue(ata_wq);
 951         }
 952
 953         spin_lock_irqsave(&ap->host_set->lock, flags);
 954         ap->flags &= ~ATA_FLAG_FLUSH_PORT_TASK;
 955         spin_unlock_irqrestore(&ap->host_set->lock, flags);
 956
 957         DPRINTK("EXIT\n");
 958 }
 959
 960 void ata_qc_complete_internal(struct ata_queued_cmd *qc)
 961 {
 962         struct completion *waiting = qc->private_data;
 963
 964         complete(waiting);
 965 }
 966
 967 /**
 968  *      ata_exec_internal - execute libata internal command
 969  *      @dev: Device to which the command is sent
 970  *      @tf: Taskfile registers for the command and the result
 971  *      @cdb: CDB for packet command
 972  *      @dma_dir: Data tranfer direction of the command
 973  *      @buf: Data buffer of the command
 974  *      @buflen: Length of data buffer
 975  *
 976  *      Executes libata internal command with timeout.  @tf contains
 977  *      command on entry and result on return.  Timeout and error
 978  *      conditions are reported via return value.  No recovery action
 979  *      is taken after a command times out.  It's caller's duty to
 980  *      clean up after timeout.
 981  *
 982  *      LOCKING:
 983  *      None.  Should be called with kernel context, might sleep.
 984  */
 985
 986 unsigned ata_exec_internal(struct ata_device *dev,
 987                            struct ata_taskfile *tf, const u8 *cdb,
 988                            int dma_dir, void *buf, unsigned int buflen)
 989 {
 990         struct ata_port *ap = dev->ap;
 991         u8 command = tf->command;
 992         struct ata_queued_cmd *qc;
 993         unsigned int tag, preempted_tag;
 994         u32 preempted_sactive, preempted_qc_active;
 995         DECLARE_COMPLETION(wait);
 996         unsigned long flags;
 997         unsigned int err_mask;
 998         int rc;
 999
1000         spin_lock_irqsave(&ap->host_set->lock, flags);
1001
1002         /* no internal command while frozen */
1003         if (ap->flags & ATA_FLAG_FROZEN) {
1004                 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1005                 return AC_ERR_SYSTEM;
1006         }
1007
1008         /* initialize internal qc */
1009
1010         /* XXX: Tag 0 is used for drivers with legacy EH as some
1011          * drivers choke if any other tag is given.  This breaks
1012          * ata_tag_internal() test for those drivers.  Don't use new
1013          * EH stuff without converting to it.
1014          */
1015         if (ap->ops->error_handler)
1016                 tag = ATA_TAG_INTERNAL;
1017         else
1018                 tag = 0;
1019
1020         if (test_and_set_bit(tag, &ap->qc_allocated))
1021                 BUG();
1022         qc = __ata_qc_from_tag(ap, tag);
1023
1024         qc->tag = tag;
1025         qc->scsicmd = NULL;
1026         qc->ap = ap;
1027         qc->dev = dev;
1028         ata_qc_reinit(qc);
1029
1030         preempted_tag = ap->active_tag;
1031         preempted_sactive = ap->sactive;
1032         preempted_qc_active = ap->qc_active;
1033         ap->active_tag = ATA_TAG_POISON;
1034         ap->sactive = 0;
1035         ap->qc_active = 0;
1036
1037         /* prepare & issue qc */
1038         qc->tf = *tf;
1039         if (cdb)
1040                 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1041         qc->flags |= ATA_QCFLAG_RESULT_TF;
1042         qc->dma_dir = dma_dir;
1043         if (dma_dir != DMA_NONE) {
1044                 ata_sg_init_one(qc, buf, buflen);
1045                 qc->nsect = buflen / ATA_SECT_SIZE;
1046         }
1047
1048         qc->private_data = &wait;
1049         qc->complete_fn = ata_qc_complete_internal;
1050
1051         ata_qc_issue(qc);
1052
1053         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1054
1055         rc = wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL);
1056
1057         ata_port_flush_task(ap);
1058
1059         if (!rc) {
1060                 spin_lock_irqsave(&ap->host_set->lock, flags);
1061
1062                 /* We're racing with irq here.  If we lose, the
1063                  * following test prevents us from completing the qc
1064                  * twice.  If we win, the port is frozen and will be
1065                  * cleaned up by ->post_internal_cmd().
1066                  */
1067                 if (qc->flags & ATA_QCFLAG_ACTIVE) {
1068                         qc->err_mask |= AC_ERR_TIMEOUT;
1069
1070                         if (ap->ops->error_handler)
1071                                 ata_port_freeze(ap);
1072                         else
1073                                 ata_qc_complete(qc);
1074
1075                         ata_dev_printk(dev, KERN_WARNING,
1076                                        "qc timeout (cmd 0x%x)\n", command);
1077                 }
1078
1079                 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1080         }
1081
1082         /* do post_internal_cmd */
1083         if (ap->ops->post_internal_cmd)
1084                 ap->ops->post_internal_cmd(qc);
1085
1086         if (qc->flags & ATA_QCFLAG_FAILED && !qc->err_mask) {
1087                 ata_dev_printk(dev, KERN_WARNING, "zero err_mask for failed "
1088                                "internal command, assuming AC_ERR_OTHER\n");
1089                 qc->err_mask |= AC_ERR_OTHER;
1090         }
1091
1092         /* finish up */
1093         spin_lock_irqsave(&ap->host_set->lock, flags);
1094
1095         *tf = qc->result_tf;
1096         err_mask = qc->err_mask;
1097
1098         ata_qc_free(qc);
1099         ap->active_tag = preempted_tag;
1100         ap->sactive = preempted_sactive;
1101         ap->qc_active = preempted_qc_active;
1102
1103         /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1104          * Until those drivers are fixed, we detect the condition
1105          * here, fail the command with AC_ERR_SYSTEM and reenable the
1106          * port.
1107          *
1108          * Note that this doesn't change any behavior as internal
1109          * command failure results in disabling the device in the
1110          * higher layer for LLDDs without new reset/EH callbacks.
1111          *
1112          * Kill the following code as soon as those drivers are fixed.
1113          */
1114         if (ap->flags & ATA_FLAG_DISABLED) {
1115                 err_mask |= AC_ERR_SYSTEM;
1116                 ata_port_probe(ap);
1117         }
1118
1119         spin_unlock_irqrestore(&ap->host_set->lock, flags);
1120
1121         return err_mask;
1122 }
1123
1124 /**
1125  *      ata_pio_need_iordy      -       check if iordy needed
1126  *      @adev: ATA device
1127  *
1128  *      Check if the current speed of the device requires IORDY. Used
1129  *      by various controllers for chip configuration.
1130  */
1131
1132 unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1133 {
1134         int pio;
1135         int speed = adev->pio_mode - XFER_PIO_0;
1136
1137         if (speed < 2)
1138                 return 0;
1139         if (speed > 2)
1140                 return 1;
1141
1142         /* If we have no drive specific rule, then PIO 2 is non IORDY */
1143
1144         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1145                 pio = adev->id[ATA_ID_EIDE_PIO];
1146                 /* Is the speed faster than the drive allows non IORDY ? */
1147                 if (pio) {
1148                         /* This is cycle times not frequency - watch the logic! */
1149                         if (pio > 240)  /* PIO2 is 240nS per cycle */
1150                                 return 1;
1151                         return 0;
1152                 }
1153         }
1154         return 0;
1155 }
1156
1157 /**
1158  *      ata_dev_read_id - Read ID data from the specified device
1159  *      @dev: target device
1160  *      @p_class: pointer to class of the target device (may be changed)
1161  *      @post_reset: is this read ID post-reset?
1162  *      @id: buffer to read IDENTIFY data into
1163  *
1164  *      Read ID data from the specified device.  ATA_CMD_ID_ATA is
1165  *      performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
1166  *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
1167  *      for pre-ATA4 drives.
1168  *
1169  *      LOCKING:
1170  *      Kernel thread context (may sleep)
1171  *
1172  *      RETURNS:
1173  *      0 on success, -errno otherwise.
1174  */
1175 int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
1176                     int post_reset, u16 *id)
1177 {
1178         struct ata_port *ap = dev->ap;
1179         unsigned int class = *p_class;
1180         struct ata_taskfile tf;
1181         unsigned int err_mask = 0;
1182         const char *reason;
1183         int rc;
1184
1185         DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1186
1187         ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1188
1189  retry:
1190         ata_tf_init(dev, &tf);
1191
1192         switch (class) {
1193         case ATA_DEV_ATA:
1194                 tf.command = ATA_CMD_ID_ATA;
1195                 break;
1196         case ATA_DEV_ATAPI:
1197                 tf.command = ATA_CMD_ID_ATAPI;
1198                 break;
1199         default:
1200                 rc = -ENODEV;
1201                 reason = "unsupported class";
1202                 goto err_out;
1203         }
1204
1205         tf.protocol = ATA_PROT_PIO;
1206
1207         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1208                                      id, sizeof(id[0]) * ATA_ID_WORDS);
1209         if (err_mask) {
1210                 rc = -EIO;
1211                 reason = "I/O error";
1212                 goto err_out;
1213         }
1214
1215         swap_buf_le16(id, ATA_ID_WORDS);
1216
1217         /* sanity check */
1218         if ((class == ATA_DEV_ATA) != (ata_id_is_ata(id) | ata_id_is_cfa(id))) {
1219                 rc = -EINVAL;
1220                 reason = "device reports illegal type";
1221                 goto err_out;
1222         }
1223
1224         if (post_reset && class == ATA_DEV_ATA) {
1225                 /*
1226                  * The exact sequence expected by certain pre-ATA4 drives is:
1227                  * SRST RESET
1228                  * IDENTIFY
1229                  * INITIALIZE DEVICE PARAMETERS
1230                  * anything else..
1231                  * Some drives were very specific about that exact sequence.
1232                  */
1233                 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
1234                         err_mask = ata_dev_init_params(dev, id[3], id[6]);
1235                         if (err_mask) {
1236                                 rc = -EIO;
1237                                 reason = "INIT_DEV_PARAMS failed";
1238                                 goto err_out;
1239                         }
1240
1241                         /* current CHS translation info (id[53-58]) might be
1242                          * changed. reread the identify device info.
1243                          */
1244                         post_reset = 0;
1245                         goto retry;
1246                 }
1247         }
1248
1249         *p_class = class;
1250
1251         return 0;
1252
1253  err_out:
1254         ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY "
1255                        "(%s, err_mask=0x%x)\n", reason, err_mask);
1256         return rc;
1257 }
1258
1259 static inline u8 ata_dev_knobble(struct ata_device *dev)
1260 {
1261         return ((dev->ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1262 }
1263
1264 static void ata_dev_config_ncq(struct ata_device *dev,
1265                                char *desc, size_t desc_sz)
1266 {
1267         struct ata_port *ap = dev->ap;
1268         int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
1269
1270         if (!ata_id_has_ncq(dev->id)) {
1271                 desc[0] = '\0';
1272                 return;
1273         }
1274
1275         if (ap->flags & ATA_FLAG_NCQ) {
1276                 hdepth = min(ap->host->can_queue, ATA_MAX_QUEUE - 1);
1277                 dev->flags |= ATA_DFLAG_NCQ;
1278         }
1279
1280         if (hdepth >= ddepth)
1281                 snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
1282         else
1283                 snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
1284 }
1285
1286 /**
1287  *      ata_dev_configure - Configure the specified ATA/ATAPI device
1288  *      @dev: Target device to configure
1289  *      @print_info: Enable device info printout
1290  *
1291  *      Configure @dev according to @dev->id.  Generic and low-level
1292  *      driver specific fixups are also applied.
1293  *
1294  *      LOCKING:
1295  *      Kernel thread context (may sleep)
1296  *
1297  *      RETURNS:
1298  *      0 on success, -errno otherwise
1299  */
1300 int ata_dev_configure(struct ata_device *dev, int print_info)
1301 {
1302         struct ata_port *ap = dev->ap;
1303         const u16 *id = dev->id;
1304         unsigned int xfer_mask;
1305         int i, rc;
1306
1307         if (!ata_dev_enabled(dev)) {
1308                 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
1309                         ap->id, dev->devno);
1310                 return 0;
1311         }
1312
1313         DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1314
1315         /* print device capabilities */
1316         if (print_info)
1317                 ata_dev_printk(dev, KERN_DEBUG, "cfg 49:%04x 82:%04x 83:%04x "
1318                                "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1319                                id[49], id[82], id[83], id[84],
1320                                id[85], id[86], id[87], id[88]);
1321
1322         /* initialize to-be-configured parameters */
1323         dev->flags &= ~ATA_DFLAG_CFG_MASK;
1324         dev->max_sectors = 0;
1325         dev->cdb_len = 0;
1326         dev->n_sectors = 0;
1327         dev->cylinders = 0;
1328         dev->heads = 0;
1329         dev->sectors = 0;
1330
1331         /*
1332          * common ATA, ATAPI feature tests
1333          */
1334
1335         /* find max transfer mode; for printk only */
1336         xfer_mask = ata_id_xfermask(id);
1337
1338         ata_dump_id(id);
1339
1340         /* ATA-specific feature tests */
1341         if (dev->class == ATA_DEV_ATA) {
1342                 dev->n_sectors = ata_id_n_sectors(id);
1343
1344                 if (ata_id_has_lba(id)) {
1345                         const char *lba_desc;
1346                         char ncq_desc[20];
1347
1348                         lba_desc = "LBA";
1349                         dev->flags |= ATA_DFLAG_LBA;
1350                         if (ata_id_has_lba48(id)) {
1351                                 dev->flags |= ATA_DFLAG_LBA48;
1352                                 lba_desc = "LBA48";
1353                         }
1354
1355                         /* config NCQ */
1356                         ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
1357
1358                         /* print device info to dmesg */
1359                         if (print_info)
1360                                 ata_dev_printk(dev, KERN_INFO, "ATA-%d, "
1361                                         "max %s, %Lu sectors: %s %s\n",
1362                                         ata_id_major_version(id),
1363                                         ata_mode_string(xfer_mask),
1364                                         (unsigned long long)dev->n_sectors,
1365                                         lba_desc, ncq_desc);
1366                 } else {
1367                         /* CHS */
1368
1369                         /* Default translation */
1370                         dev->cylinders  = id[1];
1371                         dev->heads      = id[3];
1372                         dev->sectors    = id[6];
1373
1374                         if (ata_id_current_chs_valid(id)) {
1375                                 /* Current CHS translation is valid. */
1376                                 dev->cylinders = id[54];
1377                                 dev->heads     = id[55];
1378                                 dev->sectors   = id[56];
1379                         }
1380
1381                         /* print device info to dmesg */
1382                         if (print_info)
1383                                 ata_dev_printk(dev, KERN_INFO, "ATA-%d, "
1384                                         "max %s, %Lu sectors: CHS %u/%u/%u\n",
1385                                         ata_id_major_version(id),
1386                                         ata_mode_string(xfer_mask),
1387                                         (unsigned long long)dev->n_sectors,
1388                                         dev->cylinders, dev->heads, dev->sectors);
1389                 }
1390
1391                 if (dev->id[59] & 0x100) {
1392                         dev->multi_count = dev->id[59] & 0xff;
1393                         DPRINTK("ata%u: dev %u multi count %u\n",
1394                                 ap->id, dev->devno, dev->multi_count);
1395                 }
1396
1397                 dev->cdb_len = 16;
1398         }
1399
1400         /* ATAPI-specific feature tests */
1401         else if (dev->class == ATA_DEV_ATAPI) {
1402                 char *cdb_intr_string = "";
1403
1404                 rc = atapi_cdb_len(id);
1405                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1406                         ata_dev_printk(dev, KERN_WARNING,
1407                                        "unsupported CDB len\n");
1408                         rc = -EINVAL;
1409                         goto err_out_nosup;
1410                 }
1411                 dev->cdb_len = (unsigned int) rc;
1412
1413                 if (ata_id_cdb_intr(dev->id)) {
1414                         dev->flags |= ATA_DFLAG_CDB_INTR;
1415                         cdb_intr_string = ", CDB intr";
1416                 }
1417
1418                 /* print device info to dmesg */
1419                 if (print_info)
1420                         ata_dev_printk(dev, KERN_INFO, "ATAPI, max %s%s\n",
1421                                        ata_mode_string(xfer_mask),
1422                                        cdb_intr_string);
1423         }
1424
1425         ap->host->max_cmd_len = 0;
1426         for (i = 0; i < ATA_MAX_DEVICES; i++)
1427                 ap->host->max_cmd_len = max_t(unsigned int,
1428                                               ap->host->max_cmd_len,
1429                                               ap->device[i].cdb_len);
1430
1431         /* limit bridge transfers to udma5, 200 sectors */
1432         if (ata_dev_knobble(dev)) {
1433                 if (print_info)
1434                         ata_dev_printk(dev, KERN_INFO,
1435                                        "applying bridge limits\n");
1436                 dev->udma_mask &= ATA_UDMA5;
1437                 dev->max_sectors = ATA_MAX_SECTORS;
1438         }
1439
1440         if (ap->ops->dev_config)
1441                 ap->ops->dev_config(ap, dev);
1442
1443         DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
1444         return 0;
1445
1446 err_out_nosup:
1447         DPRINTK("EXIT, err\n");
1448         return rc;
1449 }
1450
1451 /**
1452  *      ata_bus_probe - Reset and probe ATA bus
1453  *      @ap: Bus to probe
1454  *
1455  *      Master ATA bus probing function.  Initiates a hardware-dependent
1456  *      bus reset, then attempts to identify any devices found on
1457  *      the bus.
1458  *
1459  *      LOCKING:
1460  *      PCI/etc. bus probe sem.
1461  *
1462  *      RETURNS:
1463  *      Zero on success, negative errno otherwise.
1464  */
1465
1466 static int ata_bus_probe(struct ata_port *ap)
1467 {
1468         unsigned int classes[ATA_MAX_DEVICES];
1469         int tries[ATA_MAX_DEVICES];
1470         int i, rc, down_xfermask;
1471         struct ata_device *dev;
1472
1473         ata_port_probe(ap);
1474
1475         for (i = 0; i < ATA_MAX_DEVICES; i++)
1476                 tries[i] = ATA_PROBE_MAX_TRIES;
1477
1478  retry:
1479         down_xfermask = 0;
1480
1481         /* reset and determine device classes */
1482         ap->ops->phy_reset(ap);
1483
1484         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1485                 dev = &ap->device[i];
1486
1487                 if (!(ap->flags & ATA_FLAG_DISABLED) &&
1488                     dev->class != ATA_DEV_UNKNOWN)
1489                         classes[dev->devno] = dev->class;
1490                 else
1491                         classes[dev->devno] = ATA_DEV_NONE;
1492
1493                 dev->class = ATA_DEV_UNKNOWN;
1494         }
1495
1496         ata_port_probe(ap);
1497
1498         /* after the reset the device state is PIO 0 and the controller
1499            state is undefined. Record the mode */
1500
1501         for (i = 0; i < ATA_MAX_DEVICES; i++)
1502                 ap->device[i].pio_mode = XFER_PIO_0;
1503
1504         /* read IDENTIFY page and configure devices */
1505         for (i = 0; i < ATA_MAX_DEVICES; i++) {
1506                 dev = &ap->device[i];
1507
1508                 if (tries[i])
1509                         dev->class = classes[i];
1510
1511                 if (!ata_dev_enabled(dev))
1512                         continue;
1513
1514                 rc = ata_dev_read_id(dev, &dev->class, 1, dev->id);
1515                 if (rc)
1516                         goto fail;
1517
1518                 rc = ata_dev_configure(dev, 1);
1519                 if (rc)
1520                         goto fail;
1521         }
1522
1523         /* configure transfer mode */
1524         rc = ata_set_mode(ap, &dev);
1525         if (rc) {
1526                 down_xfermask = 1;
1527                 goto fail;
1528         }
1529
1530         for (i = 0; i < ATA_MAX_DEVICES; i++)
1531                 if (ata_dev_enabled(&ap->device[i]))
1532                         return 0;
1533
1534         /* no device present, disable port */
1535         ata_port_disable(ap);
1536         ap->ops->port_disable(ap);
1537         return -ENODEV;
1538
1539  fail:
1540         switch (rc) {
1541         case -EINVAL:
1542         case -ENODEV:
1543                 tries[dev->devno] = 0;
1544                 break;
1545         case -EIO:
1546                 sata_down_spd_limit(ap);
1547                 /* fall through */
1548         default:
1549                 tries[dev->devno]--;
1550                 if (down_xfermask &&
1551                     ata_down_xfermask_limit(dev, tries[dev->devno] == 1))
1552                         tries[dev->devno] = 0;
1553         }
1554
1555         if (!tries[dev->devno]) {
1556                 ata_down_xfermask_limit(dev, 1);
1557                 ata_dev_disable(dev);
1558         }
1559
1560         goto retry;
1561 }
1562
1563 /**
1564  *      ata_port_probe - Mark port as enabled
1565  *      @ap: Port for which we indicate enablement
1566  *
1567  *      Modify @ap data structure such that the system
1568  *      thinks that the entire port is enabled.
1569  *
1570  *      LOCKING: host_set lock, or some other form of
1571  *      serialization.
1572  */
1573
1574 void ata_port_probe(struct ata_port *ap)
1575 {
1576         ap->flags &= ~ATA_FLAG_DISABLED;
1577 }
1578
1579 /**
1580  *      sata_print_link_status - Print SATA link status
1581  *      @ap: SATA port to printk link status about
1582  *
1583  *      This function prints link speed and status of a SATA link.
1584  *
1585  *      LOCKING:
1586  *      None.
1587  */
1588 static void sata_print_link_status(struct ata_port *ap)
1589 {
1590         u32 sstatus, scontrol, tmp;
1591
1592         if (sata_scr_read(ap, SCR_STATUS, &sstatus))
1593                 return;
1594         sata_scr_read(ap, SCR_CONTROL, &scontrol);
1595
1596         if (ata_port_online(ap)) {
1597                 tmp = (sstatus >> 4) & 0xf;
1598                 ata_port_printk(ap, KERN_INFO,
1599                                 "SATA link up %s (SStatus %X SControl %X)\n",
1600                                 sata_spd_string(tmp), sstatus, scontrol);
1601         } else {
1602                 ata_port_printk(ap, KERN_INFO,
1603                                 "SATA link down (SStatus %X SControl %X)\n",
1604                                 sstatus, scontrol);
1605         }
1606 }
1607
1608 /**
1609  *      __sata_phy_reset - Wake/reset a low-level SATA PHY
1610  *      @ap: SATA port associated with target SATA PHY.
1611  *
1612  *      This function issues commands to standard SATA Sxxx
1613  *      PHY registers, to wake up the phy (and device), and
1614  *      clear any reset condition.
1615  *
1616  *      LOCKING:
1617  *      PCI/etc. bus probe sem.
1618  *
1619  */
1620 void __sata_phy_reset(struct ata_port *ap)
1621 {
1622         u32 sstatus;
1623         unsigned long timeout = jiffies + (HZ * 5);
1624
1625         if (ap->flags & ATA_FLAG_SATA_RESET) {
1626                 /* issue phy wake/reset */
1627                 sata_scr_write_flush(ap, SCR_CONTROL, 0x301);
1628                 /* Couldn't find anything in SATA I/II specs, but
1629                  * AHCI-1.1 10.4.2 says at least 1 ms. */
1630                 mdelay(1);
1631         }
1632         /* phy wake/clear reset */
1633         sata_scr_write_flush(ap, SCR_CONTROL, 0x300);
1634
1635         /* wait for phy to become ready, if necessary */
1636         do {
1637                 msleep(200);
1638                 sata_scr_read(ap, SCR_STATUS, &sstatus);
1639                 if ((sstatus & 0xf) != 1)
1640                         break;
1641         } while (time_before(jiffies, timeout));
1642
1643         /* print link status */
1644         sata_print_link_status(ap);
1645
1646         /* TODO: phy layer with polling, timeouts, etc. */
1647         if (!ata_port_offline(ap))
1648                 ata_port_probe(ap);
1649         else
1650                 ata_port_disable(ap);
1651
1652         if (ap->flags & ATA_FLAG_DISABLED)
1653                 return;
1654
1655         if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1656                 ata_port_disable(ap);
1657                 return;
1658         }
1659
1660         ap->cbl = ATA_CBL_SATA;
1661 }
1662
1663 /**
1664  *      sata_phy_reset - Reset SATA bus.
1665  *      @ap: SATA port associated with target SATA PHY.
1666  *
1667  *      This function resets the SATA bus, and then probes
1668  *      the bus for devices.
1669  *
1670  *      LOCKING:
1671  *      PCI/etc. bus probe sem.
1672  *
1673  */
1674 void sata_phy_reset(struct ata_port *ap)
1675 {
1676         __sata_phy_reset(ap);
1677         if (ap->flags & ATA_FLAG_DISABLED)
1678                 return;
1679         ata_bus_reset(ap);
1680 }
1681
1682 /**
1683  *      ata_dev_pair            -       return other device on cable
1684  *      @adev: device
1685  *
1686  *      Obtain the other device on the same cable, or if none is
1687  *      present NULL is returned
1688  */
1689
1690 struct ata_device *ata_dev_pair(struct ata_device *adev)
1691 {
1692         struct ata_port *ap = adev->ap;
1693         struct ata_device *pair = &ap->device[1 - adev->devno];
1694         if (!ata_dev_enabled(pair))
1695                 return NULL;
1696         return pair;
1697 }
1698
1699 /**
1700  *      ata_port_disable - Disable port.
1701  *      @ap: Port to be disabled.
1702  *
1703  *      Modify @ap data structure such that the system
1704  *      thinks that the entire port is disabled, and should
1705  *      never attempt to probe or communicate with devices
1706  *      on this port.
1707  *
1708  *      LOCKING: host_set lock, or some other form of
1709  *      serialization.
1710  */
1711
1712 void ata_port_disable(struct ata_port *ap)
1713 {
1714         ap->device[0].class = ATA_DEV_NONE;
1715         ap->device[1].class = ATA_DEV_NONE;
1716         ap->flags |= ATA_FLAG_DISABLED;
1717 }
1718
1719 /**
1720  *      sata_down_spd_limit - adjust SATA spd limit downward
1721  *      @ap: Port to adjust SATA spd limit for
1722  *
1723  *      Adjust SATA spd limit of @ap downward.  Note that this
1724  *      function only adjusts the limit.  The change must be applied
1725  *      using sata_set_spd().
1726  *
1727  *      LOCKING:
1728  *      Inherited from caller.
1729  *
1730  *      RETURNS:
1731  *      0 on success, negative errno on failure
1732  */
1733 int sata_down_spd_limit(struct ata_port *ap)
1734 {
1735         u32 sstatus, spd, mask;
1736         int rc, highbit;
1737
1738         rc = sata_scr_read(ap, SCR_STATUS, &sstatus);
1739         if (rc)
1740                 return rc;
1741
1742         mask = ap->sata_spd_limit;
1743         if (mask <= 1)
1744                 return -EINVAL;
1745         highbit = fls(mask) - 1;
1746         mask &= ~(1 << highbit);
1747
1748         spd = (sstatus >> 4) & 0xf;
1749         if (spd <= 1)
1750                 return -EINVAL;
1751         spd--;
1752         mask &= (1 << spd) - 1;
1753         if (!mask)
1754                 return -EINVAL;
1755
1756         ap->sata_spd_limit = mask;
1757
1758         ata_port_printk(ap, KERN_WARNING, "limiting SATA link speed to %s\n",
1759                         sata_spd_string(fls(mask)));
1760
1761         return 0;
1762 }
1763
1764 static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
1765 {
1766         u32 spd, limit;
1767
1768         if (ap->sata_spd_limit == UINT_MAX)
1769                 limit = 0;
1770         else
1771                 limit = fls(ap->sata_spd_limit);
1772
1773         spd = (*scontrol >> 4) & 0xf;
1774         *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
1775
1776         return spd != limit;
1777 }
1778
1779 /**
1780  *      sata_set_spd_needed - is SATA spd configuration needed
1781  *      @ap: Port in question
1782  *
1783  *      Test whether the spd limit in SControl matches
1784  *      @ap->sata_spd_limit.  This function is used to determine
1785  *      whether hardreset is necessary to apply SATA spd
1786  *      configuration.
1787  *
1788  *      LOCKING:
1789  *      Inherited from caller.
1790  *
1791  *      RETURNS:
1792  *      1 if SATA spd configuration is needed, 0 otherwise.
1793  */
1794 int sata_set_spd_needed(struct ata_port *ap)
1795 {
1796         u32 scontrol;
1797
1798         if (sata_scr_read(ap, SCR_CONTROL, &scontrol))
1799                 return 0;
1800
1801         return __sata_set_spd_needed(ap, &scontrol);
1802 }
1803
1804 /**
1805  *      sata_set_spd - set SATA spd according to spd limit
1806  *      @ap: Port to set SATA spd for
1807  *
1808  *      Set SATA spd of @ap according to sata_spd_limit.
1809  *
1810  *      LOCKING:
1811  *      Inherited from caller.
1812  *
1813  *      RETURNS:
1814  *      0 if spd doesn't need to be changed, 1 if spd has been
1815  *      changed.  Negative errno if SCR registers are inaccessible.
1816  */
1817 int sata_set_spd(struct ata_port *ap)
1818 {
1819         u32 scontrol;
1820         int rc;
1821
1822         if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
1823                 return rc;
1824
1825         if (!__sata_set_spd_needed(ap, &scontrol))
1826                 return 0;
1827
1828         if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
1829                 return rc;
1830
1831         return 1;
1832 }
1833
1834 /*
1835  * This mode timing computation functionality is ported over from
1836  * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1837  */
1838 /*
1839  * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1840  * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1841  * for PIO 5, which is a nonstandard extension and UDMA6, which
1842  * is currently supported only by Maxtor drives.
1843  */
1844
1845 static const struct ata_timing ata_timing[] = {
1846
1847         { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
1848         { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
1849         { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
1850         { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
1851
1852         { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
1853         { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
1854         { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
1855
1856 /*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
1857
1858         { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
1859         { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
1860         { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
1861
1862         { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
1863         { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
1864         { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
1865
1866 /*      { XFER_PIO_5,     20,  50,  30, 100,  50,  30, 100,   0 }, */
1867         { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
1868         { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
1869
1870         { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
1871         { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
1872         { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
1873
1874 /*      { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
1875
1876         { 0xFF }
1877 };
1878
1879 #define ENOUGH(v,unit)          (((v)-1)/(unit)+1)
1880 #define EZ(v,unit)              ((v)?ENOUGH(v,unit):0)
1881
1882 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1883 {
1884         q->setup   = EZ(t->setup   * 1000,  T);
1885         q->act8b   = EZ(t->act8b   * 1000,  T);
1886         q->rec8b   = EZ(t->rec8b   * 1000,  T);
1887         q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
1888         q->active  = EZ(t->active  * 1000,  T);
1889         q->recover = EZ(t->recover * 1000,  T);
1890         q->cycle   = EZ(t->cycle   * 1000,  T);
1891         q->udma    = EZ(t->udma    * 1000, UT);
1892 }
1893
1894 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1895                       struct ata_timing *m, unsigned int what)
1896 {
1897         if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
1898         if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
1899         if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
1900         if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
1901         if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
1902         if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1903         if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
1904         if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
1905 }
1906
1907 static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1908 {
1909         const struct ata_timing *t;
1910
1911         for (t = ata_timing; t->mode != speed; t++)
1912                 if (t->mode == 0xFF)
1913                         return NULL;
1914         return t;
1915 }
1916
1917 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1918                        struct ata_timing *t, int T, int UT)
1919 {
1920         const struct ata_timing *s;
1921         struct ata_timing p;
1922
1923         /*
1924          * Find the mode.
1925          */
1926
1927         if (!(s = ata_timing_find_mode(speed)))
1928                 return -EINVAL;
1929
1930         memcpy(t, s, sizeof(*s));
1931
1932         /*
1933          * If the drive is an EIDE drive, it can tell us it needs extended
1934          * PIO/MW_DMA cycle timing.
1935          */
1936
1937         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1938                 memset(&p, 0, sizeof(p));
1939                 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1940                         if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1941                                             else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1942                 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1943                         p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1944                 }
1945                 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1946         }
1947
1948         /*
1949          * Convert the timing to bus clock counts.
1950          */
1951
1952         ata_timing_quantize(t, t, T, UT);
1953
1954         /*
1955          * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
1956          * S.M.A.R.T * and some other commands. We have to ensure that the
1957          * DMA cycle timing is slower/equal than the fastest PIO timing.
1958          */
1959
1960         if (speed > XFER_PIO_4) {
1961                 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1962                 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1963         }
1964
1965         /*
1966          * Lengthen active & recovery time so that cycle time is correct.
1967          */
1968
1969         if (t->act8b + t->rec8b < t->cyc8b) {
1970                 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1971                 t->rec8b = t->cyc8b - t->act8b;
1972         }
1973
1974         if (t->active + t->recover < t->cycle) {
1975                 t->active += (t->cycle - (t->active + t->recover)) / 2;
1976                 t->recover = t->cycle - t->active;
1977         }
1978
1979         return 0;
1980 }
1981
1982 /**
1983  *      ata_down_xfermask_limit - adjust dev xfer masks downward
1984  *      @dev: Device to adjust xfer masks
1985  *      @force_pio0: Force PIO0
1986  *
1987  *      Adjust xfer masks of @dev downward.  Note that this function
1988  *      does not apply the change.  Invoking ata_set_mode() afterwards
1989  *      will apply the limit.
1990  *
1991  *      LOCKING:
1992  *      Inherited from caller.
1993  *
1994  *      RETURNS:
1995  *      0 on success, negative errno on failure
1996  */
1997 int ata_down_xfermask_limit(struct ata_device *dev, int force_pio0)
1998 {
1999         unsigned long xfer_mask;
2000         int highbit;
2001
2002         xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask,
2003                                       dev->udma_mask);
2004
2005         if (!xfer_mask)
2006                 goto fail;
2007         /* don't gear down to MWDMA from UDMA, go directly to PIO */
2008         if (xfer_mask & ATA_MASK_UDMA)
2009                 xfer_mask &= ~ATA_MASK_MWDMA;
2010
2011         highbit = fls(xfer_mask) - 1;
2012         xfer_mask &= ~(1 << highbit);
2013         if (force_pio0)
2014                 xfer_mask &= 1 << ATA_SHIFT_PIO;
2015         if (!xfer_mask)
2016                 goto fail;
2017
2018         ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
2019                             &dev->udma_mask);
2020
2021         ata_dev_printk(dev, KERN_WARNING, "limiting speed to %s\n",
2022                        ata_mode_string(xfer_mask));
2023
2024         return 0;
2025
2026  fail:
2027         return -EINVAL;
2028 }
2029
2030 static int ata_dev_set_mode(struct ata_device *dev)
2031 {
2032         unsigned int err_mask;
2033         int rc;
2034
2035         dev->flags &= ~ATA_DFLAG_PIO;
2036         if (dev->xfer_shift == ATA_SHIFT_PIO)
2037                 dev->flags |= ATA_DFLAG_PIO;
2038
2039         err_mask = ata_dev_set_xfermode(dev);
2040         if (err_mask) {
2041                 ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
2042                                "(err_mask=0x%x)\n", err_mask);
2043                 return -EIO;
2044         }
2045
2046         rc = ata_dev_revalidate(dev, 0);
2047         if (rc)
2048                 return rc;
2049
2050         DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
2051                 dev->xfer_shift, (int)dev->xfer_mode);
2052
2053         ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
2054                        ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
2055         return 0;
2056 }
2057
2058 /**
2059  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
2060  *      @ap: port on which timings will be programmed
2061  *      @r_failed_dev: out paramter for failed device
2062  *
2063  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
2064  *      ata_set_mode() fails, pointer to the failing device is
2065  *      returned in @r_failed_dev.
2066  *
2067  *      LOCKING:
2068  *      PCI/etc. bus probe sem.
2069  *
2070  *      RETURNS:
2071  *      0 on success, negative errno otherwise
2072  */
2073 int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
2074 {
2075         struct ata_device *dev;
2076         int i, rc = 0, used_dma = 0, found = 0;
2077
2078         /* has private set_mode? */
2079         if (ap->ops->set_mode) {
2080                 /* FIXME: make ->set_mode handle no device case and
2081                  * return error code and failing device on failure.
2082                  */
2083                 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2084                         if (ata_dev_enabled(&ap->device[i])) {
2085                                 ap->ops->set_mode(ap);
2086                                 break;
2087                         }
2088                 }
2089                 return 0;
2090         }
2091
2092         /* step 1: calculate xfer_mask */
2093         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2094                 unsigned int pio_mask, dma_mask;
2095
2096                 dev = &ap->device[i];
2097
2098                 if (!ata_dev_enabled(dev))
2099                         continue;
2100
2101                 ata_dev_xfermask(dev);
2102
2103                 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
2104                 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
2105                 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
2106                 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
2107
2108                 found = 1;
2109                 if (dev->dma_mode)
2110                         used_dma = 1;
2111         }
2112         if (!found)
2113                 goto out;
2114
2115         /* step 2: always set host PIO timings */
2116         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2117                 dev = &ap->device[i];
2118                 if (!ata_dev_enabled(dev))
2119                         continue;
2120
2121                 if (!dev->pio_mode) {
2122                         ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");
2123                         rc = -EINVAL;
2124                         goto out;
2125                 }
2126
2127                 dev->xfer_mode = dev->pio_mode;
2128                 dev->xfer_shift = ATA_SHIFT_PIO;
2129                 if (ap->ops->set_piomode)
2130                         ap->ops->set_piomode(ap, dev);
2131         }
2132
2133         /* step 3: set host DMA timings */
2134         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2135                 dev = &ap->device[i];
2136
2137                 if (!ata_dev_enabled(dev) || !dev->dma_mode)
2138                         continue;
2139
2140                 dev->xfer_mode = dev->dma_mode;
2141                 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
2142                 if (ap->ops->set_dmamode)
2143                         ap->ops->set_dmamode(ap, dev);
2144         }
2145
2146         /* step 4: update devices' xfer mode */
2147         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2148                 dev = &ap->device[i];
2149
2150                 if (!ata_dev_enabled(dev))
2151                         continue;
2152
2153                 rc = ata_dev_set_mode(dev);
2154                 if (rc)
2155                         goto out;
2156         }
2157
2158         /* Record simplex status. If we selected DMA then the other
2159          * host channels are not permitted to do so.
2160          */
2161         if (used_dma && (ap->host_set->flags & ATA_HOST_SIMPLEX))
2162                 ap->host_set->simplex_claimed = 1;
2163
2164         /* step5: chip specific finalisation */
2165         if (ap->ops->post_set_mode)
2166                 ap->ops->post_set_mode(ap);
2167
2168  out:
2169         if (rc)
2170                 *r_failed_dev = dev;
2171         return rc;
2172 }
2173
2174 /**
2175  *      ata_tf_to_host - issue ATA taskfile to host controller
2176  *      @ap: port to which command is being issued
2177  *      @tf: ATA taskfile register set
2178  *
2179  *      Issues ATA taskfile register set to ATA host controller,
2180  *      with proper synchronization with interrupt handler and
2181  *      other threads.
2182  *
2183  *      LOCKING:
2184  *      spin_lock_irqsave(host_set lock)
2185  */
2186
2187 static inline void ata_tf_to_host(struct ata_port *ap,
2188                                   const struct ata_taskfile *tf)
2189 {
2190         ap->ops->tf_load(ap, tf);
2191         ap->ops->exec_command(ap, tf);
2192 }
2193
2194 /**
2195  *      ata_busy_sleep - sleep until BSY clears, or timeout
2196  *      @ap: port containing status register to be polled
2197  *      @tmout_pat: impatience timeout
2198  *      @tmout: overall timeout
2199  *
2200  *      Sleep until ATA Status register bit BSY clears,
2201  *      or a timeout occurs.
2202  *
2203  *      LOCKING: None.
2204  */
2205
2206 unsigned int ata_busy_sleep (struct ata_port *ap,
2207                              unsigned long tmout_pat, unsigned long tmout)
2208 {
2209         unsigned long timer_start, timeout;
2210         u8 status;
2211
2212         status = ata_busy_wait(ap, ATA_BUSY, 300);
2213         timer_start = jiffies;
2214         timeout = timer_start + tmout_pat;
2215         while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2216                 msleep(50);
2217                 status = ata_busy_wait(ap, ATA_BUSY, 3);
2218         }
2219
2220         if (status & ATA_BUSY)
2221                 ata_port_printk(ap, KERN_WARNING,
2222                                 "port is slow to respond, please be patient\n");
2223
2224         timeout = timer_start + tmout;
2225         while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2226                 msleep(50);
2227                 status = ata_chk_status(ap);
2228         }
2229
2230         if (status & ATA_BUSY) {
2231                 ata_port_printk(ap, KERN_ERR, "port failed to respond "
2232                                 "(%lu secs)\n", tmout / HZ);
2233                 return 1;
2234         }
2235
2236         return 0;
2237 }
2238
2239 static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
2240 {
2241         struct ata_ioports *ioaddr = &ap->ioaddr;
2242         unsigned int dev0 = devmask & (1 << 0);
2243         unsigned int dev1 = devmask & (1 << 1);
2244         unsigned long timeout;
2245
2246         /* if device 0 was found in ata_devchk, wait for its
2247          * BSY bit to clear
2248          */
2249         if (dev0)
2250                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2251
2252         /* if device 1 was found in ata_devchk, wait for
2253          * register access, then wait for BSY to clear
2254          */
2255         timeout = jiffies + ATA_TMOUT_BOOT;
2256         while (dev1) {
2257                 u8 nsect, lbal;
2258
2259                 ap->ops->dev_select(ap, 1);
2260                 if (ap->flags & ATA_FLAG_MMIO) {
2261                         nsect = readb((void __iomem *) ioaddr->nsect_addr);
2262                         lbal = readb((void __iomem *) ioaddr->lbal_addr);
2263                 } else {
2264                         nsect = inb(ioaddr->nsect_addr);
2265                         lbal = inb(ioaddr->lbal_addr);
2266                 }
2267                 if ((nsect == 1) && (lbal == 1))
2268                         break;
2269                 if (time_after(jiffies, timeout)) {
2270                         dev1 = 0;
2271                         break;
2272                 }
2273                 msleep(50);     /* give drive a breather */
2274         }
2275         if (dev1)
2276                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2277
2278         /* is all this really necessary? */
2279         ap->ops->dev_select(ap, 0);
2280         if (dev1)
2281                 ap->ops->dev_select(ap, 1);
2282         if (dev0)
2283                 ap->ops->dev_select(ap, 0);
2284 }
2285
2286 static unsigned int ata_bus_softreset(struct ata_port *ap,
2287                                       unsigned int devmask)
2288 {
2289         struct ata_ioports *ioaddr = &ap->ioaddr;
2290
2291         DPRINTK("ata%u: bus reset via SRST\n", ap->id);
2292
2293         /* software reset.  causes dev0 to be selected */
2294         if (ap->flags & ATA_FLAG_MMIO) {
2295                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2296                 udelay(20);     /* FIXME: flush */
2297                 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
2298                 udelay(20);     /* FIXME: flush */
2299                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2300         } else {
2301                 outb(ap->ctl, ioaddr->ctl_addr);
2302                 udelay(10);
2303                 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2304                 udelay(10);
2305                 outb(ap->ctl, ioaddr->ctl_addr);
2306         }
2307
2308         /* spec mandates ">= 2ms" before checking status.
2309          * We wait 150ms, because that was the magic delay used for
2310          * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2311          * between when the ATA command register is written, and then
2312          * status is checked.  Because waiting for "a while" before
2313          * checking status is fine, post SRST, we perform this magic
2314          * delay here as well.
2315          *
2316          * Old drivers/ide uses the 2mS rule and then waits for ready
2317          */
2318         msleep(150);
2319
2320         /* Before we perform post reset processing we want to see if
2321          * the bus shows 0xFF because the odd clown forgets the D7
2322          * pulldown resistor.
2323          */
2324         if (ata_check_status(ap) == 0xFF) {
2325                 ata_port_printk(ap, KERN_ERR, "SRST failed (status 0xFF)\n");
2326                 return AC_ERR_OTHER;
2327         }
2328
2329         ata_bus_post_reset(ap, devmask);
2330
2331         return 0;
2332 }
2333
2334 /**
2335  *      ata_bus_reset - reset host port and associated ATA channel
2336  *      @ap: port to reset
2337  *
2338  *      This is typically the first time we actually start issuing
2339  *      commands to the ATA channel.  We wait for BSY to clear, then
2340  *      issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2341  *      result.  Determine what devices, if any, are on the channel
2342  *      by looking at the device 0/1 error register.  Look at the signature
2343  *      stored in each device's taskfile registers, to determine if
2344  *      the device is ATA or ATAPI.
2345  *
2346  *      LOCKING:
2347  *      PCI/etc. bus probe sem.
2348  *      Obtains host_set lock.
2349  *
2350  *      SIDE EFFECTS:
2351  *      Sets ATA_FLAG_DISABLED if bus reset fails.
2352  */
2353
2354 void ata_bus_reset(struct ata_port *ap)
2355 {
2356         struct ata_ioports *ioaddr = &ap->ioaddr;
2357         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2358         u8 err;
2359         unsigned int dev0, dev1 = 0, devmask = 0;
2360
2361         DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
2362
2363         /* determine if device 0/1 are present */
2364         if (ap->flags & ATA_FLAG_SATA_RESET)
2365                 dev0 = 1;
2366         else {
2367                 dev0 = ata_devchk(ap, 0);
2368                 if (slave_possible)
2369                         dev1 = ata_devchk(ap, 1);
2370         }
2371
2372         if (dev0)
2373                 devmask |= (1 << 0);
2374         if (dev1)
2375                 devmask |= (1 << 1);
2376
2377         /* select device 0 again */
2378         ap->ops->dev_select(ap, 0);
2379
2380         /* issue bus reset */
2381         if (ap->flags & ATA_FLAG_SRST)
2382                 if (ata_bus_softreset(ap, devmask))
2383                         goto err_out;
2384
2385         /*
2386          * determine by signature whether we have ATA or ATAPI devices
2387          */
2388         ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
2389         if ((slave_possible) && (err != 0x81))
2390                 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
2391
2392         /* re-enable interrupts */
2393         if (ap->ioaddr.ctl_addr)        /* FIXME: hack. create a hook instead */
2394                 ata_irq_on(ap);
2395
2396         /* is double-select really necessary? */
2397         if (ap->device[1].class != ATA_DEV_NONE)
2398                 ap->ops->dev_select(ap, 1);
2399         if (ap->device[0].class != ATA_DEV_NONE)
2400                 ap->ops->dev_select(ap, 0);
2401
2402         /* if no devices were detected, disable this port */
2403         if ((ap->device[0].class == ATA_DEV_NONE) &&
2404             (ap->device[1].class == ATA_DEV_NONE))
2405                 goto err_out;
2406
2407         if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2408                 /* set up device control for ATA_FLAG_SATA_RESET */
2409                 if (ap->flags & ATA_FLAG_MMIO)
2410                         writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2411                 else
2412                         outb(ap->ctl, ioaddr->ctl_addr);
2413         }
2414
2415         DPRINTK("EXIT\n");
2416         return;
2417
2418 err_out:
2419         ata_port_printk(ap, KERN_ERR, "disabling port\n");
2420         ap->ops->port_disable(ap);
2421
2422         DPRINTK("EXIT\n");
2423 }
2424
2425 /**
2426  *      sata_phy_debounce - debounce SATA phy status
2427  *      @ap: ATA port to debounce SATA phy status for
2428  *      @params: timing parameters { interval, duratinon, timeout } in msec
2429  *
2430  *      Make sure SStatus of @ap reaches stable state, determined by
2431  *      holding the same value where DET is not 1 for @duration polled
2432  *      every @interval, before @timeout.  Timeout constraints the
2433  *      beginning of the stable state.  Because, after hot unplugging,
2434  *      DET gets stuck at 1 on some controllers, this functions waits
2435  *      until timeout then returns 0 if DET is stable at 1.
2436  *
2437  *      LOCKING:
2438  *      Kernel thread context (may sleep)
2439  *
2440  *      RETURNS:
2441  *      0 on success, -errno on failure.
2442  */
2443 int sata_phy_debounce(struct ata_port *ap, const unsigned long *params)
2444 {
2445         unsigned long interval_msec = params[0];
2446         unsigned long duration = params[1] * HZ / 1000;
2447         unsigned long timeout = jiffies + params[2] * HZ / 1000;
2448         unsigned long last_jiffies;
2449         u32 last, cur;
2450         int rc;
2451
2452         if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
2453                 return rc;
2454         cur &= 0xf;
2455
2456         last = cur;
2457         last_jiffies = jiffies;
2458
2459         while (1) {
2460                 msleep(interval_msec);
2461                 if ((rc = sata_scr_read(ap, SCR_STATUS, &cur)))
2462                         return rc;
2463                 cur &= 0xf;
2464
2465                 /* DET stable? */
2466                 if (cur == last) {
2467                         if (cur == 1 && time_before(jiffies, timeout))
2468                                 continue;
2469                         if (time_after(jiffies, last_jiffies + duration))
2470                                 return 0;
2471                         continue;
2472                 }
2473
2474                 /* unstable, start over */
2475                 last = cur;
2476                 last_jiffies = jiffies;
2477
2478                 /* check timeout */
2479                 if (time_after(jiffies, timeout))
2480                         return -EBUSY;
2481         }
2482 }
2483
2484 /**
2485  *      sata_phy_resume - resume SATA phy
2486  *      @ap: ATA port to resume SATA phy for
2487  *      @params: timing parameters { interval, duratinon, timeout } in msec
2488  *
2489  *      Resume SATA phy of @ap and debounce it.
2490  *
2491  *      LOCKING:
2492  *      Kernel thread context (may sleep)
2493  *
2494  *      RETURNS:
2495  *      0 on success, -errno on failure.
2496  */
2497 int sata_phy_resume(struct ata_port *ap, const unsigned long *params)
2498 {
2499         u32 scontrol;
2500         int rc;
2501
2502         if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2503                 return rc;
2504
2505         scontrol = (scontrol & 0x0f0) | 0x300;
2506
2507         if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
2508                 return rc;
2509
2510         /* Some PHYs react badly if SStatus is pounded immediately
2511          * after resuming.  Delay 200ms before debouncing.
2512          */
2513         msleep(200);
2514
2515         return sata_phy_debounce(ap, params);
2516 }
2517
2518 static void ata_wait_spinup(struct ata_port *ap)
2519 {
2520         struct ata_eh_context *ehc = &ap->eh_context;
2521         unsigned long end, secs;
2522         int rc;
2523
2524         /* first, debounce phy if SATA */
2525         if (ap->cbl == ATA_CBL_SATA) {
2526                 rc = sata_phy_debounce(ap, sata_deb_timing_eh);
2527
2528                 /* if debounced successfully and offline, no need to wait */
2529                 if ((rc == 0 || rc == -EOPNOTSUPP) && ata_port_offline(ap))
2530                         return;
2531         }
2532
2533         /* okay, let's give the drive time to spin up */
2534         end = ehc->i.hotplug_timestamp + ATA_SPINUP_WAIT * HZ / 1000;
2535         secs = ((end - jiffies) + HZ - 1) / HZ;
2536
2537         if (time_after(jiffies, end))
2538                 return;
2539
2540         if (secs > 5)
2541                 ata_port_printk(ap, KERN_INFO, "waiting for device to spin up "
2542                                 "(%lu secs)\n", secs);
2543
2544         schedule_timeout_uninterruptible(end - jiffies);
2545 }
2546
2547 /**
2548  *      ata_std_prereset - prepare for reset
2549  *      @ap: ATA port to be reset
2550  *
2551  *      @ap is about to be reset.  Initialize it.
2552  *
2553  *      LOCKING:
2554  *      Kernel thread context (may sleep)
2555  *
2556  *      RETURNS:
2557  *      0 on success, -errno otherwise.
2558  */
2559 int ata_std_prereset(struct ata_port *ap)
2560 {
2561         struct ata_eh_context *ehc = &ap->eh_context;
2562         const unsigned long *timing;
2563         int rc;
2564
2565         /* hotplug? */
2566         if (ehc->i.flags & ATA_EHI_HOTPLUGGED) {
2567                 if (ap->flags & ATA_FLAG_HRST_TO_RESUME)
2568                         ehc->i.action |= ATA_EH_HARDRESET;
2569                 if (ap->flags & ATA_FLAG_SKIP_D2H_BSY)
2570                         ata_wait_spinup(ap);
2571         }
2572
2573         /* if we're about to do hardreset, nothing more to do */
2574         if (ehc->i.action & ATA_EH_HARDRESET)
2575                 return 0;
2576
2577         /* if SATA, resume phy */
2578         if (ap->cbl == ATA_CBL_SATA) {
2579                 if (ap->flags & ATA_FLAG_LOADING)
2580                         timing = sata_deb_timing_boot;
2581                 else
2582                         timing = sata_deb_timing_eh;
2583
2584                 rc = sata_phy_resume(ap, timing);
2585                 if (rc && rc != -EOPNOTSUPP) {
2586                         /* phy resume failed */
2587                         ata_port_printk(ap, KERN_WARNING, "failed to resume "
2588                                         "link for reset (errno=%d)\n", rc);
2589                         return rc;
2590                 }
2591         }
2592
2593         /* Wait for !BSY if the controller can wait for the first D2H
2594          * Reg FIS and we don't know that no device is attached.
2595          */
2596         if (!(ap->flags & ATA_FLAG_SKIP_D2H_BSY) && !ata_port_offline(ap))
2597                 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2598
2599         return 0;
2600 }
2601
2602 /**
2603  *      ata_std_softreset - reset host port via ATA SRST
2604  *      @ap: port to reset
2605  *      @classes: resulting classes of attached devices
2606  *
2607  *      Reset host port using ATA SRST.
2608  *
2609  *      LOCKING:
2610  *      Kernel thread context (may sleep)
2611  *
2612  *      RETURNS:
2613  *      0 on success, -errno otherwise.
2614  */
2615 int ata_std_softreset(struct ata_port *ap, unsigned int *classes)
2616 {
2617         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2618         unsigned int devmask = 0, err_mask;
2619         u8 err;
2620
2621         DPRINTK("ENTER\n");
2622
2623         if (ata_port_offline(ap)) {
2624                 classes[0] = ATA_DEV_NONE;
2625                 goto out;
2626         }
2627
2628         /* determine if device 0/1 are present */
2629         if (ata_devchk(ap, 0))
2630                 devmask |= (1 << 0);
2631         if (slave_possible && ata_devchk(ap, 1))
2632                 devmask |= (1 << 1);
2633
2634         /* select device 0 again */
2635         ap->ops->dev_select(ap, 0);
2636
2637         /* issue bus reset */
2638         DPRINTK("about to softreset, devmask=%x\n", devmask);
2639         err_mask = ata_bus_softreset(ap, devmask);
2640         if (err_mask) {
2641                 ata_port_printk(ap, KERN_ERR, "SRST failed (err_mask=0x%x)\n",
2642                                 err_mask);
2643                 return -EIO;
2644         }
2645
2646         /* determine by signature whether we have ATA or ATAPI devices */
2647         classes[0] = ata_dev_try_classify(ap, 0, &err);
2648         if (slave_possible && err != 0x81)
2649                 classes[1] = ata_dev_try_classify(ap, 1, &err);
2650
2651  out:
2652         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2653         return 0;
2654 }
2655
2656 /**
2657  *      sata_std_hardreset - reset host port via SATA phy reset
2658  *      @ap: port to reset
2659  *      @class: resulting class of attached device
2660  *
2661  *      SATA phy-reset host port using DET bits of SControl register.
2662  *
2663  *      LOCKING:
2664  *      Kernel thread context (may sleep)
2665  *
2666  *      RETURNS:
2667  *      0 on success, -errno otherwise.
2668  */
2669 int sata_std_hardreset(struct ata_port *ap, unsigned int *class)
2670 {
2671         u32 scontrol;
2672         int rc;
2673
2674         DPRINTK("ENTER\n");
2675
2676         if (sata_set_spd_needed(ap)) {
2677                 /* SATA spec says nothing about how to reconfigure
2678                  * spd.  To be on the safe side, turn off phy during
2679                  * reconfiguration.  This works for at least ICH7 AHCI
2680                  * and Sil3124.
2681                  */
2682                 if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2683                         return rc;
2684
2685                 scontrol = (scontrol & 0x0f0) | 0x302;
2686
2687                 if ((rc = sata_scr_write(ap, SCR_CONTROL, scontrol)))
2688                         return rc;
2689
2690                 sata_set_spd(ap);
2691         }
2692
2693         /* issue phy wake/reset */
2694         if ((rc = sata_scr_read(ap, SCR_CONTROL, &scontrol)))
2695                 return rc;
2696
2697         scontrol = (scontrol & 0x0f0) | 0x301;
2698
2699         if ((rc = sata_scr_write_flush(ap, SCR_CONTROL, scontrol)))
2700                 return rc;
2701
2702         /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
2703          * 10.4.2 says at least 1 ms.
2704          */
2705         msleep(1);
2706
2707         /* bring phy back */
2708         sata_phy_resume(ap, sata_deb_timing_eh);
2709
2710         /* TODO: phy layer with polling, timeouts, etc. */
2711         if (ata_port_offline(ap)) {
2712                 *class = ATA_DEV_NONE;
2713                 DPRINTK("EXIT, link offline\n");
2714                 return 0;
2715         }
2716
2717         if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
2718                 ata_port_printk(ap, KERN_ERR,
2719                                 "COMRESET failed (device not ready)\n");
2720                 return -EIO;
2721         }
2722
2723         ap->ops->dev_select(ap, 0);     /* probably unnecessary */
2724
2725         *class = ata_dev_try_classify(ap, 0, NULL);
2726
2727         DPRINTK("EXIT, class=%u\n", *class);
2728         return 0;
2729 }
2730
2731 /**
2732  *      ata_std_postreset - standard postreset callback
2733  *      @ap: the target ata_port
2734  *      @classes: classes of attached devices
2735  *
2736  *      This function is invoked after a successful reset.  Note that
2737  *      the device might have been reset more than once using
2738  *      different reset methods before postreset is invoked.
2739  *
2740  *      LOCKING:
2741  *      Kernel thread context (may sleep)
2742  */
2743 void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
2744 {
2745         u32 serror;
2746
2747         DPRINTK("ENTER\n");
2748
2749         /* print link status */
2750         sata_print_link_status(ap);
2751
2752         /* clear SError */
2753         if (sata_scr_read(ap, SCR_ERROR, &serror) == 0)
2754                 sata_scr_write(ap, SCR_ERROR, serror);
2755
2756         /* re-enable interrupts */
2757         if (!ap->ops->error_handler) {
2758                 /* FIXME: hack. create a hook instead */
2759                 if (ap->ioaddr.ctl_addr)
2760                         ata_irq_on(ap);
2761         }
2762
2763         /* is double-select really necessary? */
2764         if (classes[0] != ATA_DEV_NONE)
2765                 ap->ops->dev_select(ap, 1);
2766         if (classes[1] != ATA_DEV_NONE)
2767                 ap->ops->dev_select(ap, 0);
2768
2769         /* bail out if no device is present */
2770         if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2771                 DPRINTK("EXIT, no device\n");
2772                 return;
2773         }
2774
2775         /* set up device control */
2776         if (ap->ioaddr.ctl_addr) {
2777                 if (ap->flags & ATA_FLAG_MMIO)
2778                         writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
2779                 else
2780                         outb(ap->ctl, ap->ioaddr.ctl_addr);
2781         }
2782
2783         DPRINTK("EXIT\n");
2784 }
2785
2786 /**
2787  *      ata_dev_same_device - Determine whether new ID matches configured device
2788  *      @dev: device to compare against
2789  *      @new_class: class of the new device
2790  *      @new_id: IDENTIFY page of the new device
2791  *
2792  *      Compare @new_class and @new_id against @dev and determine
2793  *      whether @dev is the device indicated by @new_class and
2794  *      @new_id.
2795  *
2796  *      LOCKING:
2797  *      None.
2798  *
2799  *      RETURNS:
2800  *      1 if @dev matches @new_class and @new_id, 0 otherwise.
2801  */
2802 static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
2803                                const u16 *new_id)
2804 {
2805         const u16 *old_id = dev->id;
2806         unsigned char model[2][41], serial[2][21];
2807         u64 new_n_sectors;
2808
2809         if (dev->class != new_class) {
2810                 ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n",
2811                                dev->class, new_class);
2812                 return 0;
2813         }
2814
2815         ata_id_c_string(old_id, model[0], ATA_ID_PROD_OFS, sizeof(model[0]));
2816         ata_id_c_string(new_id, model[1], ATA_ID_PROD_OFS, sizeof(model[1]));
2817         ata_id_c_string(old_id, serial[0], ATA_ID_SERNO_OFS, sizeof(serial[0]));
2818         ata_id_c_string(new_id, serial[1], ATA_ID_SERNO_OFS, sizeof(serial[1]));
2819         new_n_sectors = ata_id_n_sectors(new_id);
2820
2821         if (strcmp(model[0], model[1])) {
2822                 ata_dev_printk(dev, KERN_INFO, "model number mismatch "
2823                                "'%s' != '%s'\n", model[0], model[1]);
2824                 return 0;
2825         }
2826
2827         if (strcmp(serial[0], serial[1])) {
2828                 ata_dev_printk(dev, KERN_INFO, "serial number mismatch "
2829                                "'%s' != '%s'\n", serial[0], serial[1]);
2830                 return 0;
2831         }
2832
2833         if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
2834                 ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch "
2835                                "%llu != %llu\n",
2836                                (unsigned long long)dev->n_sectors,
2837                                (unsigned long long)new_n_sectors);
2838                 return 0;
2839         }
2840
2841         return 1;
2842 }
2843
2844 /**
2845  *      ata_dev_revalidate - Revalidate ATA device
2846  *      @dev: device to revalidate
2847  *      @post_reset: is this revalidation after reset?
2848  *
2849  *      Re-read IDENTIFY page and make sure @dev is still attached to
2850  *      the port.
2851  *
2852  *      LOCKING:
2853  *      Kernel thread context (may sleep)
2854  *
2855  *      RETURNS:
2856  *      0 on success, negative errno otherwise
2857  */
2858 int ata_dev_revalidate(struct ata_device *dev, int post_reset)
2859 {
2860         unsigned int class = dev->class;
2861         u16 *id = (void *)dev->ap->sector_buf;
2862         int rc;
2863
2864         if (!ata_dev_enabled(dev)) {
2865                 rc = -ENODEV;
2866                 goto fail;
2867         }
2868
2869         /* read ID data */
2870         rc = ata_dev_read_id(dev, &class, post_reset, id);
2871         if (rc)
2872                 goto fail;
2873
2874         /* is the device still there? */
2875         if (!ata_dev_same_device(dev, class, id)) {
2876                 rc = -ENODEV;
2877                 goto fail;
2878         }
2879
2880         memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
2881
2882         /* configure device according to the new ID */
2883         rc = ata_dev_configure(dev, 0);
2884         if (rc == 0)
2885                 return 0;
2886
2887  fail:
2888         ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc);
2889         return rc;
2890 }
2891
2892 static const char * const ata_dma_blacklist [] = {
2893         "WDC AC11000H", NULL,
2894         "WDC AC22100H", NULL,
2895         "WDC AC32500H", NULL,
2896         "WDC AC33100H", NULL,
2897         "WDC AC31600H", NULL,
2898         "WDC AC32100H", "24.09P07",
2899         "WDC AC23200L", "21.10N21",
2900         "Compaq CRD-8241B",  NULL,
2901         "CRD-8400B", NULL,
2902         "CRD-8480B", NULL,
2903         "CRD-8482B", NULL,
2904         "CRD-84", NULL,
2905         "SanDisk SDP3B", NULL,
2906         "SanDisk SDP3B-64", NULL,
2907         "SANYO CD-ROM CRD", NULL,
2908         "HITACHI CDR-8", NULL,
2909         "HITACHI CDR-8335", NULL,
2910         "HITACHI CDR-8435", NULL,
2911         "Toshiba CD-ROM XM-6202B", NULL,
2912         "TOSHIBA CD-ROM XM-1702BC", NULL,
2913         "CD-532E-A", NULL,
2914         "E-IDE CD-ROM CR-840", NULL,
2915         "CD-ROM Drive/F5A", NULL,
2916         "WPI CDD-820", NULL,
2917         "SAMSUNG CD-ROM SC-148C", NULL,
2918         "SAMSUNG CD-ROM SC", NULL,
2919         "SanDisk SDP3B-64", NULL,
2920         "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
2921         "_NEC DV5800A", NULL,
2922         "SAMSUNG CD-ROM SN-124", "N001"
2923 };
2924
2925 static int ata_strim(char *s, size_t len)
2926 {
2927         len = strnlen(s, len);
2928
2929         /* ATAPI specifies that empty space is blank-filled; remove blanks */
2930         while ((len > 0) && (s[len - 1] == ' ')) {
2931                 len--;
2932                 s[len] = 0;
2933         }
2934         return len;
2935 }
2936
2937 static int ata_dma_blacklisted(const struct ata_device *dev)
2938 {
2939         unsigned char model_num[40];
2940         unsigned char model_rev[16];
2941         unsigned int nlen, rlen;
2942         int i;
2943
2944         ata_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2945                           sizeof(model_num));
2946         ata_id_string(dev->id, model_rev, ATA_ID_FW_REV_OFS,
2947                           sizeof(model_rev));
2948         nlen = ata_strim(model_num, sizeof(model_num));
2949         rlen = ata_strim(model_rev, sizeof(model_rev));
2950
2951         for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i += 2) {
2952                 if (!strncmp(ata_dma_blacklist[i], model_num, nlen)) {
2953                         if (ata_dma_blacklist[i+1] == NULL)
2954                                 return 1;
2955                         if (!strncmp(ata_dma_blacklist[i], model_rev, rlen))
2956                                 return 1;
2957                 }
2958         }
2959         return 0;
2960 }
2961
2962 /**
2963  *      ata_dev_xfermask - Compute supported xfermask of the given device
2964  *      @dev: Device to compute xfermask for
2965  *
2966  *      Compute supported xfermask of @dev and store it in
2967  *      dev->*_mask.  This function is responsible for applying all
2968  *      known limits including host controller limits, device
2969  *      blacklist, etc...
2970  *
2971  *      FIXME: The current implementation limits all transfer modes to
2972  *      the fastest of the lowested device on the port.  This is not
2973  *      required on most controllers.
2974  *
2975  *      LOCKING:
2976  *      None.
2977  */
2978 static void ata_dev_xfermask(struct ata_device *dev)
2979 {
2980         struct ata_port *ap = dev->ap;
2981         struct ata_host_set *hs = ap->host_set;
2982         unsigned long xfer_mask;
2983         int i;
2984
2985         xfer_mask = ata_pack_xfermask(ap->pio_mask,
2986                                       ap->mwdma_mask, ap->udma_mask);
2987
2988         /* Apply cable rule here.  Don't apply it early because when
2989          * we handle hot plug the cable type can itself change.
2990          */
2991         if (ap->cbl == ATA_CBL_PATA40)
2992                 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
2993
2994         /* FIXME: Use port-wide xfermask for now */
2995         for (i = 0; i < ATA_MAX_DEVICES; i++) {
2996                 struct ata_device *d = &ap->device[i];
2997
2998                 if (ata_dev_absent(d))
2999                         continue;
3000
3001                 if (ata_dev_disabled(d)) {
3002                         /* to avoid violating device selection timing */
3003                         xfer_mask &= ata_pack_xfermask(d->pio_mask,
3004                                                        UINT_MAX, UINT_MAX);
3005                         continue;
3006                 }
3007
3008                 xfer_mask &= ata_pack_xfermask(d->pio_mask,
3009                                                d->mwdma_mask, d->udma_mask);
3010                 xfer_mask &= ata_id_xfermask(d->id);
3011                 if (ata_dma_blacklisted(d))
3012                         xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
3013         }
3014
3015         if (ata_dma_blacklisted(dev))
3016                 ata_dev_printk(dev, KERN_WARNING,
3017                                "device is on DMA blacklist, disabling DMA\n");
3018
3019         if (hs->flags & ATA_HOST_SIMPLEX) {
3020                 if (hs->simplex_claimed)
3021                         xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
3022         }
3023
3024         if (ap->ops->mode_filter)
3025                 xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
3026
3027         ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
3028                             &dev->mwdma_mask, &dev->udma_mask);
3029 }
3030
3031 /**
3032  *      ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
3033  *      @dev: Device to which command will be sent
3034  *
3035  *      Issue SET FEATURES - XFER MODE command to device @dev
3036  *      on port @ap.
3037  *
3038  *      LOCKING:
3039  *      PCI/etc. bus probe sem.
3040  *
3041  *      RETURNS:
3042  *      0 on success, AC_ERR_* mask otherwise.
3043  */
3044
3045 static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
3046 {
3047         struct ata_taskfile tf;
3048         unsigned int err_mask;
3049
3050         /* set up set-features taskfile */
3051         DPRINTK("set features - xfer mode\n");
3052
3053         ata_tf_init(dev, &tf);
3054         tf.command = ATA_CMD_SET_FEATURES;
3055         tf.feature = SETFEATURES_XFER;
3056         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3057         tf.protocol = ATA_PROT_NODATA;
3058         tf.nsect = dev->xfer_mode;
3059
3060         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
3061
3062         DPRINTK("EXIT, err_mask=%x\n", err_mask);
3063         return err_mask;
3064 }
3065
3066 /**
3067  *      ata_dev_init_params - Issue INIT DEV PARAMS command
3068  *      @dev: Device to which command will be sent
3069  *      @heads: Number of heads (taskfile parameter)
3070  *      @sectors: Number of sectors (taskfile parameter)
3071  *
3072  *      LOCKING:
3073  *      Kernel thread context (may sleep)
3074  *
3075  *      RETURNS:
3076  *      0 on success, AC_ERR_* mask otherwise.
3077  */
3078 static unsigned int ata_dev_init_params(struct ata_device *dev,
3079                                         u16 heads, u16 sectors)
3080 {
3081         struct ata_taskfile tf;
3082         unsigned int err_mask;
3083
3084         /* Number of sectors per track 1-255. Number of heads 1-16 */
3085         if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
3086                 return AC_ERR_INVALID;
3087
3088         /* set up init dev params taskfile */
3089         DPRINTK("init dev params \n");
3090
3091         ata_tf_init(dev, &tf);
3092         tf.command = ATA_CMD_INIT_DEV_PARAMS;
3093         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3094         tf.protocol = ATA_PROT_NODATA;
3095         tf.nsect = sectors;
3096         tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
3097
3098         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
3099
3100         DPRINTK("EXIT, err_mask=%x\n", err_mask);
3101         return err_mask;
3102 }
3103
3104 /**
3105  *      ata_sg_clean - Unmap DMA memory associated with command
3106  *      @qc: Command containing DMA memory to be released
3107  *
3108  *      Unmap all mapped DMA memory associated with this command.
3109  *
3110  *      LOCKING:
3111  *      spin_lock_irqsave(host_set lock)
3112  */
3113
3114 static void ata_sg_clean(struct ata_queued_cmd *qc)
3115 {
3116         struct ata_port *ap = qc->ap;
3117         struct scatterlist *sg = qc->__sg;
3118         int dir = qc->dma_dir;
3119         void *pad_buf = NULL;
3120
3121         WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
3122         WARN_ON(sg == NULL);
3123
3124         if (qc->flags & ATA_QCFLAG_SINGLE)
3125                 WARN_ON(qc->n_elem > 1);
3126
3127         VPRINTK("unmapping %u sg elements\n", qc->n_elem);
3128
3129         /* if we padded the buffer out to 32-bit bound, and data
3130          * xfer direction is from-device, we must copy from the
3131          * pad buffer back into the supplied buffer
3132          */
3133         if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
3134                 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3135
3136         if (qc->flags & ATA_QCFLAG_SG) {
3137                 if (qc->n_elem)
3138                         dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
3139                 /* restore last sg */
3140                 sg[qc->orig_n_elem - 1].length += qc->pad_len;
3141                 if (pad_buf) {
3142                         struct scatterlist *psg = &qc->pad_sgent;
3143                         void *addr = kmap_atomic(psg->page, KM_IRQ0);
3144                         memcpy(addr + psg->offset, pad_buf, qc->pad_len);
3145                         kunmap_atomic(addr, KM_IRQ0);
3146                 }
3147         } else {
3148                 if (qc->n_elem)
3149                         dma_unmap_single(ap->dev,
3150                                 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
3151                                 dir);
3152                 /* restore sg */
3153                 sg->length += qc->pad_len;
3154                 if (pad_buf)
3155                         memcpy(qc->buf_virt + sg->length - qc->pad_len,
3156                                pad_buf, qc->pad_len);
3157         }
3158
3159         qc->flags &= ~ATA_QCFLAG_DMAMAP;
3160         qc->__sg = NULL;
3161 }
3162
3163 /**
3164  *      ata_fill_sg - Fill PCI IDE PRD table
3165  *      @qc: Metadata associated with taskfile to be transferred
3166  *
3167  *      Fill PCI IDE PRD (scatter-gather) table with segments
3168  *      associated with the current disk command.
3169  *
3170  *      LOCKING:
3171  *      spin_lock_irqsave(host_set lock)
3172  *
3173  */
3174 static void ata_fill_sg(struct ata_queued_cmd *qc)
3175 {
3176         struct ata_port *ap = qc->ap;
3177         struct scatterlist *sg;
3178         unsigned int idx;
3179
3180         WARN_ON(qc->__sg == NULL);
3181         WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
3182
3183         idx = 0;
3184         ata_for_each_sg(sg, qc) {
3185                 u32 addr, offset;
3186                 u32 sg_len, len;
3187
3188                 /* determine if physical DMA addr spans 64K boundary.
3189                  * Note h/w doesn't support 64-bit, so we unconditionally
3190                  * truncate dma_addr_t to u32.
3191                  */
3192                 addr = (u32) sg_dma_address(sg);
3193                 sg_len = sg_dma_len(sg);
3194
3195                 while (sg_len) {
3196                         offset = addr & 0xffff;
3197                         len = sg_len;
3198                         if ((offset + sg_len) > 0x10000)
3199                                 len = 0x10000 - offset;
3200
3201                         ap->prd[idx].addr = cpu_to_le32(addr);
3202                         ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
3203                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
3204
3205                         idx++;
3206                         sg_len -= len;
3207                         addr += len;
3208                 }
3209         }
3210
3211         if (idx)
3212                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
3213 }
3214 /**
3215  *      ata_check_atapi_dma - Check whether ATAPI DMA can be supported
3216  *      @qc: Metadata associated with taskfile to check
3217  *
3218  *      Allow low-level driver to filter ATA PACKET commands, returning
3219  *      a status indicating whether or not it is OK to use DMA for the
3220  *      supplied PACKET command.
3221  *
3222  *      LOCKING:
3223  *      spin_lock_irqsave(host_set lock)
3224  *
3225  *      RETURNS: 0 when ATAPI DMA can be used
3226  *               nonzero otherwise
3227  */
3228 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
3229 {
3230         struct ata_port *ap = qc->ap;
3231         int rc = 0; /* Assume ATAPI DMA is OK by default */
3232
3233         if (ap->ops->check_atapi_dma)
3234                 rc = ap->ops->check_atapi_dma(qc);
3235
3236         /* We don't support polling DMA.
3237          * Use PIO if the LLDD handles only interrupts in
3238          * the HSM_ST_LAST state and the ATAPI device
3239          * generates CDB interrupts.
3240          */
3241         if ((ap->flags & ATA_FLAG_PIO_POLLING) &&
3242             (qc->dev->flags & ATA_DFLAG_CDB_INTR))
3243                 rc = 1;
3244
3245         return rc;
3246 }
3247 /**
3248  *      ata_qc_prep - Prepare taskfile for submission
3249  *      @qc: Metadata associated with taskfile to be prepared
3250  *
3251  *      Prepare ATA taskfile for submission.
3252  *
3253  *      LOCKING:
3254  *      spin_lock_irqsave(host_set lock)
3255  */
3256 void ata_qc_prep(struct ata_queued_cmd *qc)
3257 {
3258         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
3259                 return;
3260
3261         ata_fill_sg(qc);
3262 }
3263
3264 void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
3265
3266 /**
3267  *      ata_sg_init_one - Associate command with memory buffer
3268  *      @qc: Command to be associated
3269  *      @buf: Memory buffer
3270  *      @buflen: Length of memory buffer, in bytes.
3271  *
3272  *      Initialize the data-related elements of queued_cmd @qc
3273  *      to point to a single memory buffer, @buf of byte length @buflen.
3274  *
3275  *      LOCKING:
3276  *      spin_lock_irqsave(host_set lock)
3277  */
3278
3279 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
3280 {
3281         struct scatterlist *sg;
3282
3283         qc->flags |= ATA_QCFLAG_SINGLE;
3284
3285         memset(&qc->sgent, 0, sizeof(qc->sgent));
3286         qc->__sg = &qc->sgent;
3287         qc->n_elem = 1;
3288         qc->orig_n_elem = 1;
3289         qc->buf_virt = buf;
3290
3291         sg = qc->__sg;
3292         sg_init_one(sg, buf, buflen);
3293 }
3294
3295 /**
3296  *      ata_sg_init - Associate command with scatter-gather table.
3297  *      @qc: Command to be associated
3298  *      @sg: Scatter-gather table.
3299  *      @n_elem: Number of elements in s/g table.
3300  *
3301  *      Initialize the data-related elements of queued_cmd @qc
3302  *      to point to a scatter-gather table @sg, containing @n_elem
3303  *      elements.
3304  *
3305  *      LOCKING:
3306  *      spin_lock_irqsave(host_set lock)
3307  */
3308
3309 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
3310                  unsigned int n_elem)
3311 {
3312         qc->flags |= ATA_QCFLAG_SG;
3313         qc->__sg = sg;
3314         qc->n_elem = n_elem;
3315         qc->orig_n_elem = n_elem;
3316 }
3317
3318 /**
3319  *      ata_sg_setup_one - DMA-map the memory buffer associated with a command.
3320  *      @qc: Command with memory buffer to be mapped.
3321  *
3322  *      DMA-map the memory buffer associated with queued_cmd @qc.
3323  *
3324  *      LOCKING:
3325  *      spin_lock_irqsave(host_set lock)
3326  *
3327  *      RETURNS:
3328  *      Zero on success, negative on error.
3329  */
3330
3331 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
3332 {
3333         struct ata_port *ap = qc->ap;
3334         int dir = qc->dma_dir;
3335         struct scatterlist *sg = qc->__sg;
3336         dma_addr_t dma_address;
3337         int trim_sg = 0;
3338
3339         /* we must lengthen transfers to end on a 32-bit boundary */
3340         qc->pad_len = sg->length & 3;
3341         if (qc->pad_len) {
3342                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3343                 struct scatterlist *psg = &qc->pad_sgent;
3344
3345                 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
3346
3347                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3348
3349                 if (qc->tf.flags & ATA_TFLAG_WRITE)
3350                         memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3351                                qc->pad_len);
3352
3353                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3354                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3355                 /* trim sg */
3356                 sg->length -= qc->pad_len;
3357                 if (sg->length == 0)
3358                         trim_sg = 1;
3359
3360                 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3361                         sg->length, qc->pad_len);
3362         }
3363
3364         if (trim_sg) {
3365                 qc->n_elem--;
3366                 goto skip_map;
3367         }
3368
3369         dma_address = dma_map_single(ap->dev, qc->buf_virt,
3370                                      sg->length, dir);
3371         if (dma_mapping_error(dma_address)) {
3372                 /* restore sg */
3373                 sg->length += qc->pad_len;
3374                 return -1;
3375         }
3376
3377         sg_dma_address(sg) = dma_address;
3378         sg_dma_len(sg) = sg->length;
3379
3380 skip_map:
3381         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3382                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3383
3384         return 0;
3385 }
3386
3387 /**
3388  *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3389  *      @qc: Command with scatter-gather table to be mapped.
3390  *
3391  *      DMA-map the scatter-gather table associated with queued_cmd @qc.
3392  *
3393  *      LOCKING:
3394  *      spin_lock_irqsave(host_set lock)
3395  *
3396  *      RETURNS:
3397  *      Zero on success, negative on error.
3398  *
3399  */
3400
3401 static int ata_sg_setup(struct ata_queued_cmd *qc)
3402 {
3403         struct ata_port *ap = qc->ap;
3404         struct scatterlist *sg = qc->__sg;
3405         struct scatterlist *lsg = &sg[qc->n_elem - 1];
3406         int n_elem, pre_n_elem, dir, trim_sg = 0;
3407
3408         VPRINTK("ENTER, ata%u\n", ap->id);
3409         WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
3410
3411         /* we must lengthen transfers to end on a 32-bit boundary */
3412         qc->pad_len = lsg->length & 3;
3413         if (qc->pad_len) {
3414                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3415                 struct scatterlist *psg = &qc->pad_sgent;
3416                 unsigned int offset;
3417
3418                 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
3419
3420                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3421
3422                 /*
3423                  * psg->page/offset are used to copy to-be-written
3424                  * data in this function or read data in ata_sg_clean.
3425                  */
3426                 offset = lsg->offset + lsg->length - qc->pad_len;
3427                 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3428                 psg->offset = offset_in_page(offset);
3429
3430                 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3431                         void *addr = kmap_atomic(psg->page, KM_IRQ0);
3432                         memcpy(pad_buf, addr + psg->offset, qc->pad_len);
3433                         kunmap_atomic(addr, KM_IRQ0);
3434                 }
3435
3436                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3437                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3438                 /* trim last sg */
3439                 lsg->length -= qc->pad_len;
3440                 if (lsg->length == 0)
3441                         trim_sg = 1;
3442
3443                 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3444                         qc->n_elem - 1, lsg->length, qc->pad_len);
3445         }
3446
3447         pre_n_elem = qc->n_elem;
3448         if (trim_sg && pre_n_elem)
3449                 pre_n_elem--;
3450
3451         if (!pre_n_elem) {
3452                 n_elem = 0;
3453                 goto skip_map;
3454         }
3455
3456         dir = qc->dma_dir;
3457         n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
3458         if (n_elem < 1) {
3459                 /* restore last sg */
3460                 lsg->length += qc->pad_len;
3461                 return -1;
3462         }
3463
3464         DPRINTK("%d sg elements mapped\n", n_elem);
3465
3466 skip_map:
3467         qc->n_elem = n_elem;
3468
3469         return 0;
3470 }
3471
3472 /**
3473  *      swap_buf_le16 - swap halves of 16-bit words in place
3474  *      @buf:  Buffer to swap
3475  *      @buf_words:  Number of 16-bit words in buffer.
3476  *
3477  *      Swap halves of 16-bit words if needed to convert from
3478  *      little-endian byte order to native cpu byte order, or
3479  *      vice-versa.
3480  *
3481  *      LOCKING:
3482  *      Inherited from caller.
3483  */
3484 void swap_buf_le16(u16 *buf, unsigned int buf_words)
3485 {
3486 #ifdef __BIG_ENDIAN
3487         unsigned int i;
3488
3489         for (i = 0; i < buf_words; i++)
3490                 buf[i] = le16_to_cpu(buf[i]);
3491 #endif /* __BIG_ENDIAN */
3492 }
3493
3494 /**
3495  *      ata_mmio_data_xfer - Transfer data by MMIO
3496  *      @dev: device for this I/O
3497  *      @buf: data buffer
3498  *      @buflen: buffer length
3499  *      @write_data: read/write
3500  *
3501  *      Transfer data from/to the device data register by MMIO.
3502  *
3503  *      LOCKING:
3504  *      Inherited from caller.
3505  */
3506
3507 void ata_mmio_data_xfer(struct ata_device *adev, unsigned char *buf,
3508                         unsigned int buflen, int write_data)
3509 {
3510         struct ata_port *ap = adev->ap;
3511         unsigned int i;
3512         unsigned int words = buflen >> 1;
3513         u16 *buf16 = (u16 *) buf;
3514         void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
3515
3516         /* Transfer multiple of 2 bytes */
3517         if (write_data) {
3518                 for (i = 0; i < words; i++)
3519                         writew(le16_to_cpu(buf16[i]), mmio);
3520         } else {
3521                 for (i = 0; i < words; i++)
3522                         buf16[i] = cpu_to_le16(readw(mmio));
3523         }
3524
3525         /* Transfer trailing 1 byte, if any. */
3526         if (unlikely(buflen & 0x01)) {
3527                 u16 align_buf[1] = { 0 };
3528                 unsigned char *trailing_buf = buf + buflen - 1;
3529
3530                 if (write_data) {
3531                         memcpy(align_buf, trailing_buf, 1);
3532                         writew(le16_to_cpu(align_buf[0]), mmio);
3533                 } else {
3534                         align_buf[0] = cpu_to_le16(readw(mmio));
3535                         memcpy(trailing_buf, align_buf, 1);
3536                 }
3537         }
3538 }
3539
3540 /**
3541  *      ata_pio_data_xfer - Transfer data by PIO
3542  *      @adev: device to target
3543  *      @buf: data buffer
3544  *      @buflen: buffer length
3545  *      @write_data: read/write
3546  *
3547  *      Transfer data from/to the device data register by PIO.
3548  *
3549  *      LOCKING:
3550  *      Inherited from caller.
3551  */
3552
3553 void ata_pio_data_xfer(struct ata_device *adev, unsigned char *buf,
3554                        unsigned int buflen, int write_data)
3555 {
3556         struct ata_port *ap = adev->ap;
3557         unsigned int words = buflen >> 1;
3558
3559         /* Transfer multiple of 2 bytes */
3560         if (write_data)
3561                 outsw(ap->ioaddr.data_addr, buf, words);
3562         else
3563                 insw(ap->ioaddr.data_addr, buf, words);
3564
3565         /* Transfer trailing 1 byte, if any. */
3566         if (unlikely(buflen & 0x01)) {
3567                 u16 align_buf[1] = { 0 };
3568                 unsigned char *trailing_buf = buf + buflen - 1;
3569
3570                 if (write_data) {
3571                         memcpy(align_buf, trailing_buf, 1);
3572                         outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3573                 } else {
3574                         align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
3575                         memcpy(trailing_buf, align_buf, 1);
3576                 }
3577         }
3578 }
3579
3580 /**
3581  *      ata_pio_data_xfer_noirq - Transfer data by PIO
3582  *      @adev: device to target
3583  *      @buf: data buffer
3584  *      @buflen: buffer length
3585  *      @write_data: read/write
3586  *
3587  *      Transfer data from/to the device data register by PIO. Do the
3588  *      transfer with interrupts disabled.
3589  *
3590  *      LOCKING:
3591  *      Inherited from caller.
3592  */
3593
3594 void ata_pio_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
3595                                     unsigned int buflen, int write_data)
3596 {
3597         unsigned long flags;
3598         local_irq_save(flags);
3599         ata_pio_data_xfer(adev, buf, buflen, write_data);
3600         local_irq_restore(flags);
3601 }
3602
3603
3604 /**
3605  *      ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3606  *      @qc: Command on going
3607  *
3608  *      Transfer ATA_SECT_SIZE of data from/to the ATA device.
3609  *
3610  *      LOCKING:
3611  *      Inherited from caller.
3612  */
3613
3614 static void ata_pio_sector(struct ata_queued_cmd *qc)
3615 {
3616         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3617         struct scatterlist *sg = qc->__sg;
3618         struct ata_port *ap = qc->ap;
3619         struct page *page;
3620         unsigned int offset;
3621         unsigned char *buf;
3622
3623         if (qc->cursect == (qc->nsect - 1))
3624                 ap->hsm_task_state = HSM_ST_LAST;
3625
3626         page = sg[qc->cursg].page;
3627         offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
3628
3629         /* get the current page and offset */
3630         page = nth_page(page, (offset >> PAGE_SHIFT));
3631         offset %= PAGE_SIZE;
3632
3633         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3634
3635         if (PageHighMem(page)) {
3636                 unsigned long flags;
3637
3638                 /* FIXME: use a bounce buffer */
3639                 local_irq_save(flags);
3640                 buf = kmap_atomic(page, KM_IRQ0);
3641
3642                 /* do the actual data transfer */
3643                 ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
3644
3645                 kunmap_atomic(buf, KM_IRQ0);
3646                 local_irq_restore(flags);
3647         } else {
3648                 buf = page_address(page);
3649                 ap->ops->data_xfer(qc->dev, buf + offset, ATA_SECT_SIZE, do_write);
3650         }
3651
3652         qc->cursect++;
3653         qc->cursg_ofs++;
3654
3655         if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
3656                 qc->cursg++;
3657                 qc->cursg_ofs = 0;
3658         }
3659 }
3660
3661 /**
3662  *      ata_pio_sectors - Transfer one or many 512-byte sectors.
3663  *      @qc: Command on going
3664  *
3665  *      Transfer one or many ATA_SECT_SIZE of data from/to the
3666  *      ATA device for the DRQ request.
3667  *
3668  *      LOCKING:
3669  *      Inherited from caller.
3670  */
3671
3672 static void ata_pio_sectors(struct ata_queued_cmd *qc)
3673 {
3674         if (is_multi_taskfile(&qc->tf)) {
3675                 /* READ/WRITE MULTIPLE */
3676                 unsigned int nsect;
3677
3678                 WARN_ON(qc->dev->multi_count == 0);
3679
3680                 nsect = min(qc->nsect - qc->cursect, qc->dev->multi_count);
3681                 while (nsect--)
3682                         ata_pio_sector(qc);
3683         } else
3684                 ata_pio_sector(qc);
3685 }
3686
3687 /**
3688  *      atapi_send_cdb - Write CDB bytes to hardware
3689  *      @ap: Port to which ATAPI device is attached.
3690  *      @qc: Taskfile currently active
3691  *
3692  *      When device has indicated its readiness to accept
3693  *      a CDB, this function is called.  Send the CDB.
3694  *
3695  *      LOCKING:
3696  *      caller.
3697  */
3698
3699 static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
3700 {
3701         /* send SCSI cdb */
3702         DPRINTK("send cdb\n");
3703         WARN_ON(qc->dev->cdb_len < 12);
3704
3705         ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
3706         ata_altstatus(ap); /* flush */
3707
3708         switch (qc->tf.protocol) {
3709         case ATA_PROT_ATAPI:
3710                 ap->hsm_task_state = HSM_ST;
3711                 break;
3712         case ATA_PROT_ATAPI_NODATA:
3713                 ap->hsm_task_state = HSM_ST_LAST;
3714                 break;
3715         case ATA_PROT_ATAPI_DMA:
3716                 ap->hsm_task_state = HSM_ST_LAST;
3717                 /* initiate bmdma */
3718                 ap->ops->bmdma_start(qc);
3719                 break;
3720         }
3721 }
3722
3723 /**
3724  *      __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3725  *      @qc: Command on going
3726  *      @bytes: number of bytes
3727  *
3728  *      Transfer Transfer data from/to the ATAPI device.
3729  *
3730  *      LOCKING:
3731  *      Inherited from caller.
3732  *
3733  */
3734
3735 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3736 {
3737         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3738         struct scatterlist *sg = qc->__sg;
3739         struct ata_port *ap = qc->ap;
3740         struct page *page;
3741         unsigned char *buf;
3742         unsigned int offset, count;
3743
3744         if (qc->curbytes + bytes >= qc->nbytes)
3745                 ap->hsm_task_state = HSM_ST_LAST;
3746
3747 next_sg:
3748         if (unlikely(qc->cursg >= qc->n_elem)) {
3749                 /*
3750                  * The end of qc->sg is reached and the device expects
3751                  * more data to transfer. In order not to overrun qc->sg
3752                  * and fulfill length specified in the byte count register,
3753                  *    - for read case, discard trailing data from the device
3754                  *    - for write case, padding zero data to the device
3755                  */
3756                 u16 pad_buf[1] = { 0 };
3757                 unsigned int words = bytes >> 1;
3758                 unsigned int i;
3759
3760                 if (words) /* warning if bytes > 1 */
3761                         ata_dev_printk(qc->dev, KERN_WARNING,
3762                                        "%u bytes trailing data\n", bytes);
3763
3764                 for (i = 0; i < words; i++)
3765                         ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write);
3766
3767                 ap->hsm_task_state = HSM_ST_LAST;
3768                 return;
3769         }
3770
3771         sg = &qc->__sg[qc->cursg];
3772
3773         page = sg->page;
3774         offset = sg->offset + qc->cursg_ofs;
3775
3776         /* get the current page and offset */
3777         page = nth_page(page, (offset >> PAGE_SHIFT));
3778         offset %= PAGE_SIZE;
3779
3780         /* don't overrun current sg */
3781         count = min(sg->length - qc->cursg_ofs, bytes);
3782
3783         /* don't cross page boundaries */
3784         count = min(count, (unsigned int)PAGE_SIZE - offset);
3785
3786         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3787
3788         if (PageHighMem(page)) {
3789                 unsigned long flags;
3790
3791                 /* FIXME: use bounce buffer */
3792                 local_irq_save(flags);
3793                 buf = kmap_atomic(page, KM_IRQ0);
3794
3795                 /* do the actual data transfer */
3796                 ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
3797
3798                 kunmap_atomic(buf, KM_IRQ0);
3799                 local_irq_restore(flags);
3800         } else {
3801                 buf = page_address(page);
3802                 ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
3803         }
3804
3805         bytes -= count;
3806         qc->curbytes += count;
3807         qc->cursg_ofs += count;
3808
3809         if (qc->cursg_ofs == sg->length) {
3810                 qc->cursg++;
3811                 qc->cursg_ofs = 0;
3812         }
3813
3814         if (bytes)
3815                 goto next_sg;
3816 }
3817
3818 /**
3819  *      atapi_pio_bytes - Transfer data from/to the ATAPI device.
3820  *      @qc: Command on going
3821  *
3822  *      Transfer Transfer data from/to the ATAPI device.
3823  *
3824  *      LOCKING:
3825  *      Inherited from caller.
3826  */
3827
3828 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3829 {
3830         struct ata_port *ap = qc->ap;
3831         struct ata_device *dev = qc->dev;
3832         unsigned int ireason, bc_lo, bc_hi, bytes;
3833         int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3834
3835         /* Abuse qc->result_tf for temp storage of intermediate TF
3836          * here to save some kernel stack usage.
3837          * For normal completion, qc->result_tf is not relevant. For
3838          * error, qc->result_tf is later overwritten by ata_qc_complete().
3839          * So, the correctness of qc->result_tf is not affected.
3840          */
3841         ap->ops->tf_read(ap, &qc->result_tf);
3842         ireason = qc->result_tf.nsect;
3843         bc_lo = qc->result_tf.lbam;
3844         bc_hi = qc->result_tf.lbah;
3845         bytes = (bc_hi << 8) | bc_lo;
3846
3847         /* shall be cleared to zero, indicating xfer of data */
3848         if (ireason & (1 << 0))
3849                 goto err_out;
3850
3851         /* make sure transfer direction matches expected */
3852         i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3853         if (do_write != i_write)
3854                 goto err_out;
3855
3856         VPRINTK("ata%u: xfering %d bytes\n", ap->id, bytes);
3857
3858         __atapi_pio_bytes(qc, bytes);
3859
3860         return;
3861
3862 err_out:
3863         ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n");
3864         qc->err_mask |= AC_ERR_HSM;
3865         ap->hsm_task_state = HSM_ST_ERR;
3866 }
3867
3868 /**
3869  *      ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue.
3870  *      @ap: the target ata_port
3871  *      @qc: qc on going
3872  *
3873  *      RETURNS:
3874  *      1 if ok in workqueue, 0 otherwise.
3875  */
3876
3877 static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
3878 {
3879         if (qc->tf.flags & ATA_TFLAG_POLLING)
3880                 return 1;
3881
3882         if (ap->hsm_task_state == HSM_ST_FIRST) {
3883                 if (qc->tf.protocol == ATA_PROT_PIO &&
3884                     (qc->tf.flags & ATA_TFLAG_WRITE))
3885                     return 1;
3886
3887                 if (is_atapi_taskfile(&qc->tf) &&
3888                     !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
3889                         return 1;
3890         }
3891
3892         return 0;
3893 }
3894
3895 /**
3896  *      ata_hsm_qc_complete - finish a qc running on standard HSM
3897  *      @qc: Command to complete
3898  *      @in_wq: 1 if called from workqueue, 0 otherwise
3899  *
3900  *      Finish @qc which is running on standard HSM.
3901  *
3902  *      LOCKING:
3903  *      If @in_wq is zero, spin_lock_irqsave(host_set lock).
3904  *      Otherwise, none on entry and grabs host lock.
3905  */
3906 static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
3907 {
3908         struct ata_port *ap = qc->ap;
3909         unsigned long flags;
3910
3911         if (ap->ops->error_handler) {
3912                 if (in_wq) {
3913                         spin_lock_irqsave(&ap->host_set->lock, flags);
3914
3915                         /* EH might have kicked in while host_set lock
3916                          * is released.
3917                          */
3918                         qc = ata_qc_from_tag(ap, qc->tag);
3919                         if (qc) {
3920                                 if (likely(!(qc->err_mask & AC_ERR_HSM))) {
3921                                         ata_irq_on(ap);
3922                                         ata_qc_complete(qc);
3923                                 } else
3924                                         ata_port_freeze(ap);
3925                         }
3926
3927                         spin_unlock_irqrestore(&ap->host_set->lock, flags);
3928                 } else {
3929                         if (likely(!(qc->err_mask & AC_ERR_HSM)))
3930                                 ata_qc_complete(qc);
3931                         else
3932                                 ata_port_freeze(ap);
3933                 }
3934         } else {
3935                 if (in_wq) {
3936                         spin_lock_irqsave(&ap->host_set->lock, flags);
3937                         ata_irq_on(ap);
3938                         ata_qc_complete(qc);
3939                         spin_unlock_irqrestore(&ap->host_set->lock, flags);
3940                 } else
3941                         ata_qc_complete(qc);
3942         }
3943
3944         ata_altstatus(ap); /* flush */
3945 }
3946
3947 /**
3948  *      ata_hsm_move - move the HSM to the next state.
3949  *      @ap: the target ata_port
3950  *      @qc: qc on going
3951  *      @status: current device status
3952  *      @in_wq: 1 if called from workqueue, 0 otherwise
3953  *
3954  *      RETURNS:
3955  *      1 when poll next status needed, 0 otherwise.
3956  */
3957 int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
3958                  u8 status, int in_wq)
3959 {
3960         unsigned long flags = 0;
3961         int poll_next;
3962
3963         WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
3964
3965         /* Make sure ata_qc_issue_prot() does not throw things
3966          * like DMA polling into the workqueue. Notice that
3967          * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING).
3968          */
3969         WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
3970
3971 fsm_start:
3972         DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
3973                 ap->id, qc->tf.protocol, ap->hsm_task_state, status);
3974
3975         switch (ap->hsm_task_state) {
3976         case HSM_ST_FIRST:
3977                 /* Send first data block or PACKET CDB */
3978
3979                 /* If polling, we will stay in the work queue after
3980                  * sending the data. Otherwise, interrupt handler
3981                  * takes over after sending the data.
3982                  */
3983                 poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
3984
3985                 /* check device status */
3986                 if (unlikely((status & ATA_DRQ) == 0)) {
3987                         /* handle BSY=0, DRQ=0 as error */
3988                         if (likely(status & (ATA_ERR | ATA_DF)))
3989                                 /* device stops HSM for abort/error */
3990                                 qc->err_mask |= AC_ERR_DEV;
3991                         else
3992                                 /* HSM violation. Let EH handle this */
3993                                 qc->err_mask |= AC_ERR_HSM;
3994
3995                         ap->hsm_task_state = HSM_ST_ERR;
3996                         goto fsm_start;
3997                 }
3998
3999                 /* Device should not ask for data transfer (DRQ=1)
4000                  * when it finds something wrong.
4001                  * We ignore DRQ here and stop the HSM by
4002                  * changing hsm_task_state to HSM_ST_ERR and
4003                  * let the EH abort the command or reset the device.
4004                  */
4005                 if (unlikely(status & (ATA_ERR | ATA_DF))) {
4006                         printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
4007                                ap->id, status);
4008                         qc->err_mask |= AC_ERR_HSM;
4009                         ap->hsm_task_state = HSM_ST_ERR;
4010                         goto fsm_start;
4011                 }
4012
4013                 /* Send the CDB (atapi) or the first data block (ata pio out).
4014                  * During the state transition, interrupt handler shouldn't
4015                  * be invoked before the data transfer is complete and
4016                  * hsm_task_state is changed. Hence, the following locking.
4017                  */
4018                 if (in_wq)
4019                         spin_lock_irqsave(&ap->host_set->lock, flags);
4020
4021                 if (qc->tf.protocol == ATA_PROT_PIO) {
4022                         /* PIO data out protocol.
4023                          * send first data block.
4024                          */
4025
4026                         /* ata_pio_sectors() might change the state
4027                          * to HSM_ST_LAST. so, the state is changed here
4028                          * before ata_pio_sectors().
4029                          */
4030                         ap->hsm_task_state = HSM_ST;
4031                         ata_pio_sectors(qc);
4032                         ata_altstatus(ap); /* flush */
4033                 } else
4034                         /* send CDB */
4035                         atapi_send_cdb(ap, qc);
4036
4037                 if (in_wq)
4038                         spin_unlock_irqrestore(&ap->host_set->lock, flags);
4039
4040                 /* if polling, ata_pio_task() handles the rest.
4041                  * otherwise, interrupt handler takes over from here.
4042                  */
4043                 break;
4044
4045         case HSM_ST:
4046                 /* complete command or read/write the data register */
4047                 if (qc->tf.protocol == ATA_PROT_ATAPI) {
4048                         /* ATAPI PIO protocol */
4049                         if ((status & ATA_DRQ) == 0) {
4050                                 /* No more data to transfer or device error.
4051                                  * Device error will be tagged in HSM_ST_LAST.
4052                                  */
4053                                 ap->hsm_task_state = HSM_ST_LAST;
4054                                 goto fsm_start;
4055                         }
4056
4057                         /* Device should not ask for data transfer (DRQ=1)
4058                          * when it finds something wrong.
4059                          * We ignore DRQ here and stop the HSM by
4060                          * changing hsm_task_state to HSM_ST_ERR and
4061                          * let the EH abort the command or reset the device.
4062                          */
4063                         if (unlikely(status & (ATA_ERR | ATA_DF))) {
4064                                 printk(KERN_WARNING "ata%d: DRQ=1 with device error, dev_stat 0x%X\n",
4065                                        ap->id, status);
4066                                 qc->err_mask |= AC_ERR_HSM;
4067                                 ap->hsm_task_state = HSM_ST_ERR;
4068                                 goto fsm_start;
4069                         }
4070
4071                         atapi_pio_bytes(qc);
4072
4073                         if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
4074                                 /* bad ireason reported by device */
4075                                 goto fsm_start;
4076
4077                 } else {
4078                         /* ATA PIO protocol */
4079                         if (unlikely((status & ATA_DRQ) == 0)) {
4080                                 /* handle BSY=0, DRQ=0 as error */
4081                                 if (likely(status & (ATA_ERR | ATA_DF)))
4082                                         /* device stops HSM for abort/error */
4083                                         qc->err_mask |= AC_ERR_DEV;
4084                                 else
4085                                         /* HSM violation. Let EH handle this */
4086                                         qc->err_mask |= AC_ERR_HSM;
4087
4088                                 ap->hsm_task_state = HSM_ST_ERR;
4089                                 goto fsm_start;
4090                         }
4091
4092                         /* For PIO reads, some devices may ask for
4093                          * data transfer (DRQ=1) alone with ERR=1.
4094                          * We respect DRQ here and transfer one
4095                          * block of junk data before changing the
4096                          * hsm_task_state to HSM_ST_ERR.
4097                          *
4098                          * For PIO writes, ERR=1 DRQ=1 doesn't make
4099                          * sense since the data block has been
4100                          * transferred to the device.
4101                          */
4102                         if (unlikely(status & (ATA_ERR | ATA_DF))) {
4103                                 /* data might be corrputed */
4104                                 qc->err_mask |= AC_ERR_DEV;
4105
4106                                 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
4107                                         ata_pio_sectors(qc);
4108                                         ata_altstatus(ap);
4109                                         status = ata_wait_idle(ap);
4110                                 }
4111
4112                                 if (status & (ATA_BUSY | ATA_DRQ))
4113                                         qc->err_mask |= AC_ERR_HSM;
4114
4115                                 /* ata_pio_sectors() might change the
4116                                  * state to HSM_ST_LAST. so, the state
4117                                  * is changed after ata_pio_sectors().
4118                                  */
4119                                 ap->hsm_task_state = HSM_ST_ERR;
4120                                 goto fsm_start;
4121                         }
4122
4123                         ata_pio_sectors(qc);
4124
4125                         if (ap->hsm_task_state == HSM_ST_LAST &&
4126                             (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
4127                                 /* all data read */
4128                                 ata_altstatus(ap);
4129                                 status = ata_wait_idle(ap);
4130                                 goto fsm_start;
4131                         }
4132                 }
4133
4134                 ata_altstatus(ap); /* flush */
4135                 poll_next = 1;
4136                 break;
4137
4138         case HSM_ST_LAST:
4139                 if (unlikely(!ata_ok(status))) {
4140                         qc->err_mask |= __ac_err_mask(status);
4141                         ap->hsm_task_state = HSM_ST_ERR;
4142                         goto fsm_start;
4143                 }
4144
4145                 /* no more data to transfer */
4146                 DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
4147                         ap->id, qc->dev->devno, status);
4148
4149                 WARN_ON(qc->err_mask);
4150
4151                 ap->hsm_task_state = HSM_ST_IDLE;
4152
4153                 /* complete taskfile transaction */
4154                 ata_hsm_qc_complete(qc, in_wq);
4155
4156                 poll_next = 0;
4157                 break;
4158
4159         case HSM_ST_ERR:
4160                 /* make sure qc->err_mask is available to
4161                  * know what's wrong and recover
4162                  */
4163                 WARN_ON(qc->err_mask == 0);
4164
4165                 ap->hsm_task_state = HSM_ST_IDLE;
4166
4167                 /* complete taskfile transaction */
4168                 ata_hsm_qc_complete(qc, in_wq);
4169
4170                 poll_next = 0;
4171                 break;
4172         default:
4173                 poll_next = 0;
4174                 BUG();
4175         }
4176
4177         return poll_next;
4178 }
4179
4180 static void ata_pio_task(void *_data)
4181 {
4182         struct ata_queued_cmd *qc = _data;
4183         struct ata_port *ap = qc->ap;
4184         u8 status;
4185         int poll_next;
4186
4187 fsm_start:
4188         WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
4189
4190         /*
4191          * This is purely heuristic.  This is a fast path.
4192          * Sometimes when we enter, BSY will be cleared in
4193          * a chk-status or two.  If not, the drive is probably seeking
4194          * or something.  Snooze for a couple msecs, then
4195          * chk-status again.  If still busy, queue delayed work.
4196          */
4197         status = ata_busy_wait(ap, ATA_BUSY, 5);
4198         if (status & ATA_BUSY) {
4199                 msleep(2);
4200                 status = ata_busy_wait(ap, ATA_BUSY, 10);
4201                 if (status & ATA_BUSY) {
4202                         ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE);
4203                         return;
4204                 }
4205         }
4206
4207         /* move the HSM */
4208         poll_next = ata_hsm_move(ap, qc, status, 1);
4209
4210         /* another command or interrupt handler
4211          * may be running at this point.
4212          */
4213         if (poll_next)
4214                 goto fsm_start;
4215 }
4216
4217 /**
4218  *      ata_qc_new - Request an available ATA command, for queueing
4219  *      @ap: Port associated with device @dev
4220  *      @dev: Device from whom we request an available command structure
4221  *
4222  *      LOCKING:
4223  *      None.
4224  */
4225
4226 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
4227 {
4228         struct ata_queued_cmd *qc = NULL;
4229         unsigned int i;
4230
4231         /* no command while frozen */
4232         if (unlikely(ap->flags & ATA_FLAG_FROZEN))
4233                 return NULL;
4234
4235         /* the last tag is reserved for internal command. */
4236         for (i = 0; i < ATA_MAX_QUEUE - 1; i++)
4237                 if (!test_and_set_bit(i, &ap->qc_allocated)) {
4238                         qc = __ata_qc_from_tag(ap, i);
4239                         break;
4240                 }
4241
4242         if (qc)
4243                 qc->tag = i;
4244
4245         return qc;
4246 }
4247
4248 /**
4249  *      ata_qc_new_init - Request an available ATA command, and initialize it
4250  *      @dev: Device from whom we request an available command structure
4251  *
4252  *      LOCKING:
4253  *      None.
4254  */
4255
4256 struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
4257 {
4258         struct ata_port *ap = dev->ap;
4259         struct ata_queued_cmd *qc;
4260
4261         qc = ata_qc_new(ap);
4262         if (qc) {
4263                 qc->scsicmd = NULL;
4264                 qc->ap = ap;
4265                 qc->dev = dev;
4266
4267                 ata_qc_reinit(qc);
4268         }
4269
4270         return qc;
4271 }
4272
4273 /**
4274  *      ata_qc_free - free unused ata_queued_cmd
4275  *      @qc: Command to complete
4276  *
4277  *      Designed to free unused ata_queued_cmd object
4278  *      in case something prevents using it.
4279  *
4280  *      LOCKING:
4281  *      spin_lock_irqsave(host_set lock)
4282  */
4283 void ata_qc_free(struct ata_queued_cmd *qc)
4284 {
4285         struct ata_port *ap = qc->ap;
4286         unsigned int tag;
4287
4288         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
4289
4290         qc->flags = 0;
4291         tag = qc->tag;
4292         if (likely(ata_tag_valid(tag))) {
4293                 qc->tag = ATA_TAG_POISON;
4294                 clear_bit(tag, &ap->qc_allocated);
4295         }
4296 }
4297
4298 void __ata_qc_complete(struct ata_queued_cmd *qc)
4299 {
4300         struct ata_port *ap = qc->ap;
4301
4302         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
4303         WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
4304
4305         if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4306                 ata_sg_clean(qc);
4307
4308         /* command should be marked inactive atomically with qc completion */
4309         if (qc->tf.protocol == ATA_PROT_NCQ)
4310                 ap->sactive &= ~(1 << qc->tag);
4311         else
4312                 ap->active_tag = ATA_TAG_POISON;
4313
4314         /* atapi: mark qc as inactive to prevent the interrupt handler
4315          * from completing the command twice later, before the error handler
4316          * is called. (when rc != 0 and atapi request sense is needed)
4317          */
4318         qc->flags &= ~ATA_QCFLAG_ACTIVE;
4319         ap->qc_active &= ~(1 << qc->tag);
4320
4321         /* call completion callback */
4322         qc->complete_fn(qc);
4323 }
4324
4325 /**
4326  *      ata_qc_complete - Complete an active ATA command
4327  *      @qc: Command to complete
4328  *      @err_mask: ATA Status register contents
4329  *
4330  *      Indicate to the mid and upper layers that an ATA
4331  *      command has completed, with either an ok or not-ok status.
4332  *
4333  *      LOCKING:
4334  *      spin_lock_irqsave(host_set lock)
4335  */
4336 void ata_qc_complete(struct ata_queued_cmd *qc)
4337 {
4338         struct ata_port *ap = qc->ap;
4339
4340         /* XXX: New EH and old EH use different mechanisms to
4341          * synchronize EH with regular execution path.
4342          *
4343          * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
4344          * Normal execution path is responsible for not accessing a
4345          * failed qc.  libata core enforces the rule by returning NULL
4346          * from ata_qc_from_tag() for failed qcs.
4347          *
4348          * Old EH depends on ata_qc_complete() nullifying completion
4349          * requests if ATA_QCFLAG_EH_SCHEDULED is set.  Old EH does
4350          * not synchronize with interrupt handler.  Only PIO task is
4351          * taken care of.
4352          */
4353         if (ap->ops->error_handler) {
4354                 WARN_ON(ap->flags & ATA_FLAG_FROZEN);
4355
4356                 if (unlikely(qc->err_mask))
4357                         qc->flags |= ATA_QCFLAG_FAILED;
4358
4359                 if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
4360                         if (!ata_tag_internal(qc->tag)) {
4361                                 /* always fill result TF for failed qc */
4362                                 ap->ops->tf_read(ap, &qc->result_tf);
4363                                 ata_qc_schedule_eh(qc);
4364                                 return;
4365                         }
4366                 }
4367
4368                 /* read result TF if requested */
4369                 if (qc->flags & ATA_QCFLAG_RESULT_TF)
4370                         ap->ops->tf_read(ap, &qc->result_tf);
4371
4372                 __ata_qc_complete(qc);
4373         } else {
4374                 if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
4375                         return;
4376
4377                 /* read result TF if failed or requested */
4378                 if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
4379                         ap->ops->tf_read(ap, &qc->result_tf);
4380
4381                 __ata_qc_complete(qc);
4382         }
4383 }
4384
4385 /**
4386  *      ata_qc_complete_multiple - Complete multiple qcs successfully
4387  *      @ap: port in question
4388  *      @qc_active: new qc_active mask
4389  *      @finish_qc: LLDD callback invoked before completing a qc
4390  *
4391  *      Complete in-flight commands.  This functions is meant to be
4392  *      called from low-level driver's interrupt routine to complete
4393  *      requests normally.  ap->qc_active and @qc_active is compared
4394  *      and commands are completed accordingly.
4395  *
4396  *      LOCKING:
4397  *      spin_lock_irqsave(host_set lock)
4398  *
4399  *      RETURNS:
4400  *      Number of completed commands on success, -errno otherwise.
4401  */
4402 int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
4403                              void (*finish_qc)(struct ata_queued_cmd *))
4404 {
4405         int nr_done = 0;
4406         u32 done_mask;
4407         int i;
4408
4409         done_mask = ap->qc_active ^ qc_active;
4410
4411         if (unlikely(done_mask & qc_active)) {
4412                 ata_port_printk(ap, KERN_ERR, "illegal qc_active transition "
4413                                 "(%08x->%08x)\n", ap->qc_active, qc_active);
4414                 return -EINVAL;
4415         }
4416
4417         for (i = 0; i < ATA_MAX_QUEUE; i++) {
4418                 struct ata_queued_cmd *qc;
4419
4420                 if (!(done_mask & (1 << i)))
4421                         continue;
4422
4423                 if ((qc = ata_qc_from_tag(ap, i))) {
4424                         if (finish_qc)
4425                                 finish_qc(qc);
4426                         ata_qc_complete(qc);
4427                         nr_done++;
4428                 }
4429         }
4430
4431         return nr_done;
4432 }
4433
4434 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
4435 {
4436         struct ata_port *ap = qc->ap;
4437
4438         switch (qc->tf.protocol) {
4439         case ATA_PROT_NCQ:
4440         case ATA_PROT_DMA:
4441         case ATA_PROT_ATAPI_DMA:
4442                 return 1;
4443
4444         case ATA_PROT_ATAPI:
4445         case ATA_PROT_PIO:
4446                 if (ap->flags & ATA_FLAG_PIO_DMA)
4447                         return 1;
4448
4449                 /* fall through */
4450
4451         default:
4452                 return 0;
4453         }
4454
4455         /* never reached */
4456 }
4457
4458 /**
4459  *      ata_qc_issue - issue taskfile to device
4460  *      @qc: command to issue to device
4461  *
4462  *      Prepare an ATA command to submission to device.
4463  *      This includes mapping the data into a DMA-able
4464  *      area, filling in the S/G table, and finally
4465  *      writing the taskfile to hardware, starting the command.
4466  *
4467  *      LOCKING:
4468  *      spin_lock_irqsave(host_set lock)
4469  */
4470 void ata_qc_issue(struct ata_queued_cmd *qc)
4471 {
4472         struct ata_port *ap = qc->ap;
4473
4474         /* Make sure only one non-NCQ command is outstanding.  The
4475          * check is skipped for old EH because it reuses active qc to
4476          * request ATAPI sense.
4477          */
4478         WARN_ON(ap->ops->error_handler && ata_tag_valid(ap->active_tag));
4479
4480         if (qc->tf.protocol == ATA_PROT_NCQ) {
4481                 WARN_ON(ap->sactive & (1 << qc->tag));
4482                 ap->sactive |= 1 << qc->tag;
4483         } else {
4484                 WARN_ON(ap->sactive);
4485                 ap->active_tag = qc->tag;
4486         }
4487
4488         qc->flags |= ATA_QCFLAG_ACTIVE;
4489         ap->qc_active |= 1 << qc->tag;
4490
4491         if (ata_should_dma_map(qc)) {
4492                 if (qc->flags & ATA_QCFLAG_SG) {
4493                         if (ata_sg_setup(qc))
4494                                 goto sg_err;
4495                 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4496                         if (ata_sg_setup_one(qc))
4497                                 goto sg_err;
4498                 }
4499         } else {
4500                 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4501         }
4502
4503         ap->ops->qc_prep(qc);
4504
4505         qc->err_mask |= ap->ops->qc_issue(qc);
4506         if (unlikely(qc->err_mask))
4507                 goto err;
4508         return;
4509
4510 sg_err:
4511         qc->flags &= ~ATA_QCFLAG_DMAMAP;
4512         qc->err_mask |= AC_ERR_SYSTEM;
4513 err:
4514         ata_qc_complete(qc);
4515 }
4516
4517 /**
4518  *      ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4519  *      @qc: command to issue to device
4520  *
4521  *      Using various libata functions and hooks, this function
4522  *      starts an ATA command.  ATA commands are grouped into
4523  *      classes called "protocols", and issuing each type of protocol
4524  *      is slightly different.
4525  *
4526  *      May be used as the qc_issue() entry in ata_port_operations.
4527  *
4528  *      LOCKING:
4529  *      spin_lock_irqsave(host_set lock)
4530  *
4531  *      RETURNS:
4532  *      Zero on success, AC_ERR_* mask on failure
4533  */
4534
4535 unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
4536 {
4537         struct ata_port *ap = qc->ap;
4538
4539         /* Use polling pio if the LLD doesn't handle
4540          * interrupt driven pio and atapi CDB interrupt.
4541          */
4542         if (ap->flags & ATA_FLAG_PIO_POLLING) {
4543                 switch (qc->tf.protocol) {
4544                 case ATA_PROT_PIO:
4545                 case ATA_PROT_ATAPI:
4546                 case ATA_PROT_ATAPI_NODATA:
4547                         qc->tf.flags |= ATA_TFLAG_POLLING;
4548                         break;
4549                 case ATA_PROT_ATAPI_DMA:
4550                         if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
4551                                 /* see ata_check_atapi_dma() */
4552                                 BUG();
4553                         break;
4554                 default:
4555                         break;
4556                 }
4557         }
4558
4559         /* select the device */
4560         ata_dev_select(ap, qc->dev->devno, 1, 0);
4561
4562         /* start the command */
4563         switch (qc->tf.protocol) {
4564         case ATA_PROT_NODATA:
4565                 if (qc->tf.flags & ATA_TFLAG_POLLING)
4566                         ata_qc_set_polling(qc);
4567
4568                 ata_tf_to_host(ap, &qc->tf);
4569                 ap->hsm_task_state = HSM_ST_LAST;
4570
4571                 if (qc->tf.flags & ATA_TFLAG_POLLING)
4572                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
4573
4574                 break;
4575
4576         case ATA_PROT_DMA:
4577                 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
4578
4579                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
4580                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
4581                 ap->ops->bmdma_start(qc);           /* initiate bmdma */
4582                 ap->hsm_task_state = HSM_ST_LAST;
4583                 break;
4584
4585         case ATA_PROT_PIO:
4586                 if (qc->tf.flags & ATA_TFLAG_POLLING)
4587                         ata_qc_set_polling(qc);
4588
4589                 ata_tf_to_host(ap, &qc->tf);
4590
4591                 if (qc->tf.flags & ATA_TFLAG_WRITE) {
4592                         /* PIO data out protocol */
4593                         ap->hsm_task_state = HSM_ST_FIRST;
4594                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
4595
4596                         /* always send first data block using
4597                          * the ata_pio_task() codepath.
4598                          */
4599                 } else {
4600                         /* PIO data in protocol */
4601                         ap->hsm_task_state = HSM_ST;
4602
4603                         if (qc->tf.flags & ATA_TFLAG_POLLING)
4604                                 ata_port_queue_task(ap, ata_pio_task, qc, 0);
4605
4606                         /* if polling, ata_pio_task() handles the rest.
4607                          * otherwise, interrupt handler takes over from here.
4608                          */
4609                 }
4610
4611                 break;
4612
4613         case ATA_PROT_ATAPI:
4614         case ATA_PROT_ATAPI_NODATA:
4615                 if (qc->tf.flags & ATA_TFLAG_POLLING)
4616                         ata_qc_set_polling(qc);
4617
4618                 ata_tf_to_host(ap, &qc->tf);
4619
4620                 ap->hsm_task_state = HSM_ST_FIRST;
4621
4622                 /* send cdb by polling if no cdb interrupt */
4623                 if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
4624                     (qc->tf.flags & ATA_TFLAG_POLLING))
4625                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
4626                 break;
4627
4628         case ATA_PROT_ATAPI_DMA:
4629                 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
4630
4631                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
4632                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
4633                 ap->hsm_task_state = HSM_ST_FIRST;
4634
4635                 /* send cdb by polling if no cdb interrupt */
4636                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
4637                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
4638                 break;
4639
4640         default:
4641                 WARN_ON(1);
4642                 return AC_ERR_SYSTEM;
4643         }
4644
4645         return 0;
4646 }
4647
4648 /**
4649  *      ata_host_intr - Handle host interrupt for given (port, task)
4650  *      @ap: Port on which interrupt arrived (possibly...)
4651  *      @qc: Taskfile currently active in engine
4652  *
4653  *      Handle host interrupt for given queued command.  Currently,
4654  *      only DMA interrupts are handled.  All other commands are
4655  *      handled via polling with interrupts disabled (nIEN bit).
4656  *
4657  *      LOCKING:
4658  *      spin_lock_irqsave(host_set lock)
4659  *
4660  *      RETURNS:
4661  *      One if interrupt was handled, zero if not (shared irq).
4662  */
4663
4664 inline unsigned int ata_host_intr (struct ata_port *ap,
4665                                    struct ata_queued_cmd *qc)
4666 {
4667         u8 status, host_stat = 0;
4668
4669         VPRINTK("ata%u: protocol %d task_state %d\n",
4670                 ap->id, qc->tf.protocol, ap->hsm_task_state);
4671
4672         /* Check whether we are expecting interrupt in this state */
4673         switch (ap->hsm_task_state) {
4674         case HSM_ST_FIRST:
4675                 /* Some pre-ATAPI-4 devices assert INTRQ
4676                  * at this state when ready to receive CDB.
4677                  */
4678
4679                 /* Check the ATA_DFLAG_CDB_INTR flag is enough here.
4680                  * The flag was turned on only for atapi devices.
4681                  * No need to check is_atapi_taskfile(&qc->tf) again.
4682                  */
4683                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
4684                         goto idle_irq;
4685                 break;
4686         case HSM_ST_LAST:
4687                 if (qc->tf.protocol == ATA_PROT_DMA ||
4688                     qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
4689                         /* check status of DMA engine */
4690                         host_stat = ap->ops->bmdma_status(ap);
4691                         VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
4692
4693                         /* if it's not our irq... */
4694                         if (!(host_stat & ATA_DMA_INTR))
4695                                 goto idle_irq;
4696
4697                         /* before we do anything else, clear DMA-Start bit */
4698                         ap->ops->bmdma_stop(qc);
4699
4700                         if (unlikely(host_stat & ATA_DMA_ERR)) {
4701                                 /* error when transfering data to/from memory */
4702                                 qc->err_mask |= AC_ERR_HOST_BUS;
4703                                 ap->hsm_task_state = HSM_ST_ERR;
4704                         }
4705                 }
4706                 break;
4707         case HSM_ST:
4708                 break;
4709         default:
4710                 goto idle_irq;
4711         }
4712
4713         /* check altstatus */
4714         status = ata_altstatus(ap);
4715         if (status & ATA_BUSY)
4716                 goto idle_irq;
4717
4718         /* check main status, clearing INTRQ */
4719         status = ata_chk_status(ap);
4720         if (unlikely(status & ATA_BUSY))
4721                 goto idle_irq;
4722
4723         /* ack bmdma irq events */
4724         ap->ops->irq_clear(ap);
4725
4726         ata_hsm_move(ap, qc, status, 0);
4727         return 1;       /* irq handled */
4728
4729 idle_irq:
4730         ap->stats.idle_irq++;
4731
4732 #ifdef ATA_IRQ_TRAP
4733         if ((ap->stats.idle_irq % 1000) == 0) {
4734                 ata_irq_ack(ap, 0); /* debug trap */
4735                 ata_port_printk(ap, KERN_WARNING, "irq trap\n");
4736                 return 1;
4737         }
4738 #endif
4739         return 0;       /* irq not handled */
4740 }
4741
4742 /**
4743  *      ata_interrupt - Default ATA host interrupt handler
4744  *      @irq: irq line (unused)
4745  *      @dev_instance: pointer to our ata_host_set information structure
4746  *      @regs: unused
4747  *
4748  *      Default interrupt handler for PCI IDE devices.  Calls
4749  *      ata_host_intr() for each port that is not disabled.
4750  *
4751  *      LOCKING:
4752  *      Obtains host_set lock during operation.
4753  *
4754  *      RETURNS:
4755  *      IRQ_NONE or IRQ_HANDLED.
4756  */
4757
4758 irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
4759 {
4760         struct ata_host_set *host_set = dev_instance;
4761         unsigned int i;
4762         unsigned int handled = 0;
4763         unsigned long flags;
4764
4765         /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
4766         spin_lock_irqsave(&host_set->lock, flags);
4767
4768         for (i = 0; i < host_set->n_ports; i++) {
4769                 struct ata_port *ap;
4770
4771                 ap = host_set->ports[i];
4772                 if (ap &&
4773                     !(ap->flags & ATA_FLAG_DISABLED)) {
4774                         struct ata_queued_cmd *qc;
4775
4776                         qc = ata_qc_from_tag(ap, ap->active_tag);
4777                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
4778                             (qc->flags & ATA_QCFLAG_ACTIVE))
4779                                 handled |= ata_host_intr(ap, qc);
4780                 }
4781         }
4782
4783         spin_unlock_irqrestore(&host_set->lock, flags);
4784
4785         return IRQ_RETVAL(handled);
4786 }
4787
4788 /**
4789  *      sata_scr_valid - test whether SCRs are accessible
4790  *      @ap: ATA port to test SCR accessibility for
4791  *
4792  *      Test whether SCRs are accessible for @ap.
4793  *
4794  *      LOCKING:
4795  *      None.
4796  *
4797  *      RETURNS:
4798  *      1 if SCRs are accessible, 0 otherwise.
4799  */
4800 int sata_scr_valid(struct ata_port *ap)
4801 {
4802         return ap->cbl == ATA_CBL_SATA && ap->ops->scr_read;
4803 }
4804
4805 /**
4806  *      sata_scr_read - read SCR register of the specified port
4807  *      @ap: ATA port to read SCR for
4808  *      @reg: SCR to read
4809  *      @val: Place to store read value
4810  *
4811  *      Read SCR register @reg of @ap into *@val.  This function is
4812  *      guaranteed to succeed if the cable type of the port is SATA
4813  *      and the port implements ->scr_read.
4814  *
4815  *      LOCKING:
4816  *      None.
4817  *
4818  *      RETURNS:
4819  *      0 on success, negative errno on failure.
4820  */
4821 int sata_scr_read(struct ata_port *ap, int reg, u32 *val)
4822 {
4823         if (sata_scr_valid(ap)) {
4824                 *val = ap->ops->scr_read(ap, reg);
4825                 return 0;
4826         }
4827         return -EOPNOTSUPP;
4828 }
4829
4830 /**
4831  *      sata_scr_write - write SCR register of the specified port
4832  *      @ap: ATA port to write SCR for
4833  *      @reg: SCR to write
4834  *      @val: value to write
4835  *
4836  *      Write @val to SCR register @reg of @ap.  This function is
4837  *      guaranteed to succeed if the cable type of the port is SATA
4838  *      and the port implements ->scr_read.
4839  *
4840  *      LOCKING:
4841  *      None.
4842  *
4843  *      RETURNS:
4844  *      0 on success, negative errno on failure.
4845  */
4846 int sata_scr_write(struct ata_port *ap, int reg, u32 val)
4847 {
4848         if (sata_scr_valid(ap)) {
4849                 ap->ops->scr_write(ap, reg, val);
4850                 return 0;
4851         }
4852         return -EOPNOTSUPP;
4853 }
4854
4855 /**
4856  *      sata_scr_write_flush - write SCR register of the specified port and flush
4857  *      @ap: ATA port to write SCR for
4858  *      @reg: SCR to write
4859  *      @val: value to write
4860  *
4861  *      This function is identical to sata_scr_write() except that this
4862  *      function performs flush after writing to the register.
4863  *
4864  *      LOCKING:
4865  *      None.
4866  *
4867  *      RETURNS:
4868  *      0 on success, negative errno on failure.
4869  */
4870 int sata_scr_write_flush(struct ata_port *ap, int reg, u32 val)
4871 {
4872         if (sata_scr_valid(ap)) {
4873                 ap->ops->scr_write(ap, reg, val);
4874                 ap->ops->scr_read(ap, reg);
4875                 return 0;
4876         }
4877         return -EOPNOTSUPP;
4878 }
4879
4880 /**
4881  *      ata_port_online - test whether the given port is online
4882  *      @ap: ATA port to test
4883  *
4884  *      Test whether @ap is online.  Note that this function returns 0
4885  *      if online status of @ap cannot be obtained, so
4886  *      ata_port_online(ap) != !ata_port_offline(ap).
4887  *
4888  *      LOCKING:
4889  *      None.
4890  *
4891  *      RETURNS:
4892  *      1 if the port online status is available and online.
4893  */
4894 int ata_port_online(struct ata_port *ap)
4895 {
4896         u32 sstatus;
4897
4898         if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) == 0x3)
4899                 return 1;
4900         return 0;
4901 }
4902
4903 /**
4904  *      ata_port_offline - test whether the given port is offline
4905  *      @ap: ATA port to test
4906  *
4907  *      Test whether @ap is offline.  Note that this function returns
4908  *      0 if offline status of @ap cannot be obtained, so
4909  *      ata_port_online(ap) != !ata_port_offline(ap).
4910  *
4911  *      LOCKING:
4912  *      None.
4913  *
4914  *      RETURNS:
4915  *      1 if the port offline status is available and offline.
4916  */
4917 int ata_port_offline(struct ata_port *ap)
4918 {
4919         u32 sstatus;
4920
4921         if (!sata_scr_read(ap, SCR_STATUS, &sstatus) && (sstatus & 0xf) != 0x3)
4922                 return 1;
4923         return 0;
4924 }
4925
4926 /*
4927  * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
4928  * without filling any other registers
4929  */
4930 static int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
4931 {
4932         struct ata_taskfile tf;
4933         int err;
4934
4935         ata_tf_init(dev, &tf);
4936
4937         tf.command = cmd;
4938         tf.flags |= ATA_TFLAG_DEVICE;
4939         tf.protocol = ATA_PROT_NODATA;
4940
4941         err = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0);
4942         if (err)
4943                 ata_dev_printk(dev, KERN_ERR, "%s: ata command failed: %d\n",
4944                                __FUNCTION__, err);
4945
4946         return err;
4947 }
4948
4949 static int ata_flush_cache(struct ata_device *dev)
4950 {
4951         u8 cmd;
4952
4953         if (!ata_try_flush_cache(dev))
4954                 return 0;
4955
4956         if (ata_id_has_flush_ext(dev->id))
4957                 cmd = ATA_CMD_FLUSH_EXT;
4958         else
4959                 cmd = ATA_CMD_FLUSH;
4960
4961         return ata_do_simple_cmd(dev, cmd);
4962 }
4963
4964 static int ata_standby_drive(struct ata_device *dev)
4965 {
4966         return ata_do_simple_cmd(dev, ATA_CMD_STANDBYNOW1);
4967 }
4968
4969 static int ata_start_drive(struct ata_device *dev)
4970 {
4971         return ata_do_simple_cmd(dev, ATA_CMD_IDLEIMMEDIATE);
4972 }
4973
4974 /**
4975  *      ata_device_resume - wakeup a previously suspended devices
4976  *      @dev: the device to resume
4977  *
4978  *      Kick the drive back into action, by sending it an idle immediate
4979  *      command and making sure its transfer mode matches between drive
4980  *      and host.
4981  *
4982  */
4983 int ata_device_resume(struct ata_device *dev)
4984 {
4985         struct ata_port *ap = dev->ap;
4986
4987         if (ap->flags & ATA_FLAG_SUSPENDED) {
4988                 struct ata_device *failed_dev;
4989
4990                 ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 200000);
4991
4992                 ap->flags &= ~ATA_FLAG_SUSPENDED;
4993                 while (ata_set_mode(ap, &failed_dev))
4994                         ata_dev_disable(failed_dev);
4995         }
4996         if (!ata_dev_enabled(dev))
4997                 return 0;
4998         if (dev->class == ATA_DEV_ATA)
4999                 ata_start_drive(dev);
5000
5001         return 0;
5002 }
5003
5004 /**
5005  *      ata_device_suspend - prepare a device for suspend
5006  *      @dev: the device to suspend
5007  *      @state: target power management state
5008  *
5009  *      Flush the cache on the drive, if appropriate, then issue a
5010  *      standbynow command.
5011  */
5012 int ata_device_suspend(struct ata_device *dev, pm_message_t state)
5013 {
5014         struct ata_port *ap = dev->ap;
5015
5016         if (!ata_dev_enabled(dev))
5017                 return 0;
5018         if (dev->class == ATA_DEV_ATA)
5019                 ata_flush_cache(dev);
5020
5021         if (state.event != PM_EVENT_FREEZE)
5022                 ata_standby_drive(dev);
5023         ap->flags |= ATA_FLAG_SUSPENDED;
5024         return 0;
5025 }
5026
5027 /**
5028  *      ata_port_start - Set port up for dma.
5029  *      @ap: Port to initialize
5030  *
5031  *      Called just after data structures for each port are
5032  *      initialized.  Allocates space for PRD table.
5033  *
5034  *      May be used as the port_start() entry in ata_port_operations.
5035  *
5036  *      LOCKING:
5037  *      Inherited from caller.
5038  */
5039
5040 int ata_port_start (struct ata_port *ap)
5041 {
5042         struct device *dev = ap->dev;
5043         int rc;
5044
5045         ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
5046         if (!ap->prd)
5047                 return -ENOMEM;
5048
5049         rc = ata_pad_alloc(ap, dev);
5050         if (rc) {
5051                 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
5052                 return rc;
5053         }
5054
5055         DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
5056
5057         return 0;
5058 }
5059
5060
5061 /**
5062  *      ata_port_stop - Undo ata_port_start()
5063  *      @ap: Port to shut down
5064  *
5065  *      Frees the PRD table.
5066  *
5067  *      May be used as the port_stop() entry in ata_port_operations.
5068  *
5069  *      LOCKING:
5070  *      Inherited from caller.
5071  */
5072
5073 void ata_port_stop (struct ata_port *ap)
5074 {
5075         struct device *dev = ap->dev;
5076
5077         dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
5078         ata_pad_free(ap, dev);
5079 }
5080
5081 void ata_host_stop (struct ata_host_set *host_set)
5082 {
5083         if (host_set->mmio_base)
5084                 iounmap(host_set->mmio_base);
5085 }
5086
5087
5088 /**
5089  *      ata_host_remove - Unregister SCSI host structure with upper layers
5090  *      @ap: Port to unregister
5091  *      @do_unregister: 1 if we fully unregister, 0 to just stop the port
5092  *
5093  *      LOCKING:
5094  *      Inherited from caller.
5095  */
5096
5097 static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
5098 {
5099         struct Scsi_Host *sh = ap->host;
5100
5101         DPRINTK("ENTER\n");
5102
5103         if (do_unregister)
5104                 scsi_remove_host(sh);
5105
5106         ap->ops->port_stop(ap);
5107 }
5108
5109 /**
5110  *      ata_dev_init - Initialize an ata_device structure
5111  *      @dev: Device structure to initialize
5112  *
5113  *      Initialize @dev in preparation for probing.
5114  *
5115  *      LOCKING:
5116  *      Inherited from caller.
5117  */
5118 void ata_dev_init(struct ata_device *dev)
5119 {
5120         struct ata_port *ap = dev->ap;
5121         unsigned long flags;
5122
5123         /* SATA spd limit is bound to the first device */
5124         ap->sata_spd_limit = ap->hw_sata_spd_limit;
5125
5126         /* High bits of dev->flags are used to record warm plug
5127          * requests which occur asynchronously.  Synchronize using
5128          * host_set lock.
5129          */
5130         spin_lock_irqsave(&ap->host_set->lock, flags);
5131         dev->flags &= ~ATA_DFLAG_INIT_MASK;
5132         spin_unlock_irqrestore(&ap->host_set->lock, flags);
5133
5134         memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0,
5135                sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET);
5136         dev->pio_mask = UINT_MAX;
5137         dev->mwdma_mask = UINT_MAX;
5138         dev->udma_mask = UINT_MAX;
5139 }
5140
5141 /**
5142  *      ata_host_init - Initialize an ata_port structure
5143  *      @ap: Structure to initialize
5144  *      @host: associated SCSI mid-layer structure
5145  *      @host_set: Collection of hosts to which @ap belongs
5146  *      @ent: Probe information provided by low-level driver
5147  *      @port_no: Port number associated with this ata_port
5148  *
5149  *      Initialize a new ata_port structure, and its associated
5150  *      scsi_host.
5151  *
5152  *      LOCKING:
5153  *      Inherited from caller.
5154  */
5155 static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
5156                           struct ata_host_set *host_set,
5157                           const struct ata_probe_ent *ent, unsigned int port_no)
5158 {
5159         unsigned int i;
5160
5161         host->max_id = 16;
5162         host->max_lun = 1;
5163         host->max_channel = 1;
5164         host->unique_id = ata_unique_id++;
5165         host->max_cmd_len = 12;
5166
5167         ap->flags = ATA_FLAG_DISABLED;
5168         ap->id = host->unique_id;
5169         ap->host = host;
5170         ap->ctl = ATA_DEVCTL_OBS;
5171         ap->host_set = host_set;
5172         ap->dev = ent->dev;
5173         ap->port_no = port_no;
5174         ap->hard_port_no =
5175                 ent->legacy_mode ? ent->hard_port_no : port_no;
5176         ap->pio_mask = ent->pio_mask;
5177         ap->mwdma_mask = ent->mwdma_mask;
5178         ap->udma_mask = ent->udma_mask;
5179         ap->flags |= ent->host_flags;
5180         ap->ops = ent->port_ops;
5181         ap->hw_sata_spd_limit = UINT_MAX;
5182         ap->active_tag = ATA_TAG_POISON;
5183         ap->last_ctl = 0xFF;
5184
5185 #if defined(ATA_VERBOSE_DEBUG)
5186         /* turn on all debugging levels */
5187         ap->msg_enable = 0x00FF;
5188 #elif defined(ATA_DEBUG)
5189         ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
5190 #else
5191         ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR;
5192 #endif
5193
5194         INIT_WORK(&ap->port_task, NULL, NULL);
5195         INIT_WORK(&ap->hotplug_task, ata_scsi_hotplug, ap);
5196         INIT_LIST_HEAD(&ap->eh_done_q);
5197         init_waitqueue_head(&ap->eh_wait_q);
5198
5199         /* set cable type */
5200         ap->cbl = ATA_CBL_NONE;
5201         if (ap->flags & ATA_FLAG_SATA)
5202                 ap->cbl = ATA_CBL_SATA;
5203
5204         for (i = 0; i < ATA_MAX_DEVICES; i++) {
5205                 struct ata_device *dev = &ap->device[i];
5206                 dev->ap = ap;
5207                 dev->devno = i;
5208                 ata_dev_init(dev);
5209         }
5210
5211 #ifdef ATA_IRQ_TRAP
5212         ap->stats.unhandled_irq = 1;
5213         ap->stats.idle_irq = 1;
5214 #endif
5215
5216         memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
5217 }
5218
5219 /**
5220  *      ata_host_add - Attach low-level ATA driver to system
5221  *      @ent: Information provided by low-level driver
5222  *      @host_set: Collections of ports to which we add
5223  *      @port_no: Port number associated with this host
5224  *
5225  *      Attach low-level ATA driver to system.
5226  *
5227  *      LOCKING:
5228  *      PCI/etc. bus probe sem.
5229  *
5230  *      RETURNS:
5231  *      New ata_port on success, for NULL on error.
5232  */
5233
5234 static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
5235                                       struct ata_host_set *host_set,
5236                                       unsigned int port_no)
5237 {
5238         struct Scsi_Host *host;
5239         struct ata_port *ap;
5240         int rc;
5241
5242         DPRINTK("ENTER\n");
5243
5244         if (!ent->port_ops->error_handler &&
5245             !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
5246                 printk(KERN_ERR "ata%u: no reset mechanism available\n",
5247                        port_no);
5248                 return NULL;
5249         }
5250
5251         host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
5252         if (!host)
5253                 return NULL;
5254
5255         host->transportt = &ata_scsi_transport_template;
5256
5257         ap = ata_shost_to_port(host);
5258
5259         ata_host_init(ap, host, host_set, ent, port_no);
5260
5261         rc = ap->ops->port_start(ap);
5262         if (rc)
5263                 goto err_out;
5264
5265         return ap;
5266
5267 err_out:
5268         scsi_host_put(host);
5269         return NULL;
5270 }
5271
5272 /**
5273  *      ata_device_add - Register hardware device with ATA and SCSI layers
5274  *      @ent: Probe information describing hardware device to be registered
5275  *
5276  *      This function processes the information provided in the probe
5277  *      information struct @ent, allocates the necessary ATA and SCSI
5278  *      host information structures, initializes them, and registers
5279  *      everything with requisite kernel subsystems.
5280  *
5281  *      This function requests irqs, probes the ATA bus, and probes
5282  *      the SCSI bus.
5283  *
5284  *      LOCKING:
5285  *      PCI/etc. bus probe sem.
5286  *
5287  *      RETURNS:
5288  *      Number of ports registered.  Zero on error (no ports registered).
5289  */
5290 int ata_device_add(const struct ata_probe_ent *ent)
5291 {
5292         unsigned int count = 0, i;
5293         struct device *dev = ent->dev;
5294         struct ata_host_set *host_set;
5295
5296         DPRINTK("ENTER\n");
5297         /* alloc a container for our list of ATA ports (buses) */
5298         host_set = kzalloc(sizeof(struct ata_host_set) +
5299                            (ent->n_ports * sizeof(void *)), GFP_KERNEL);
5300         if (!host_set)
5301                 return 0;
5302         spin_lock_init(&host_set->lock);
5303
5304         host_set->dev = dev;
5305         host_set->n_ports = ent->n_ports;
5306         host_set->irq = ent->irq;
5307         host_set->mmio_base = ent->mmio_base;
5308         host_set->private_data = ent->private_data;
5309         host_set->ops = ent->port_ops;
5310         host_set->flags = ent->host_set_flags;
5311
5312         /* register each port bound to this device */
5313         for (i = 0; i < ent->n_ports; i++) {
5314                 struct ata_port *ap;
5315                 unsigned long xfer_mode_mask;
5316
5317                 ap = ata_host_add(ent, host_set, i);
5318                 if (!ap)
5319                         goto err_out;
5320
5321                 host_set->ports[i] = ap;
5322                 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
5323                                 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
5324                                 (ap->pio_mask << ATA_SHIFT_PIO);
5325
5326                 /* print per-port info to dmesg */
5327                 ata_port_printk(ap, KERN_INFO, "%cATA max %s cmd 0x%lX "
5328                                 "ctl 0x%lX bmdma 0x%lX irq %lu\n",
5329                                 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
5330                                 ata_mode_string(xfer_mode_mask),
5331                                 ap->ioaddr.cmd_addr,
5332                                 ap->ioaddr.ctl_addr,
5333                                 ap->ioaddr.bmdma_addr,
5334                                 ent->irq);
5335
5336                 ata_chk_status(ap);
5337                 host_set->ops->irq_clear(ap);
5338                 ata_eh_freeze_port(ap); /* freeze port before requesting IRQ */
5339                 count++;
5340         }
5341
5342         if (!count)
5343                 goto err_free_ret;
5344
5345         /* obtain irq, that is shared between channels */
5346         if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
5347                         DRV_NAME, host_set))
5348                 goto err_out;
5349
5350         /* perform each probe synchronously */
5351         DPRINTK("probe begin\n");
5352         for (i = 0; i < count; i++) {
5353                 struct ata_port *ap;
5354                 u32 scontrol;
5355                 int rc;
5356
5357                 ap = host_set->ports[i];
5358
5359                 /* init sata_spd_limit to the current value */
5360                 if (sata_scr_read(ap, SCR_CONTROL, &scontrol) == 0) {
5361                         int spd = (scontrol >> 4) & 0xf;
5362                         ap->hw_sata_spd_limit &= (1 << spd) - 1;
5363                 }
5364                 ap->sata_spd_limit = ap->hw_sata_spd_limit;
5365
5366                 rc = scsi_add_host(ap->host, dev);
5367                 if (rc) {
5368                         ata_port_printk(ap, KERN_ERR, "scsi_add_host failed\n");
5369                         /* FIXME: do something useful here */
5370                         /* FIXME: handle unconditional calls to
5371                          * scsi_scan_host and ata_host_remove, below,
5372                          * at the very least
5373                          */
5374                 }
5375
5376                 if (ap->ops->error_handler) {
5377                         unsigned long flags;
5378
5379                         ata_port_probe(ap);
5380
5381                         /* kick EH for boot probing */
5382                         spin_lock_irqsave(&ap->host_set->lock, flags);
5383
5384                         ap->eh_info.probe_mask = (1 << ATA_MAX_DEVICES) - 1;
5385                         ap->eh_info.action |= ATA_EH_SOFTRESET;
5386
5387                         ap->flags |= ATA_FLAG_LOADING;
5388                         ata_port_schedule_eh(ap);
5389
5390                         spin_unlock_irqrestore(&ap->host_set->lock, flags);
5391
5392                         /* wait for EH to finish */
5393                         ata_port_wait_eh(ap);
5394                 } else {
5395                         DPRINTK("ata%u: bus probe begin\n", ap->id);
5396                         rc = ata_bus_probe(ap);
5397                         DPRINTK("ata%u: bus probe end\n", ap->id);
5398
5399                         if (rc) {
5400                                 /* FIXME: do something useful here?
5401                                  * Current libata behavior will
5402                                  * tear down everything when
5403                                  * the module is removed
5404                                  * or the h/w is unplugged.
5405                                  */
5406                         }
5407                 }
5408         }
5409
5410         /* probes are done, now scan each port's disk(s) */
5411         DPRINTK("host probe begin\n");
5412         for (i = 0; i < count; i++) {
5413                 struct ata_port *ap = host_set->ports[i];
5414
5415                 ata_scsi_scan_host(ap);
5416         }
5417
5418         dev_set_drvdata(dev, host_set);
5419
5420         VPRINTK("EXIT, returning %u\n", ent->n_ports);
5421         return ent->n_ports; /* success */
5422
5423 err_out:
5424         for (i = 0; i < count; i++) {
5425                 ata_host_remove(host_set->ports[i], 1);
5426                 scsi_host_put(host_set->ports[i]->host);
5427         }
5428 err_free_ret:
5429         kfree(host_set);
5430         VPRINTK("EXIT, returning 0\n");
5431         return 0;
5432 }
5433
5434 /**
5435  *      ata_port_detach - Detach ATA port in prepration of device removal
5436  *      @ap: ATA port to be detached
5437  *
5438  *      Detach all ATA devices and the associated SCSI devices of @ap;
5439  *      then, remove the associated SCSI host.  @ap is guaranteed to
5440  *      be quiescent on return from this function.
5441  *
5442  *      LOCKING:
5443  *      Kernel thread context (may sleep).
5444  */
5445 void ata_port_detach(struct ata_port *ap)
5446 {
5447         unsigned long flags;
5448         int i;
5449
5450         if (!ap->ops->error_handler)
5451                 return;
5452
5453         /* tell EH we're leaving & flush EH */
5454         spin_lock_irqsave(&ap->host_set->lock, flags);
5455         ap->flags |= ATA_FLAG_UNLOADING;
5456         spin_unlock_irqrestore(&ap->host_set->lock, flags);
5457
5458         ata_port_wait_eh(ap);
5459
5460         /* EH is now guaranteed to see UNLOADING, so no new device
5461          * will be attached.  Disable all existing devices.
5462          */
5463         spin_lock_irqsave(&ap->host_set->lock, flags);
5464
5465         for (i = 0; i < ATA_MAX_DEVICES; i++)
5466                 ata_dev_disable(&ap->device[i]);
5467
5468         spin_unlock_irqrestore(&ap->host_set->lock, flags);
5469
5470         /* Final freeze & EH.  All in-flight commands are aborted.  EH
5471          * will be skipped and retrials will be terminated with bad
5472          * target.
5473          */
5474         spin_lock_irqsave(&ap->host_set->lock, flags);
5475         ata_port_freeze(ap);    /* won't be thawed */
5476         spin_unlock_irqrestore(&ap->host_set->lock, flags);
5477
5478         ata_port_wait_eh(ap);
5479
5480         /* Flush hotplug task.  The sequence is similar to
5481          * ata_port_flush_task().
5482          */
5483         flush_workqueue(ata_aux_wq);
5484         cancel_delayed_work(&ap->hotplug_task);
5485         flush_workqueue(ata_aux_wq);
5486
5487         /* remove the associated SCSI host */
5488         scsi_remove_host(ap->host);
5489 }
5490
5491 /**
5492  *      ata_host_set_remove - PCI layer callback for device removal
5493  *      @host_set: ATA host set that was removed
5494  *
5495  *      Unregister all objects associated with this host set. Free those
5496  *      objects.
5497  *
5498  *      LOCKING:
5499  *      Inherited from calling layer (may sleep).
5500  */
5501
5502 void ata_host_set_remove(struct ata_host_set *host_set)
5503 {
5504         unsigned int i;
5505
5506         for (i = 0; i < host_set->n_ports; i++)
5507                 ata_port_detach(host_set->ports[i]);
5508
5509         free_irq(host_set->irq, host_set);
5510
5511         for (i = 0; i < host_set->n_ports; i++) {
5512                 struct ata_port *ap = host_set->ports[i];
5513
5514                 ata_scsi_release(ap->host);
5515
5516                 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
5517                         struct ata_ioports *ioaddr = &ap->ioaddr;
5518
5519                         if (ioaddr->cmd_addr == 0x1f0)
5520                                 release_region(0x1f0, 8);
5521                         else if (ioaddr->cmd_addr == 0x170)
5522                                 release_region(0x170, 8);
5523                 }
5524
5525                 scsi_host_put(ap->host);
5526         }
5527
5528         if (host_set->ops->host_stop)
5529                 host_set->ops->host_stop(host_set);
5530
5531         kfree(host_set);
5532 }
5533
5534 /**
5535  *      ata_scsi_release - SCSI layer callback hook for host unload
5536  *      @host: libata host to be unloaded
5537  *
5538  *      Performs all duties necessary to shut down a libata port...
5539  *      Kill port kthread, disable port, and release resources.
5540  *
5541  *      LOCKING:
5542  *      Inherited from SCSI layer.
5543  *
5544  *      RETURNS:
5545  *      One.
5546  */
5547
5548 int ata_scsi_release(struct Scsi_Host *host)
5549 {
5550         struct ata_port *ap = ata_shost_to_port(host);
5551
5552         DPRINTK("ENTER\n");
5553
5554         ap->ops->port_disable(ap);
5555         ata_host_remove(ap, 0);
5556
5557         DPRINTK("EXIT\n");
5558         return 1;
5559 }
5560
5561 /**
5562  *      ata_std_ports - initialize ioaddr with standard port offsets.
5563  *      @ioaddr: IO address structure to be initialized
5564  *
5565  *      Utility function which initializes data_addr, error_addr,
5566  *      feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
5567  *      device_addr, status_addr, and command_addr to standard offsets
5568  *      relative to cmd_addr.
5569  *
5570  *      Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
5571  */
5572
5573 void ata_std_ports(struct ata_ioports *ioaddr)
5574 {
5575         ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
5576         ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
5577         ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
5578         ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
5579         ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
5580         ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
5581         ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
5582         ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
5583         ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
5584         ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
5585 }
5586
5587
5588 #ifdef CONFIG_PCI
5589
5590 void ata_pci_host_stop (struct ata_host_set *host_set)
5591 {
5592         struct pci_dev *pdev = to_pci_dev(host_set->dev);
5593
5594         pci_iounmap(pdev, host_set->mmio_base);
5595 }
5596
5597 /**
5598  *      ata_pci_remove_one - PCI layer callback for device removal
5599  *      @pdev: PCI device that was removed
5600  *
5601  *      PCI layer indicates to libata via this hook that
5602  *      hot-unplug or module unload event has occurred.
5603  *      Handle this by unregistering all objects associated
5604  *      with this PCI device.  Free those objects.  Then finally
5605  *      release PCI resources and disable device.
5606  *
5607  *      LOCKING:
5608  *      Inherited from PCI layer (may sleep).
5609  */
5610
5611 void ata_pci_remove_one (struct pci_dev *pdev)
5612 {
5613         struct device *dev = pci_dev_to_dev(pdev);
5614         struct ata_host_set *host_set = dev_get_drvdata(dev);
5615
5616         ata_host_set_remove(host_set);
5617         pci_release_regions(pdev);
5618         pci_disable_device(pdev);
5619         dev_set_drvdata(dev, NULL);
5620 }
5621
5622 /* move to PCI subsystem */
5623 int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
5624 {
5625         unsigned long tmp = 0;
5626
5627         switch (bits->width) {
5628         case 1: {
5629                 u8 tmp8 = 0;
5630                 pci_read_config_byte(pdev, bits->reg, &tmp8);
5631                 tmp = tmp8;
5632                 break;
5633         }
5634         case 2: {
5635                 u16 tmp16 = 0;
5636                 pci_read_config_word(pdev, bits->reg, &tmp16);
5637                 tmp = tmp16;
5638                 break;
5639         }
5640         case 4: {
5641                 u32 tmp32 = 0;
5642                 pci_read_config_dword(pdev, bits->reg, &tmp32);
5643                 tmp = tmp32;
5644                 break;
5645         }
5646
5647         default:
5648                 return -EINVAL;
5649         }
5650
5651         tmp &= bits->mask;
5652
5653         return (tmp == bits->val) ? 1 : 0;
5654 }
5655
5656 int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state)
5657 {
5658         pci_save_state(pdev);
5659         pci_disable_device(pdev);
5660         pci_set_power_state(pdev, PCI_D3hot);
5661         return 0;
5662 }
5663
5664 int ata_pci_device_resume(struct pci_dev *pdev)
5665 {
5666         pci_set_power_state(pdev, PCI_D0);
5667         pci_restore_state(pdev);
5668         pci_enable_device(pdev);
5669         pci_set_master(pdev);
5670         return 0;
5671 }
5672 #endif /* CONFIG_PCI */
5673
5674
5675 static int __init ata_init(void)
5676 {
5677         ata_wq = create_workqueue("ata");
5678         if (!ata_wq)
5679                 return -ENOMEM;
5680
5681         ata_aux_wq = create_singlethread_workqueue("ata_aux");
5682         if (!ata_aux_wq) {
5683                 destroy_workqueue(ata_wq);
5684                 return -ENOMEM;
5685         }
5686
5687         printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
5688         return 0;
5689 }
5690
5691 static void __exit ata_exit(void)
5692 {
5693         destroy_workqueue(ata_wq);
5694         destroy_workqueue(ata_aux_wq);
5695 }
5696
5697 module_init(ata_init);
5698 module_exit(ata_exit);
5699
5700 static unsigned long ratelimit_time;
5701 static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
5702
5703 int ata_ratelimit(void)
5704 {
5705         int rc;
5706         unsigned long flags;
5707
5708         spin_lock_irqsave(&ata_ratelimit_lock, flags);
5709
5710         if (time_after(jiffies, ratelimit_time)) {
5711                 rc = 1;
5712                 ratelimit_time = jiffies + (HZ/5);
5713         } else
5714                 rc = 0;
5715
5716         spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
5717
5718         return rc;
5719 }
5720
5721 /**
5722  *      ata_wait_register - wait until register value changes
5723  *      @reg: IO-mapped register
5724  *      @mask: Mask to apply to read register value
5725  *      @val: Wait condition
5726  *      @interval_msec: polling interval in milliseconds
5727  *      @timeout_msec: timeout in milliseconds
5728  *
5729  *      Waiting for some bits of register to change is a common
5730  *      operation for ATA controllers.  This function reads 32bit LE
5731  *      IO-mapped register @reg and tests for the following condition.
5732  *
5733  *      (*@reg & mask) != val
5734  *
5735  *      If the condition is met, it returns; otherwise, the process is
5736  *      repeated after @interval_msec until timeout.
5737  *
5738  *      LOCKING:
5739  *      Kernel thread context (may sleep)
5740  *
5741  *      RETURNS:
5742  *      The final register value.
5743  */
5744 u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
5745                       unsigned long interval_msec,
5746                       unsigned long timeout_msec)
5747 {
5748         unsigned long timeout;
5749         u32 tmp;
5750
5751         tmp = ioread32(reg);
5752
5753         /* Calculate timeout _after_ the first read to make sure
5754          * preceding writes reach the controller before starting to
5755          * eat away the timeout.
5756          */
5757         timeout = jiffies + (timeout_msec * HZ) / 1000;
5758
5759         while ((tmp & mask) == val && time_before(jiffies, timeout)) {
5760                 msleep(interval_msec);
5761                 tmp = ioread32(reg);
5762         }
5763
5764         return tmp;
5765 }
5766
5767 /*
5768  * libata is essentially a library of internal helper functions for
5769  * low-level ATA host controller drivers.  As such, the API/ABI is
5770  * likely to change as new drivers are added and updated.
5771  * Do not depend on ABI/API stability.
5772  */
5773
5774 EXPORT_SYMBOL_GPL(sata_deb_timing_boot);
5775 EXPORT_SYMBOL_GPL(sata_deb_timing_eh);
5776 EXPORT_SYMBOL_GPL(sata_deb_timing_before_fsrst);
5777 EXPORT_SYMBOL_GPL(ata_std_bios_param);
5778 EXPORT_SYMBOL_GPL(ata_std_ports);
5779 EXPORT_SYMBOL_GPL(ata_device_add);
5780 EXPORT_SYMBOL_GPL(ata_port_detach);
5781 EXPORT_SYMBOL_GPL(ata_host_set_remove);
5782 EXPORT_SYMBOL_GPL(ata_sg_init);
5783 EXPORT_SYMBOL_GPL(ata_sg_init_one);
5784 EXPORT_SYMBOL_GPL(ata_hsm_move);
5785 EXPORT_SYMBOL_GPL(ata_qc_complete);
5786 EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
5787 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
5788 EXPORT_SYMBOL_GPL(ata_tf_load);
5789 EXPORT_SYMBOL_GPL(ata_tf_read);
5790 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
5791 EXPORT_SYMBOL_GPL(ata_std_dev_select);
5792 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
5793 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
5794 EXPORT_SYMBOL_GPL(ata_check_status);
5795 EXPORT_SYMBOL_GPL(ata_altstatus);
5796 EXPORT_SYMBOL_GPL(ata_exec_command);
5797 EXPORT_SYMBOL_GPL(ata_port_start);
5798 EXPORT_SYMBOL_GPL(ata_port_stop);
5799 EXPORT_SYMBOL_GPL(ata_host_stop);
5800 EXPORT_SYMBOL_GPL(ata_interrupt);
5801 EXPORT_SYMBOL_GPL(ata_mmio_data_xfer);
5802 EXPORT_SYMBOL_GPL(ata_pio_data_xfer);
5803 EXPORT_SYMBOL_GPL(ata_pio_data_xfer_noirq);
5804 EXPORT_SYMBOL_GPL(ata_qc_prep);
5805 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
5806 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
5807 EXPORT_SYMBOL_GPL(ata_bmdma_start);
5808 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
5809 EXPORT_SYMBOL_GPL(ata_bmdma_status);
5810 EXPORT_SYMBOL_GPL(ata_bmdma_stop);
5811 EXPORT_SYMBOL_GPL(ata_bmdma_freeze);
5812 EXPORT_SYMBOL_GPL(ata_bmdma_thaw);
5813 EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);
5814 EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
5815 EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
5816 EXPORT_SYMBOL_GPL(ata_port_probe);
5817 EXPORT_SYMBOL_GPL(sata_set_spd);
5818 EXPORT_SYMBOL_GPL(sata_phy_debounce);
5819 EXPORT_SYMBOL_GPL(sata_phy_resume);
5820 EXPORT_SYMBOL_GPL(sata_phy_reset);
5821 EXPORT_SYMBOL_GPL(__sata_phy_reset);
5822 EXPORT_SYMBOL_GPL(ata_bus_reset);
5823 EXPORT_SYMBOL_GPL(ata_std_prereset);
5824 EXPORT_SYMBOL_GPL(ata_std_softreset);
5825 EXPORT_SYMBOL_GPL(sata_std_hardreset);
5826 EXPORT_SYMBOL_GPL(ata_std_postreset);
5827 EXPORT_SYMBOL_GPL(ata_dev_revalidate);
5828 EXPORT_SYMBOL_GPL(ata_dev_classify);
5829 EXPORT_SYMBOL_GPL(ata_dev_pair);
5830 EXPORT_SYMBOL_GPL(ata_port_disable);
5831 EXPORT_SYMBOL_GPL(ata_ratelimit);
5832 EXPORT_SYMBOL_GPL(ata_wait_register);
5833 EXPORT_SYMBOL_GPL(ata_busy_sleep);
5834 EXPORT_SYMBOL_GPL(ata_port_queue_task);
5835 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
5836 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
5837 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
5838 EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
5839 EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
5840 EXPORT_SYMBOL_GPL(ata_scsi_release);
5841 EXPORT_SYMBOL_GPL(ata_host_intr);
5842 EXPORT_SYMBOL_GPL(sata_scr_valid);
5843 EXPORT_SYMBOL_GPL(sata_scr_read);
5844 EXPORT_SYMBOL_GPL(sata_scr_write);
5845 EXPORT_SYMBOL_GPL(sata_scr_write_flush);
5846 EXPORT_SYMBOL_GPL(ata_port_online);
5847 EXPORT_SYMBOL_GPL(ata_port_offline);
5848 EXPORT_SYMBOL_GPL(ata_id_string);
5849 EXPORT_SYMBOL_GPL(ata_id_c_string);
5850 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
5851
5852 EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
5853 EXPORT_SYMBOL_GPL(ata_timing_compute);
5854 EXPORT_SYMBOL_GPL(ata_timing_merge);
5855
5856 #ifdef CONFIG_PCI
5857 EXPORT_SYMBOL_GPL(pci_test_config_bits);
5858 EXPORT_SYMBOL_GPL(ata_pci_host_stop);
5859 EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
5860 EXPORT_SYMBOL_GPL(ata_pci_init_one);
5861 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
5862 EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
5863 EXPORT_SYMBOL_GPL(ata_pci_device_resume);
5864 EXPORT_SYMBOL_GPL(ata_pci_default_filter);
5865 EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
5866 #endif /* CONFIG_PCI */
5867
5868 EXPORT_SYMBOL_GPL(ata_device_suspend);
5869 EXPORT_SYMBOL_GPL(ata_device_resume);
5870 EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
5871 EXPORT_SYMBOL_GPL(ata_scsi_device_resume);
5872
5873 EXPORT_SYMBOL_GPL(ata_eng_timeout);
5874 EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
5875 EXPORT_SYMBOL_GPL(ata_port_abort);
5876 EXPORT_SYMBOL_GPL(ata_port_freeze);
5877 EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
5878 EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
5879 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
5880 EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
5881 EXPORT_SYMBOL_GPL(ata_do_eh);