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