drivers/ata/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  *  Standards documents from:
  34  *      http://www.t13.org (ATA standards, PCI DMA IDE spec)
  35  *      http://www.t10.org (SCSI MMC - for ATAPI MMC)
  36  *      http://www.sata-io.org (SATA)
  37  *      http://www.compactflash.org (CF)
  38  *      http://www.qic.org (QIC157 - Tape and DSC)
  39  *      http://www.ce-ata.org (CE-ATA: not supported)
  40  *
  41  */
  42
  43 #include <linux/kernel.h>
  44 #include <linux/module.h>
  45 #include <linux/pci.h>
  46 #include <linux/init.h>
  47 #include <linux/list.h>
  48 #include <linux/mm.h>
  49 #include <linux/highmem.h>
  50 #include <linux/spinlock.h>
  51 #include <linux/blkdev.h>
  52 #include <linux/delay.h>
  53 #include <linux/timer.h>
  54 #include <linux/interrupt.h>
  55 #include <linux/completion.h>
  56 #include <linux/suspend.h>
  57 #include <linux/workqueue.h>
  58 #include <linux/jiffies.h>
  59 #include <linux/scatterlist.h>
  60 #include <linux/io.h>
  61 #include <scsi/scsi.h>
  62 #include <scsi/scsi_cmnd.h>
  63 #include <scsi/scsi_host.h>
  64 #include <linux/libata.h>
  65 #include <asm/semaphore.h>
  66 #include <asm/byteorder.h>
  67
  68 #include "libata.h"
  69
  70
  71 /* debounce timing parameters in msecs { interval, duration, timeout } */
  72 const unsigned long sata_deb_timing_normal[]            = {   5,  100, 2000 };
  73 const unsigned long sata_deb_timing_hotplug[]           = {  25,  500, 2000 };
  74 const unsigned long sata_deb_timing_long[]              = { 100, 2000, 5000 };
  75
  76 static unsigned int ata_dev_init_params(struct ata_device *dev,
  77                                         u16 heads, u16 sectors);
  78 static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
  79 static unsigned int ata_dev_set_feature(struct ata_device *dev,
  80                                         u8 enable, u8 feature);
  81 static void ata_dev_xfermask(struct ata_device *dev);
  82 static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
  83
  84 unsigned int ata_print_id = 1;
  85 static struct workqueue_struct *ata_wq;
  86
  87 struct workqueue_struct *ata_aux_wq;
  88
  89 int atapi_enabled = 1;
  90 module_param(atapi_enabled, int, 0444);
  91 MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
  92
  93 int atapi_dmadir = 0;
  94 module_param(atapi_dmadir, int, 0444);
  95 MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
  96
  97 int atapi_passthru16 = 1;
  98 module_param(atapi_passthru16, int, 0444);
  99 MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)");
 100
 101 int libata_fua = 0;
 102 module_param_named(fua, libata_fua, int, 0444);
 103 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
 104
 105 static int ata_ignore_hpa;
 106 module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
 107 MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
 108
 109 static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
 110 module_param_named(dma, libata_dma_mask, int, 0444);
 111 MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");
 112
 113 static int ata_probe_timeout = ATA_TMOUT_INTERNAL / HZ;
 114 module_param(ata_probe_timeout, int, 0444);
 115 MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
 116
 117 int libata_noacpi = 0;
 118 module_param_named(noacpi, libata_noacpi, int, 0444);
 119 MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set");
 120
 121 MODULE_AUTHOR("Jeff Garzik");
 122 MODULE_DESCRIPTION("Library module for ATA devices");
 123 MODULE_LICENSE("GPL");
 124 MODULE_VERSION(DRV_VERSION);
 125
 126
 127 /**
 128  *      ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
 129  *      @tf: Taskfile to convert
 130  *      @pmp: Port multiplier port
 131  *      @is_cmd: This FIS is for command
 132  *      @fis: Buffer into which data will output
 133  *
 134  *      Converts a standard ATA taskfile to a Serial ATA
 135  *      FIS structure (Register - Host to Device).
 136  *
 137  *      LOCKING:
 138  *      Inherited from caller.
 139  */
 140 void ata_tf_to_fis(const struct ata_taskfile *tf, u8 pmp, int is_cmd, u8 *fis)
 141 {
 142         fis[0] = 0x27;                  /* Register - Host to Device FIS */
 143         fis[1] = pmp & 0xf;             /* Port multiplier number*/
 144         if (is_cmd)
 145                 fis[1] |= (1 << 7);     /* bit 7 indicates Command FIS */
 146
 147         fis[2] = tf->command;
 148         fis[3] = tf->feature;
 149
 150         fis[4] = tf->lbal;
 151         fis[5] = tf->lbam;
 152         fis[6] = tf->lbah;
 153         fis[7] = tf->device;
 154
 155         fis[8] = tf->hob_lbal;
 156         fis[9] = tf->hob_lbam;
 157         fis[10] = tf->hob_lbah;
 158         fis[11] = tf->hob_feature;
 159
 160         fis[12] = tf->nsect;
 161         fis[13] = tf->hob_nsect;
 162         fis[14] = 0;
 163         fis[15] = tf->ctl;
 164
 165         fis[16] = 0;
 166         fis[17] = 0;
 167         fis[18] = 0;
 168         fis[19] = 0;
 169 }
 170
 171 /**
 172  *      ata_tf_from_fis - Convert SATA FIS to ATA taskfile
 173  *      @fis: Buffer from which data will be input
 174  *      @tf: Taskfile to output
 175  *
 176  *      Converts a serial ATA FIS structure to a standard ATA taskfile.
 177  *
 178  *      LOCKING:
 179  *      Inherited from caller.
 180  */
 181
 182 void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
 183 {
 184         tf->command     = fis[2];       /* status */
 185         tf->feature     = fis[3];       /* error */
 186
 187         tf->lbal        = fis[4];
 188         tf->lbam        = fis[5];
 189         tf->lbah        = fis[6];
 190         tf->device      = fis[7];
 191
 192         tf->hob_lbal    = fis[8];
 193         tf->hob_lbam    = fis[9];
 194         tf->hob_lbah    = fis[10];
 195
 196         tf->nsect       = fis[12];
 197         tf->hob_nsect   = fis[13];
 198 }
 199
 200 static const u8 ata_rw_cmds[] = {
 201         /* pio multi */
 202         ATA_CMD_READ_MULTI,
 203         ATA_CMD_WRITE_MULTI,
 204         ATA_CMD_READ_MULTI_EXT,
 205         ATA_CMD_WRITE_MULTI_EXT,
 206         0,
 207         0,
 208         0,
 209         ATA_CMD_WRITE_MULTI_FUA_EXT,
 210         /* pio */
 211         ATA_CMD_PIO_READ,
 212         ATA_CMD_PIO_WRITE,
 213         ATA_CMD_PIO_READ_EXT,
 214         ATA_CMD_PIO_WRITE_EXT,
 215         0,
 216         0,
 217         0,
 218         0,
 219         /* dma */
 220         ATA_CMD_READ,
 221         ATA_CMD_WRITE,
 222         ATA_CMD_READ_EXT,
 223         ATA_CMD_WRITE_EXT,
 224         0,
 225         0,
 226         0,
 227         ATA_CMD_WRITE_FUA_EXT
 228 };
 229
 230 /**
 231  *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
 232  *      @tf: command to examine and configure
 233  *      @dev: device tf belongs to
 234  *
 235  *      Examine the device configuration and tf->flags to calculate
 236  *      the proper read/write commands and protocol to use.
 237  *
 238  *      LOCKING:
 239  *      caller.
 240  */
 241 static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
 242 {
 243         u8 cmd;
 244
 245         int index, fua, lba48, write;
 246
 247         fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
 248         lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
 249         write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
 250
 251         if (dev->flags & ATA_DFLAG_PIO) {
 252                 tf->protocol = ATA_PROT_PIO;
 253                 index = dev->multi_count ? 0 : 8;
 254         } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
 255                 /* Unable to use DMA due to host limitation */
 256                 tf->protocol = ATA_PROT_PIO;
 257                 index = dev->multi_count ? 0 : 8;
 258         } else {
 259                 tf->protocol = ATA_PROT_DMA;
 260                 index = 16;
 261         }
 262
 263         cmd = ata_rw_cmds[index + fua + lba48 + write];
 264         if (cmd) {
 265                 tf->command = cmd;
 266                 return 0;
 267         }
 268         return -1;
 269 }
 270
 271 /**
 272  *      ata_tf_read_block - Read block address from ATA taskfile
 273  *      @tf: ATA taskfile of interest
 274  *      @dev: ATA device @tf belongs to
 275  *
 276  *      LOCKING:
 277  *      None.
 278  *
 279  *      Read block address from @tf.  This function can handle all
 280  *      three address formats - LBA, LBA48 and CHS.  tf->protocol and
 281  *      flags select the address format to use.
 282  *
 283  *      RETURNS:
 284  *      Block address read from @tf.
 285  */
 286 u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev)
 287 {
 288         u64 block = 0;
 289
 290         if (tf->flags & ATA_TFLAG_LBA) {
 291                 if (tf->flags & ATA_TFLAG_LBA48) {
 292                         block |= (u64)tf->hob_lbah << 40;
 293                         block |= (u64)tf->hob_lbam << 32;
 294                         block |= tf->hob_lbal << 24;
 295                 } else
 296                         block |= (tf->device & 0xf) << 24;
 297
 298                 block |= tf->lbah << 16;
 299                 block |= tf->lbam << 8;
 300                 block |= tf->lbal;
 301         } else {
 302                 u32 cyl, head, sect;
 303
 304                 cyl = tf->lbam | (tf->lbah << 8);
 305                 head = tf->device & 0xf;
 306                 sect = tf->lbal;
 307
 308                 block = (cyl * dev->heads + head) * dev->sectors + sect;
 309         }
 310
 311         return block;
 312 }
 313
 314 /**
 315  *      ata_build_rw_tf - Build ATA taskfile for given read/write request
 316  *      @tf: Target ATA taskfile
 317  *      @dev: ATA device @tf belongs to
 318  *      @block: Block address
 319  *      @n_block: Number of blocks
 320  *      @tf_flags: RW/FUA etc...
 321  *      @tag: tag
 322  *
 323  *      LOCKING:
 324  *      None.
 325  *
 326  *      Build ATA taskfile @tf for read/write request described by
 327  *      @block, @n_block, @tf_flags and @tag on @dev.
 328  *
 329  *      RETURNS:
 330  *
 331  *      0 on success, -ERANGE if the request is too large for @dev,
 332  *      -EINVAL if the request is invalid.
 333  */
 334 int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
 335                     u64 block, u32 n_block, unsigned int tf_flags,
 336                     unsigned int tag)
 337 {
 338         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 339         tf->flags |= tf_flags;
 340
 341         if (ata_ncq_enabled(dev) && likely(tag != ATA_TAG_INTERNAL)) {
 342                 /* yay, NCQ */
 343                 if (!lba_48_ok(block, n_block))
 344                         return -ERANGE;
 345
 346                 tf->protocol = ATA_PROT_NCQ;
 347                 tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
 348
 349                 if (tf->flags & ATA_TFLAG_WRITE)
 350                         tf->command = ATA_CMD_FPDMA_WRITE;
 351                 else
 352                         tf->command = ATA_CMD_FPDMA_READ;
 353
 354                 tf->nsect = tag << 3;
 355                 tf->hob_feature = (n_block >> 8) & 0xff;
 356                 tf->feature = n_block & 0xff;
 357
 358                 tf->hob_lbah = (block >> 40) & 0xff;
 359                 tf->hob_lbam = (block >> 32) & 0xff;
 360                 tf->hob_lbal = (block >> 24) & 0xff;
 361                 tf->lbah = (block >> 16) & 0xff;
 362                 tf->lbam = (block >> 8) & 0xff;
 363                 tf->lbal = block & 0xff;
 364
 365                 tf->device = 1 << 6;
 366                 if (tf->flags & ATA_TFLAG_FUA)
 367                         tf->device |= 1 << 7;
 368         } else if (dev->flags & ATA_DFLAG_LBA) {
 369                 tf->flags |= ATA_TFLAG_LBA;
 370
 371                 if (lba_28_ok(block, n_block)) {
 372                         /* use LBA28 */
 373                         tf->device |= (block >> 24) & 0xf;
 374                 } else if (lba_48_ok(block, n_block)) {
 375                         if (!(dev->flags & ATA_DFLAG_LBA48))
 376                                 return -ERANGE;
 377
 378                         /* use LBA48 */
 379                         tf->flags |= ATA_TFLAG_LBA48;
 380
 381                         tf->hob_nsect = (n_block >> 8) & 0xff;
 382
 383                         tf->hob_lbah = (block >> 40) & 0xff;
 384                         tf->hob_lbam = (block >> 32) & 0xff;
 385                         tf->hob_lbal = (block >> 24) & 0xff;
 386                 } else
 387                         /* request too large even for LBA48 */
 388                         return -ERANGE;
 389
 390                 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
 391                         return -EINVAL;
 392
 393                 tf->nsect = n_block & 0xff;
 394
 395                 tf->lbah = (block >> 16) & 0xff;
 396                 tf->lbam = (block >> 8) & 0xff;
 397                 tf->lbal = block & 0xff;
 398
 399                 tf->device |= ATA_LBA;
 400         } else {
 401                 /* CHS */
 402                 u32 sect, head, cyl, track;
 403
 404                 /* The request -may- be too large for CHS addressing. */
 405                 if (!lba_28_ok(block, n_block))
 406                         return -ERANGE;
 407
 408                 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
 409                         return -EINVAL;
 410
 411                 /* Convert LBA to CHS */
 412                 track = (u32)block / dev->sectors;
 413                 cyl   = track / dev->heads;
 414                 head  = track % dev->heads;
 415                 sect  = (u32)block % dev->sectors + 1;
 416
 417                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
 418                         (u32)block, track, cyl, head, sect);
 419
 420                 /* Check whether the converted CHS can fit.
 421                    Cylinder: 0-65535
 422                    Head: 0-15
 423                    Sector: 1-255*/
 424                 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
 425                         return -ERANGE;
 426
 427                 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
 428                 tf->lbal = sect;
 429                 tf->lbam = cyl;
 430                 tf->lbah = cyl >> 8;
 431                 tf->device |= head;
 432         }
 433
 434         return 0;
 435 }
 436
 437 /**
 438  *      ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
 439  *      @pio_mask: pio_mask
 440  *      @mwdma_mask: mwdma_mask
 441  *      @udma_mask: udma_mask
 442  *
 443  *      Pack @pio_mask, @mwdma_mask and @udma_mask into a single
 444  *      unsigned int xfer_mask.
 445  *
 446  *      LOCKING:
 447  *      None.
 448  *
 449  *      RETURNS:
 450  *      Packed xfer_mask.
 451  */
 452 static unsigned int ata_pack_xfermask(unsigned int pio_mask,
 453                                       unsigned int mwdma_mask,
 454                                       unsigned int udma_mask)
 455 {
 456         return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
 457                 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
 458                 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
 459 }
 460
 461 /**
 462  *      ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
 463  *      @xfer_mask: xfer_mask to unpack
 464  *      @pio_mask: resulting pio_mask
 465  *      @mwdma_mask: resulting mwdma_mask
 466  *      @udma_mask: resulting udma_mask
 467  *
 468  *      Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
 469  *      Any NULL distination masks will be ignored.
 470  */
 471 static void ata_unpack_xfermask(unsigned int xfer_mask,
 472                                 unsigned int *pio_mask,
 473                                 unsigned int *mwdma_mask,
 474                                 unsigned int *udma_mask)
 475 {
 476         if (pio_mask)
 477                 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
 478         if (mwdma_mask)
 479                 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
 480         if (udma_mask)
 481                 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
 482 }
 483
 484 static const struct ata_xfer_ent {
 485         int shift, bits;
 486         u8 base;
 487 } ata_xfer_tbl[] = {
 488         { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
 489         { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
 490         { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
 491         { -1, },
 492 };
 493
 494 /**
 495  *      ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
 496  *      @xfer_mask: xfer_mask of interest
 497  *
 498  *      Return matching XFER_* value for @xfer_mask.  Only the highest
 499  *      bit of @xfer_mask is considered.
 500  *
 501  *      LOCKING:
 502  *      None.
 503  *
 504  *      RETURNS:
 505  *      Matching XFER_* value, 0 if no match found.
 506  */
 507 static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
 508 {
 509         int highbit = fls(xfer_mask) - 1;
 510         const struct ata_xfer_ent *ent;
 511
 512         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 513                 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
 514                         return ent->base + highbit - ent->shift;
 515         return 0;
 516 }
 517
 518 /**
 519  *      ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
 520  *      @xfer_mode: XFER_* of interest
 521  *
 522  *      Return matching xfer_mask for @xfer_mode.
 523  *
 524  *      LOCKING:
 525  *      None.
 526  *
 527  *      RETURNS:
 528  *      Matching xfer_mask, 0 if no match found.
 529  */
 530 static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
 531 {
 532         const struct ata_xfer_ent *ent;
 533
 534         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 535                 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
 536                         return 1 << (ent->shift + xfer_mode - ent->base);
 537         return 0;
 538 }
 539
 540 /**
 541  *      ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
 542  *      @xfer_mode: XFER_* of interest
 543  *
 544  *      Return matching xfer_shift for @xfer_mode.
 545  *
 546  *      LOCKING:
 547  *      None.
 548  *
 549  *      RETURNS:
 550  *      Matching xfer_shift, -1 if no match found.
 551  */
 552 static int ata_xfer_mode2shift(unsigned int xfer_mode)
 553 {
 554         const struct ata_xfer_ent *ent;
 555
 556         for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
 557                 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
 558                         return ent->shift;
 559         return -1;
 560 }
 561
 562 /**
 563  *      ata_mode_string - convert xfer_mask to string
 564  *      @xfer_mask: mask of bits supported; only highest bit counts.
 565  *
 566  *      Determine string which represents the highest speed
 567  *      (highest bit in @modemask).
 568  *
 569  *      LOCKING:
 570  *      None.
 571  *
 572  *      RETURNS:
 573  *      Constant C string representing highest speed listed in
 574  *      @mode_mask, or the constant C string "<n/a>".
 575  */
 576 static const char *ata_mode_string(unsigned int xfer_mask)
 577 {
 578         static const char * const xfer_mode_str[] = {
 579                 "PIO0",
 580                 "PIO1",
 581                 "PIO2",
 582                 "PIO3",
 583                 "PIO4",
 584                 "PIO5",
 585                 "PIO6",
 586                 "MWDMA0",
 587                 "MWDMA1",
 588                 "MWDMA2",
 589                 "MWDMA3",
 590                 "MWDMA4",
 591                 "UDMA/16",
 592                 "UDMA/25",
 593                 "UDMA/33",
 594                 "UDMA/44",
 595                 "UDMA/66",
 596                 "UDMA/100",
 597                 "UDMA/133",
 598                 "UDMA7",
 599         };
 600         int highbit;
 601
 602         highbit = fls(xfer_mask) - 1;
 603         if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
 604                 return xfer_mode_str[highbit];
 605         return "<n/a>";
 606 }
 607
 608 static const char *sata_spd_string(unsigned int spd)
 609 {
 610         static const char * const spd_str[] = {
 611                 "1.5 Gbps",
 612                 "3.0 Gbps",
 613         };
 614
 615         if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
 616                 return "<unknown>";
 617         return spd_str[spd - 1];
 618 }
 619
 620 void ata_dev_disable(struct ata_device *dev)
 621 {
 622         if (ata_dev_enabled(dev)) {
 623                 if (ata_msg_drv(dev->link->ap))
 624                         ata_dev_printk(dev, KERN_WARNING, "disabled\n");
 625                 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 |
 626                                              ATA_DNXFER_QUIET);
 627                 dev->class++;
 628         }
 629 }
 630
 631 static int ata_dev_set_dipm(struct ata_device *dev, enum link_pm policy)
 632 {
 633         struct ata_link *link = dev->link;
 634         struct ata_port *ap = link->ap;
 635         u32 scontrol;
 636         unsigned int err_mask;
 637         int rc;
 638
 639         /*
 640          * disallow DIPM for drivers which haven't set
 641          * ATA_FLAG_IPM.  This is because when DIPM is enabled,
 642          * phy ready will be set in the interrupt status on
 643          * state changes, which will cause some drivers to
 644          * think there are errors - additionally drivers will
 645          * need to disable hot plug.
 646          */
 647         if (!(ap->flags & ATA_FLAG_IPM) || !ata_dev_enabled(dev)) {
 648                 ap->pm_policy = NOT_AVAILABLE;
 649                 return -EINVAL;
 650         }
 651
 652         /*
 653          * For DIPM, we will only enable it for the
 654          * min_power setting.
 655          *
 656          * Why?  Because Disks are too stupid to know that
 657          * If the host rejects a request to go to SLUMBER
 658          * they should retry at PARTIAL, and instead it
 659          * just would give up.  So, for medium_power to
 660          * work at all, we need to only allow HIPM.
 661          */
 662         rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
 663         if (rc)
 664                 return rc;
 665
 666         switch (policy) {
 667         case MIN_POWER:
 668                 /* no restrictions on IPM transitions */
 669                 scontrol &= ~(0x3 << 8);
 670                 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
 671                 if (rc)
 672                         return rc;
 673
 674                 /* enable DIPM */
 675                 if (dev->flags & ATA_DFLAG_DIPM)
 676                         err_mask = ata_dev_set_feature(dev,
 677                                         SETFEATURES_SATA_ENABLE, SATA_DIPM);
 678                 break;
 679         case MEDIUM_POWER:
 680                 /* allow IPM to PARTIAL */
 681                 scontrol &= ~(0x1 << 8);
 682                 scontrol |= (0x2 << 8);
 683                 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
 684                 if (rc)
 685                         return rc;
 686
 687                 /*
 688                  * we don't have to disable DIPM since IPM flags
 689                  * disallow transitions to SLUMBER, which effectively
 690                  * disable DIPM if it does not support PARTIAL
 691                  */
 692                 break;
 693         case NOT_AVAILABLE:
 694         case MAX_PERFORMANCE:
 695                 /* disable all IPM transitions */
 696                 scontrol |= (0x3 << 8);
 697                 rc = sata_scr_write(link, SCR_CONTROL, scontrol);
 698                 if (rc)
 699                         return rc;
 700
 701                 /*
 702                  * we don't have to disable DIPM since IPM flags
 703                  * disallow all transitions which effectively
 704                  * disable DIPM anyway.
 705                  */
 706                 break;
 707         }
 708
 709         /* FIXME: handle SET FEATURES failure */
 710         (void) err_mask;
 711
 712         return 0;
 713 }
 714
 715 /**
 716  *      ata_dev_enable_pm - enable SATA interface power management
 717  *      @dev:  device to enable power management
 718  *      @policy: the link power management policy
 719  *
 720  *      Enable SATA Interface power management.  This will enable
 721  *      Device Interface Power Management (DIPM) for min_power
 722  *      policy, and then call driver specific callbacks for
 723  *      enabling Host Initiated Power management.
 724  *
 725  *      Locking: Caller.
 726  *      Returns: -EINVAL if IPM is not supported, 0 otherwise.
 727  */
 728 void ata_dev_enable_pm(struct ata_device *dev, enum link_pm policy)
 729 {
 730         int rc = 0;
 731         struct ata_port *ap = dev->link->ap;
 732
 733         /* set HIPM first, then DIPM */
 734         if (ap->ops->enable_pm)
 735                 rc = ap->ops->enable_pm(ap, policy);
 736         if (rc)
 737                 goto enable_pm_out;
 738         rc = ata_dev_set_dipm(dev, policy);
 739
 740 enable_pm_out:
 741         if (rc)
 742                 ap->pm_policy = MAX_PERFORMANCE;
 743         else
 744                 ap->pm_policy = policy;
 745         return /* rc */;        /* hopefully we can use 'rc' eventually */
 746 }
 747
 748 #ifdef CONFIG_PM
 749 /**
 750  *      ata_dev_disable_pm - disable SATA interface power management
 751  *      @dev: device to disable power management
 752  *
 753  *      Disable SATA Interface power management.  This will disable
 754  *      Device Interface Power Management (DIPM) without changing
 755  *      policy,  call driver specific callbacks for disabling Host
 756  *      Initiated Power management.
 757  *
 758  *      Locking: Caller.
 759  *      Returns: void
 760  */
 761 static void ata_dev_disable_pm(struct ata_device *dev)
 762 {
 763         struct ata_port *ap = dev->link->ap;
 764
 765         ata_dev_set_dipm(dev, MAX_PERFORMANCE);
 766         if (ap->ops->disable_pm)
 767                 ap->ops->disable_pm(ap);
 768 }
 769 #endif  /* CONFIG_PM */
 770
 771 void ata_lpm_schedule(struct ata_port *ap, enum link_pm policy)
 772 {
 773         ap->pm_policy = policy;
 774         ap->link.eh_info.action |= ATA_EHI_LPM;
 775         ap->link.eh_info.flags |= ATA_EHI_NO_AUTOPSY;
 776         ata_port_schedule_eh(ap);
 777 }
 778
 779 #ifdef CONFIG_PM
 780 static void ata_lpm_enable(struct ata_host *host)
 781 {
 782         struct ata_link *link;
 783         struct ata_port *ap;
 784         struct ata_device *dev;
 785         int i;
 786
 787         for (i = 0; i < host->n_ports; i++) {
 788                 ap = host->ports[i];
 789                 ata_port_for_each_link(link, ap) {
 790                         ata_link_for_each_dev(dev, link)
 791                                 ata_dev_disable_pm(dev);
 792                 }
 793         }
 794 }
 795
 796 static void ata_lpm_disable(struct ata_host *host)
 797 {
 798         int i;
 799
 800         for (i = 0; i < host->n_ports; i++) {
 801                 struct ata_port *ap = host->ports[i];
 802                 ata_lpm_schedule(ap, ap->pm_policy);
 803         }
 804 }
 805 #endif  /* CONFIG_PM */
 806
 807
 808 /**
 809  *      ata_devchk - PATA device presence detection
 810  *      @ap: ATA channel to examine
 811  *      @device: Device to examine (starting at zero)
 812  *
 813  *      This technique was originally described in
 814  *      Hale Landis's ATADRVR (www.ata-atapi.com), and
 815  *      later found its way into the ATA/ATAPI spec.
 816  *
 817  *      Write a pattern to the ATA shadow registers,
 818  *      and if a device is present, it will respond by
 819  *      correctly storing and echoing back the
 820  *      ATA shadow register contents.
 821  *
 822  *      LOCKING:
 823  *      caller.
 824  */
 825
 826 static unsigned int ata_devchk(struct ata_port *ap, unsigned int device)
 827 {
 828         struct ata_ioports *ioaddr = &ap->ioaddr;
 829         u8 nsect, lbal;
 830
 831         ap->ops->dev_select(ap, device);
 832
 833         iowrite8(0x55, ioaddr->nsect_addr);
 834         iowrite8(0xaa, ioaddr->lbal_addr);
 835
 836         iowrite8(0xaa, ioaddr->nsect_addr);
 837         iowrite8(0x55, ioaddr->lbal_addr);
 838
 839         iowrite8(0x55, ioaddr->nsect_addr);
 840         iowrite8(0xaa, ioaddr->lbal_addr);
 841
 842         nsect = ioread8(ioaddr->nsect_addr);
 843         lbal = ioread8(ioaddr->lbal_addr);
 844
 845         if ((nsect == 0x55) && (lbal == 0xaa))
 846                 return 1;       /* we found a device */
 847
 848         return 0;               /* nothing found */
 849 }
 850
 851 /**
 852  *      ata_dev_classify - determine device type based on ATA-spec signature
 853  *      @tf: ATA taskfile register set for device to be identified
 854  *
 855  *      Determine from taskfile register contents whether a device is
 856  *      ATA or ATAPI, as per "Signature and persistence" section
 857  *      of ATA/PI spec (volume 1, sect 5.14).
 858  *
 859  *      LOCKING:
 860  *      None.
 861  *
 862  *      RETURNS:
 863  *      Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP or
 864  *      %ATA_DEV_UNKNOWN the event of failure.
 865  */
 866 unsigned int ata_dev_classify(const struct ata_taskfile *tf)
 867 {
 868         /* Apple's open source Darwin code hints that some devices only
 869          * put a proper signature into the LBA mid/high registers,
 870          * So, we only check those.  It's sufficient for uniqueness.
 871          *
 872          * ATA/ATAPI-7 (d1532v1r1: Feb. 19, 2003) specified separate
 873          * signatures for ATA and ATAPI devices attached on SerialATA,
 874          * 0x3c/0xc3 and 0x69/0x96 respectively.  However, SerialATA
 875          * spec has never mentioned about using different signatures
 876          * for ATA/ATAPI devices.  Then, Serial ATA II: Port
 877          * Multiplier specification began to use 0x69/0x96 to identify
 878          * port multpliers and 0x3c/0xc3 to identify SEMB device.
 879          * ATA/ATAPI-7 dropped descriptions about 0x3c/0xc3 and
 880          * 0x69/0x96 shortly and described them as reserved for
 881          * SerialATA.
 882          *
 883          * We follow the current spec and consider that 0x69/0x96
 884          * identifies a port multiplier and 0x3c/0xc3 a SEMB device.
 885          */
 886         if ((tf->lbam == 0) && (tf->lbah == 0)) {
 887                 DPRINTK("found ATA device by sig\n");
 888                 return ATA_DEV_ATA;
 889         }
 890
 891         if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
 892                 DPRINTK("found ATAPI device by sig\n");
 893                 return ATA_DEV_ATAPI;
 894         }
 895
 896         if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
 897                 DPRINTK("found PMP device by sig\n");
 898                 return ATA_DEV_PMP;
 899         }
 900
 901         if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
 902                 printk(KERN_INFO "ata: SEMB device ignored\n");
 903                 return ATA_DEV_SEMB_UNSUP; /* not yet */
 904         }
 905
 906         DPRINTK("unknown device\n");
 907         return ATA_DEV_UNKNOWN;
 908 }
 909
 910 /**
 911  *      ata_dev_try_classify - Parse returned ATA device signature
 912  *      @dev: ATA device to classify (starting at zero)
 913  *      @present: device seems present
 914  *      @r_err: Value of error register on completion
 915  *
 916  *      After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
 917  *      an ATA/ATAPI-defined set of values is placed in the ATA
 918  *      shadow registers, indicating the results of device detection
 919  *      and diagnostics.
 920  *
 921  *      Select the ATA device, and read the values from the ATA shadow
 922  *      registers.  Then parse according to the Error register value,
 923  *      and the spec-defined values examined by ata_dev_classify().
 924  *
 925  *      LOCKING:
 926  *      caller.
 927  *
 928  *      RETURNS:
 929  *      Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
 930  */
 931 unsigned int ata_dev_try_classify(struct ata_device *dev, int present,
 932                                   u8 *r_err)
 933 {
 934         struct ata_port *ap = dev->link->ap;
 935         struct ata_taskfile tf;
 936         unsigned int class;
 937         u8 err;
 938
 939         ap->ops->dev_select(ap, dev->devno);
 940
 941         memset(&tf, 0, sizeof(tf));
 942
 943         ap->ops->tf_read(ap, &tf);
 944         err = tf.feature;
 945         if (r_err)
 946                 *r_err = err;
 947
 948         /* see if device passed diags: if master then continue and warn later */
 949         if (err == 0 && dev->devno == 0)
 950                 /* diagnostic fail : do nothing _YET_ */
 951                 dev->horkage |= ATA_HORKAGE_DIAGNOSTIC;
 952         else if (err == 1)
 953                 /* do nothing */ ;
 954         else if ((dev->devno == 0) && (err == 0x81))
 955                 /* do nothing */ ;
 956         else
 957                 return ATA_DEV_NONE;
 958
 959         /* determine if device is ATA or ATAPI */
 960         class = ata_dev_classify(&tf);
 961
 962         if (class == ATA_DEV_UNKNOWN) {
 963                 /* If the device failed diagnostic, it's likely to
 964                  * have reported incorrect device signature too.
 965                  * Assume ATA device if the device seems present but
 966                  * device signature is invalid with diagnostic
 967                  * failure.
 968                  */
 969                 if (present && (dev->horkage & ATA_HORKAGE_DIAGNOSTIC))
 970                         class = ATA_DEV_ATA;
 971                 else
 972                         class = ATA_DEV_NONE;
 973         } else if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
 974                 class = ATA_DEV_NONE;
 975
 976         return class;
 977 }
 978
 979 /**
 980  *      ata_id_string - Convert IDENTIFY DEVICE page into string
 981  *      @id: IDENTIFY DEVICE results we will examine
 982  *      @s: string into which data is output
 983  *      @ofs: offset into identify device page
 984  *      @len: length of string to return. must be an even number.
 985  *
 986  *      The strings in the IDENTIFY DEVICE page are broken up into
 987  *      16-bit chunks.  Run through the string, and output each
 988  *      8-bit chunk linearly, regardless of platform.
 989  *
 990  *      LOCKING:
 991  *      caller.
 992  */
 993
 994 void ata_id_string(const u16 *id, unsigned char *s,
 995                    unsigned int ofs, unsigned int len)
 996 {
 997         unsigned int c;
 998
 999         while (len > 0) {
1000                 c = id[ofs] >> 8;
1001                 *s = c;
1002                 s++;
1003
1004                 c = id[ofs] & 0xff;
1005                 *s = c;
1006                 s++;
1007
1008                 ofs++;
1009                 len -= 2;
1010         }
1011 }
1012
1013 /**
1014  *      ata_id_c_string - Convert IDENTIFY DEVICE page into C string
1015  *      @id: IDENTIFY DEVICE results we will examine
1016  *      @s: string into which data is output
1017  *      @ofs: offset into identify device page
1018  *      @len: length of string to return. must be an odd number.
1019  *
1020  *      This function is identical to ata_id_string except that it
1021  *      trims trailing spaces and terminates the resulting string with
1022  *      null.  @len must be actual maximum length (even number) + 1.
1023  *
1024  *      LOCKING:
1025  *      caller.
1026  */
1027 void ata_id_c_string(const u16 *id, unsigned char *s,
1028                      unsigned int ofs, unsigned int len)
1029 {
1030         unsigned char *p;
1031
1032         WARN_ON(!(len & 1));
1033
1034         ata_id_string(id, s, ofs, len - 1);
1035
1036         p = s + strnlen(s, len - 1);
1037         while (p > s && p[-1] == ' ')
1038                 p--;
1039         *p = '\0';
1040 }
1041
1042 static u64 ata_id_n_sectors(const u16 *id)
1043 {
1044         if (ata_id_has_lba(id)) {
1045                 if (ata_id_has_lba48(id))
1046                         return ata_id_u64(id, 100);
1047                 else
1048                         return ata_id_u32(id, 60);
1049         } else {
1050                 if (ata_id_current_chs_valid(id))
1051                         return ata_id_u32(id, 57);
1052                 else
1053                         return id[1] * id[3] * id[6];
1054         }
1055 }
1056
1057 static u64 ata_tf_to_lba48(struct ata_taskfile *tf)
1058 {
1059         u64 sectors = 0;
1060
1061         sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40;
1062         sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32;
1063         sectors |= (tf->hob_lbal & 0xff) << 24;
1064         sectors |= (tf->lbah & 0xff) << 16;
1065         sectors |= (tf->lbam & 0xff) << 8;
1066         sectors |= (tf->lbal & 0xff);
1067
1068         return ++sectors;
1069 }
1070
1071 static u64 ata_tf_to_lba(struct ata_taskfile *tf)
1072 {
1073         u64 sectors = 0;
1074
1075         sectors |= (tf->device & 0x0f) << 24;
1076         sectors |= (tf->lbah & 0xff) << 16;
1077         sectors |= (tf->lbam & 0xff) << 8;
1078         sectors |= (tf->lbal & 0xff);
1079
1080         return ++sectors;
1081 }
1082
1083 /**
1084  *      ata_read_native_max_address - Read native max address
1085  *      @dev: target device
1086  *      @max_sectors: out parameter for the result native max address
1087  *
1088  *      Perform an LBA48 or LBA28 native size query upon the device in
1089  *      question.
1090  *
1091  *      RETURNS:
1092  *      0 on success, -EACCES if command is aborted by the drive.
1093  *      -EIO on other errors.
1094  */
1095 static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
1096 {
1097         unsigned int err_mask;
1098         struct ata_taskfile tf;
1099         int lba48 = ata_id_has_lba48(dev->id);
1100
1101         ata_tf_init(dev, &tf);
1102
1103         /* always clear all address registers */
1104         tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1105
1106         if (lba48) {
1107                 tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
1108                 tf.flags |= ATA_TFLAG_LBA48;
1109         } else
1110                 tf.command = ATA_CMD_READ_NATIVE_MAX;
1111
1112         tf.protocol |= ATA_PROT_NODATA;
1113         tf.device |= ATA_LBA;
1114
1115         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1116         if (err_mask) {
1117                 ata_dev_printk(dev, KERN_WARNING, "failed to read native "
1118                                "max address (err_mask=0x%x)\n", err_mask);
1119                 if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
1120                         return -EACCES;
1121                 return -EIO;
1122         }
1123
1124         if (lba48)
1125                 *max_sectors = ata_tf_to_lba48(&tf);
1126         else
1127                 *max_sectors = ata_tf_to_lba(&tf);
1128         if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
1129                 (*max_sectors)--;
1130         return 0;
1131 }
1132
1133 /**
1134  *      ata_set_max_sectors - Set max sectors
1135  *      @dev: target device
1136  *      @new_sectors: new max sectors value to set for the device
1137  *
1138  *      Set max sectors of @dev to @new_sectors.
1139  *
1140  *      RETURNS:
1141  *      0 on success, -EACCES if command is aborted or denied (due to
1142  *      previous non-volatile SET_MAX) by the drive.  -EIO on other
1143  *      errors.
1144  */
1145 static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
1146 {
1147         unsigned int err_mask;
1148         struct ata_taskfile tf;
1149         int lba48 = ata_id_has_lba48(dev->id);
1150
1151         new_sectors--;
1152
1153         ata_tf_init(dev, &tf);
1154
1155         tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1156
1157         if (lba48) {
1158                 tf.command = ATA_CMD_SET_MAX_EXT;
1159                 tf.flags |= ATA_TFLAG_LBA48;
1160
1161                 tf.hob_lbal = (new_sectors >> 24) & 0xff;
1162                 tf.hob_lbam = (new_sectors >> 32) & 0xff;
1163                 tf.hob_lbah = (new_sectors >> 40) & 0xff;
1164         } else {
1165                 tf.command = ATA_CMD_SET_MAX;
1166
1167                 tf.device |= (new_sectors >> 24) & 0xf;
1168         }
1169
1170         tf.protocol |= ATA_PROT_NODATA;
1171         tf.device |= ATA_LBA;
1172
1173         tf.lbal = (new_sectors >> 0) & 0xff;
1174         tf.lbam = (new_sectors >> 8) & 0xff;
1175         tf.lbah = (new_sectors >> 16) & 0xff;
1176
1177         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1178         if (err_mask) {
1179                 ata_dev_printk(dev, KERN_WARNING, "failed to set "
1180                                "max address (err_mask=0x%x)\n", err_mask);
1181                 if (err_mask == AC_ERR_DEV &&
1182                     (tf.feature & (ATA_ABORTED | ATA_IDNF)))
1183                         return -EACCES;
1184                 return -EIO;
1185         }
1186
1187         return 0;
1188 }
1189
1190 /**
1191  *      ata_hpa_resize          -       Resize a device with an HPA set
1192  *      @dev: Device to resize
1193  *
1194  *      Read the size of an LBA28 or LBA48 disk with HPA features and resize
1195  *      it if required to the full size of the media. The caller must check
1196  *      the drive has the HPA feature set enabled.
1197  *
1198  *      RETURNS:
1199  *      0 on success, -errno on failure.
1200  */
1201 static int ata_hpa_resize(struct ata_device *dev)
1202 {
1203         struct ata_eh_context *ehc = &dev->link->eh_context;
1204         int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
1205         u64 sectors = ata_id_n_sectors(dev->id);
1206         u64 native_sectors;
1207         int rc;
1208
1209         /* do we need to do it? */
1210         if (dev->class != ATA_DEV_ATA ||
1211             !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
1212             (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
1213                 return 0;
1214
1215         /* read native max address */
1216         rc = ata_read_native_max_address(dev, &native_sectors);
1217         if (rc) {
1218                 /* If HPA isn't going to be unlocked, skip HPA
1219                  * resizing from the next try.
1220                  */
1221                 if (!ata_ignore_hpa) {
1222                         ata_dev_printk(dev, KERN_WARNING, "HPA support seems "
1223                                        "broken, will skip HPA handling\n");
1224                         dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1225
1226                         /* we can continue if device aborted the command */
1227                         if (rc == -EACCES)
1228                                 rc = 0;
1229                 }
1230
1231                 return rc;
1232         }
1233
1234         /* nothing to do? */
1235         if (native_sectors <= sectors || !ata_ignore_hpa) {
1236                 if (!print_info || native_sectors == sectors)
1237                         return 0;
1238
1239                 if (native_sectors > sectors)
1240                         ata_dev_printk(dev, KERN_INFO,
1241                                 "HPA detected: current %llu, native %llu\n",
1242                                 (unsigned long long)sectors,
1243                                 (unsigned long long)native_sectors);
1244                 else if (native_sectors < sectors)
1245                         ata_dev_printk(dev, KERN_WARNING,
1246                                 "native sectors (%llu) is smaller than "
1247                                 "sectors (%llu)\n",
1248                                 (unsigned long long)native_sectors,
1249                                 (unsigned long long)sectors);
1250                 return 0;
1251         }
1252
1253         /* let's unlock HPA */
1254         rc = ata_set_max_sectors(dev, native_sectors);
1255         if (rc == -EACCES) {
1256                 /* if device aborted the command, skip HPA resizing */
1257                 ata_dev_printk(dev, KERN_WARNING, "device aborted resize "
1258                                "(%llu -> %llu), skipping HPA handling\n",
1259                                (unsigned long long)sectors,
1260                                (unsigned long long)native_sectors);
1261                 dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1262                 return 0;
1263         } else if (rc)
1264                 return rc;
1265
1266         /* re-read IDENTIFY data */
1267         rc = ata_dev_reread_id(dev, 0);
1268         if (rc) {
1269                 ata_dev_printk(dev, KERN_ERR, "failed to re-read IDENTIFY "
1270                                "data after HPA resizing\n");
1271                 return rc;
1272         }
1273
1274         if (print_info) {
1275                 u64 new_sectors = ata_id_n_sectors(dev->id);
1276                 ata_dev_printk(dev, KERN_INFO,
1277                         "HPA unlocked: %llu -> %llu, native %llu\n",
1278                         (unsigned long long)sectors,
1279                         (unsigned long long)new_sectors,
1280                         (unsigned long long)native_sectors);
1281         }
1282
1283         return 0;
1284 }
1285
1286 /**
1287  *      ata_id_to_dma_mode      -       Identify DMA mode from id block
1288  *      @dev: device to identify
1289  *      @unknown: mode to assume if we cannot tell
1290  *
1291  *      Set up the timing values for the device based upon the identify
1292  *      reported values for the DMA mode. This function is used by drivers
1293  *      which rely upon firmware configured modes, but wish to report the
1294  *      mode correctly when possible.
1295  *
1296  *      In addition we emit similarly formatted messages to the default
1297  *      ata_dev_set_mode handler, in order to provide consistency of
1298  *      presentation.
1299  */
1300
1301 void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown)
1302 {
1303         unsigned int mask;
1304         u8 mode;
1305
1306         /* Pack the DMA modes */
1307         mask = ((dev->id[63] >> 8) << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA;
1308         if (dev->id[53] & 0x04)
1309                 mask |= ((dev->id[88] >> 8) << ATA_SHIFT_UDMA) & ATA_MASK_UDMA;
1310
1311         /* Select the mode in use */
1312         mode = ata_xfer_mask2mode(mask);
1313
1314         if (mode != 0) {
1315                 ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
1316                        ata_mode_string(mask));
1317         } else {
1318                 /* SWDMA perhaps ? */
1319                 mode = unknown;
1320                 ata_dev_printk(dev, KERN_INFO, "configured for DMA\n");
1321         }
1322
1323         /* Configure the device reporting */
1324         dev->xfer_mode = mode;
1325         dev->xfer_shift = ata_xfer_mode2shift(mode);
1326 }
1327
1328 /**
1329  *      ata_noop_dev_select - Select device 0/1 on ATA bus
1330  *      @ap: ATA channel to manipulate
1331  *      @device: ATA device (numbered from zero) to select
1332  *
1333  *      This function performs no actual function.
1334  *
1335  *      May be used as the dev_select() entry in ata_port_operations.
1336  *
1337  *      LOCKING:
1338  *      caller.
1339  */
1340 void ata_noop_dev_select(struct ata_port *ap, unsigned int device)
1341 {
1342 }
1343
1344
1345 /**
1346  *      ata_std_dev_select - Select device 0/1 on ATA bus
1347  *      @ap: ATA channel to manipulate
1348  *      @device: ATA device (numbered from zero) to select
1349  *
1350  *      Use the method defined in the ATA specification to
1351  *      make either device 0, or device 1, active on the
1352  *      ATA channel.  Works with both PIO and MMIO.
1353  *
1354  *      May be used as the dev_select() entry in ata_port_operations.
1355  *
1356  *      LOCKING:
1357  *      caller.
1358  */
1359
1360 void ata_std_dev_select(struct ata_port *ap, unsigned int device)
1361 {
1362         u8 tmp;
1363
1364         if (device == 0)
1365                 tmp = ATA_DEVICE_OBS;
1366         else
1367                 tmp = ATA_DEVICE_OBS | ATA_DEV1;
1368
1369         iowrite8(tmp, ap->ioaddr.device_addr);
1370         ata_pause(ap);          /* needed; also flushes, for mmio */
1371 }
1372
1373 /**
1374  *      ata_dev_select - Select device 0/1 on ATA bus
1375  *      @ap: ATA channel to manipulate
1376  *      @device: ATA device (numbered from zero) to select
1377  *      @wait: non-zero to wait for Status register BSY bit to clear
1378  *      @can_sleep: non-zero if context allows sleeping
1379  *
1380  *      Use the method defined in the ATA specification to
1381  *      make either device 0, or device 1, active on the
1382  *      ATA channel.
1383  *
1384  *      This is a high-level version of ata_std_dev_select(),
1385  *      which additionally provides the services of inserting
1386  *      the proper pauses and status polling, where needed.
1387  *
1388  *      LOCKING:
1389  *      caller.
1390  */
1391
1392 void ata_dev_select(struct ata_port *ap, unsigned int device,
1393                            unsigned int wait, unsigned int can_sleep)
1394 {
1395         if (ata_msg_probe(ap))
1396                 ata_port_printk(ap, KERN_INFO, "ata_dev_select: ENTER, "
1397                                 "device %u, wait %u\n", device, wait);
1398
1399         if (wait)
1400                 ata_wait_idle(ap);
1401
1402         ap->ops->dev_select(ap, device);
1403
1404         if (wait) {
1405                 if (can_sleep && ap->link.device[device].class == ATA_DEV_ATAPI)
1406                         msleep(150);
1407                 ata_wait_idle(ap);
1408         }
1409 }
1410
1411 /**
1412  *      ata_dump_id - IDENTIFY DEVICE info debugging output
1413  *      @id: IDENTIFY DEVICE page to dump
1414  *
1415  *      Dump selected 16-bit words from the given IDENTIFY DEVICE
1416  *      page.
1417  *
1418  *      LOCKING:
1419  *      caller.
1420  */
1421
1422 static inline void ata_dump_id(const u16 *id)
1423 {
1424         DPRINTK("49==0x%04x  "
1425                 "53==0x%04x  "
1426                 "63==0x%04x  "
1427                 "64==0x%04x  "
1428                 "75==0x%04x  \n",
1429                 id[49],
1430                 id[53],
1431                 id[63],
1432                 id[64],
1433                 id[75]);
1434         DPRINTK("80==0x%04x  "
1435                 "81==0x%04x  "
1436                 "82==0x%04x  "
1437                 "83==0x%04x  "
1438                 "84==0x%04x  \n",
1439                 id[80],
1440                 id[81],
1441                 id[82],
1442                 id[83],
1443                 id[84]);
1444         DPRINTK("88==0x%04x  "
1445                 "93==0x%04x\n",
1446                 id[88],
1447                 id[93]);
1448 }
1449
1450 /**
1451  *      ata_id_xfermask - Compute xfermask from the given IDENTIFY data
1452  *      @id: IDENTIFY data to compute xfer mask from
1453  *
1454  *      Compute the xfermask for this device. This is not as trivial
1455  *      as it seems if we must consider early devices correctly.
1456  *
1457  *      FIXME: pre IDE drive timing (do we care ?).
1458  *
1459  *      LOCKING:
1460  *      None.
1461  *
1462  *      RETURNS:
1463  *      Computed xfermask
1464  */
1465 static unsigned int ata_id_xfermask(const u16 *id)
1466 {
1467         unsigned int pio_mask, mwdma_mask, udma_mask;
1468
1469         /* Usual case. Word 53 indicates word 64 is valid */
1470         if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
1471                 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
1472                 pio_mask <<= 3;
1473                 pio_mask |= 0x7;
1474         } else {
1475                 /* If word 64 isn't valid then Word 51 high byte holds
1476                  * the PIO timing number for the maximum. Turn it into
1477                  * a mask.
1478                  */
1479                 u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
1480                 if (mode < 5)   /* Valid PIO range */
1481                         pio_mask = (2 << mode) - 1;
1482                 else
1483                         pio_mask = 1;
1484
1485                 /* But wait.. there's more. Design your standards by
1486                  * committee and you too can get a free iordy field to
1487                  * process. However its the speeds not the modes that
1488                  * are supported... Note drivers using the timing API
1489                  * will get this right anyway
1490                  */
1491         }
1492
1493         mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
1494
1495         if (ata_id_is_cfa(id)) {
1496                 /*
1497                  *      Process compact flash extended modes
1498                  */
1499                 int pio = id[163] & 0x7;
1500                 int dma = (id[163] >> 3) & 7;
1501
1502                 if (pio)
1503                         pio_mask |= (1 << 5);
1504                 if (pio > 1)
1505                         pio_mask |= (1 << 6);
1506                 if (dma)
1507                         mwdma_mask |= (1 << 3);
1508                 if (dma > 1)
1509                         mwdma_mask |= (1 << 4);
1510         }
1511
1512         udma_mask = 0;
1513         if (id[ATA_ID_FIELD_VALID] & (1 << 2))
1514                 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
1515
1516         return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
1517 }
1518
1519 /**
1520  *      ata_port_queue_task - Queue port_task
1521  *      @ap: The ata_port to queue port_task for
1522  *      @fn: workqueue function to be scheduled
1523  *      @data: data for @fn to use
1524  *      @delay: delay time for workqueue function
1525  *
1526  *      Schedule @fn(@data) for execution after @delay jiffies using
1527  *      port_task.  There is one port_task per port and it's the
1528  *      user(low level driver)'s responsibility to make sure that only
1529  *      one task is active at any given time.
1530  *
1531  *      libata core layer takes care of synchronization between
1532  *      port_task and EH.  ata_port_queue_task() may be ignored for EH
1533  *      synchronization.
1534  *
1535  *      LOCKING:
1536  *      Inherited from caller.
1537  */
1538 void ata_port_queue_task(struct ata_port *ap, work_func_t fn, void *data,
1539                          unsigned long delay)
1540 {
1541         PREPARE_DELAYED_WORK(&ap->port_task, fn);
1542         ap->port_task_data = data;
1543
1544         /* may fail if ata_port_flush_task() in progress */
1545         queue_delayed_work(ata_wq, &ap->port_task, delay);
1546 }
1547
1548 /**
1549  *      ata_port_flush_task - Flush port_task
1550  *      @ap: The ata_port to flush port_task for
1551  *
1552  *      After this function completes, port_task is guranteed not to
1553  *      be running or scheduled.
1554  *
1555  *      LOCKING:
1556  *      Kernel thread context (may sleep)
1557  */
1558 void ata_port_flush_task(struct ata_port *ap)
1559 {
1560         DPRINTK("ENTER\n");
1561
1562         cancel_rearming_delayed_work(&ap->port_task);
1563
1564         if (ata_msg_ctl(ap))
1565                 ata_port_printk(ap, KERN_DEBUG, "%s: EXIT\n", __FUNCTION__);
1566 }
1567
1568 static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
1569 {
1570         struct completion *waiting = qc->private_data;
1571
1572         complete(waiting);
1573 }
1574
1575 /**
1576  *      ata_exec_internal_sg - execute libata internal command
1577  *      @dev: Device to which the command is sent
1578  *      @tf: Taskfile registers for the command and the result
1579  *      @cdb: CDB for packet command
1580  *      @dma_dir: Data tranfer direction of the command
1581  *      @sgl: sg list for the data buffer of the command
1582  *      @n_elem: Number of sg entries
1583  *      @timeout: Timeout in msecs (0 for default)
1584  *
1585  *      Executes libata internal command with timeout.  @tf contains
1586  *      command on entry and result on return.  Timeout and error
1587  *      conditions are reported via return value.  No recovery action
1588  *      is taken after a command times out.  It's caller's duty to
1589  *      clean up after timeout.
1590  *
1591  *      LOCKING:
1592  *      None.  Should be called with kernel context, might sleep.
1593  *
1594  *      RETURNS:
1595  *      Zero on success, AC_ERR_* mask on failure
1596  */
1597 unsigned ata_exec_internal_sg(struct ata_device *dev,
1598                               struct ata_taskfile *tf, const u8 *cdb,
1599                               int dma_dir, struct scatterlist *sgl,
1600                               unsigned int n_elem, unsigned long timeout)
1601 {
1602         struct ata_link *link = dev->link;
1603         struct ata_port *ap = link->ap;
1604         u8 command = tf->command;
1605         struct ata_queued_cmd *qc;
1606         unsigned int tag, preempted_tag;
1607         u32 preempted_sactive, preempted_qc_active;
1608         int preempted_nr_active_links;
1609         DECLARE_COMPLETION_ONSTACK(wait);
1610         unsigned long flags;
1611         unsigned int err_mask;
1612         int rc;
1613
1614         spin_lock_irqsave(ap->lock, flags);
1615
1616         /* no internal command while frozen */
1617         if (ap->pflags & ATA_PFLAG_FROZEN) {
1618                 spin_unlock_irqrestore(ap->lock, flags);
1619                 return AC_ERR_SYSTEM;
1620         }
1621
1622         /* initialize internal qc */
1623
1624         /* XXX: Tag 0 is used for drivers with legacy EH as some
1625          * drivers choke if any other tag is given.  This breaks
1626          * ata_tag_internal() test for those drivers.  Don't use new
1627          * EH stuff without converting to it.
1628          */
1629         if (ap->ops->error_handler)
1630                 tag = ATA_TAG_INTERNAL;
1631         else
1632                 tag = 0;
1633
1634         if (test_and_set_bit(tag, &ap->qc_allocated))
1635                 BUG();
1636         qc = __ata_qc_from_tag(ap, tag);
1637
1638         qc->tag = tag;
1639         qc->scsicmd = NULL;
1640         qc->ap = ap;
1641         qc->dev = dev;
1642         ata_qc_reinit(qc);
1643
1644         preempted_tag = link->active_tag;
1645         preempted_sactive = link->sactive;
1646         preempted_qc_active = ap->qc_active;
1647         preempted_nr_active_links = ap->nr_active_links;
1648         link->active_tag = ATA_TAG_POISON;
1649         link->sactive = 0;
1650         ap->qc_active = 0;
1651         ap->nr_active_links = 0;
1652
1653         /* prepare & issue qc */
1654         qc->tf = *tf;
1655         if (cdb)
1656                 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1657         qc->flags |= ATA_QCFLAG_RESULT_TF;
1658         qc->dma_dir = dma_dir;
1659         if (dma_dir != DMA_NONE) {
1660                 unsigned int i, buflen = 0;
1661                 struct scatterlist *sg;
1662
1663                 for_each_sg(sgl, sg, n_elem, i)
1664                         buflen += sg->length;
1665
1666                 ata_sg_init(qc, sgl, n_elem);
1667                 qc->nbytes = buflen;
1668         }
1669
1670         qc->private_data = &wait;
1671         qc->complete_fn = ata_qc_complete_internal;
1672
1673         ata_qc_issue(qc);
1674
1675         spin_unlock_irqrestore(ap->lock, flags);
1676
1677         if (!timeout)
1678                 timeout = ata_probe_timeout * 1000 / HZ;
1679
1680         rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
1681
1682         ata_port_flush_task(ap);
1683
1684         if (!rc) {
1685                 spin_lock_irqsave(ap->lock, flags);
1686
1687                 /* We're racing with irq here.  If we lose, the
1688                  * following test prevents us from completing the qc
1689                  * twice.  If we win, the port is frozen and will be
1690                  * cleaned up by ->post_internal_cmd().
1691                  */
1692                 if (qc->flags & ATA_QCFLAG_ACTIVE) {
1693                         qc->err_mask |= AC_ERR_TIMEOUT;
1694
1695                         if (ap->ops->error_handler)
1696                                 ata_port_freeze(ap);
1697                         else
1698                                 ata_qc_complete(qc);
1699
1700                         if (ata_msg_warn(ap))
1701                                 ata_dev_printk(dev, KERN_WARNING,
1702                                         "qc timeout (cmd 0x%x)\n", command);
1703                 }
1704
1705                 spin_unlock_irqrestore(ap->lock, flags);
1706         }
1707
1708         /* do post_internal_cmd */
1709         if (ap->ops->post_internal_cmd)
1710                 ap->ops->post_internal_cmd(qc);
1711
1712         /* perform minimal error analysis */
1713         if (qc->flags & ATA_QCFLAG_FAILED) {
1714                 if (qc->result_tf.command & (ATA_ERR | ATA_DF))
1715                         qc->err_mask |= AC_ERR_DEV;
1716
1717                 if (!qc->err_mask)
1718                         qc->err_mask |= AC_ERR_OTHER;
1719
1720                 if (qc->err_mask & ~AC_ERR_OTHER)
1721                         qc->err_mask &= ~AC_ERR_OTHER;
1722         }
1723
1724         /* finish up */
1725         spin_lock_irqsave(ap->lock, flags);
1726
1727         *tf = qc->result_tf;
1728         err_mask = qc->err_mask;
1729
1730         ata_qc_free(qc);
1731         link->active_tag = preempted_tag;
1732         link->sactive = preempted_sactive;
1733         ap->qc_active = preempted_qc_active;
1734         ap->nr_active_links = preempted_nr_active_links;
1735
1736         /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1737          * Until those drivers are fixed, we detect the condition
1738          * here, fail the command with AC_ERR_SYSTEM and reenable the
1739          * port.
1740          *
1741          * Note that this doesn't change any behavior as internal
1742          * command failure results in disabling the device in the
1743          * higher layer for LLDDs without new reset/EH callbacks.
1744          *
1745          * Kill the following code as soon as those drivers are fixed.
1746          */
1747         if (ap->flags & ATA_FLAG_DISABLED) {
1748                 err_mask |= AC_ERR_SYSTEM;
1749                 ata_port_probe(ap);
1750         }
1751
1752         spin_unlock_irqrestore(ap->lock, flags);
1753
1754         return err_mask;
1755 }
1756
1757 /**
1758  *      ata_exec_internal - execute libata internal command
1759  *      @dev: Device to which the command is sent
1760  *      @tf: Taskfile registers for the command and the result
1761  *      @cdb: CDB for packet command
1762  *      @dma_dir: Data tranfer direction of the command
1763  *      @buf: Data buffer of the command
1764  *      @buflen: Length of data buffer
1765  *      @timeout: Timeout in msecs (0 for default)
1766  *
1767  *      Wrapper around ata_exec_internal_sg() which takes simple
1768  *      buffer instead of sg list.
1769  *
1770  *      LOCKING:
1771  *      None.  Should be called with kernel context, might sleep.
1772  *
1773  *      RETURNS:
1774  *      Zero on success, AC_ERR_* mask on failure
1775  */
1776 unsigned ata_exec_internal(struct ata_device *dev,
1777                            struct ata_taskfile *tf, const u8 *cdb,
1778                            int dma_dir, void *buf, unsigned int buflen,
1779                            unsigned long timeout)
1780 {
1781         struct scatterlist *psg = NULL, sg;
1782         unsigned int n_elem = 0;
1783
1784         if (dma_dir != DMA_NONE) {
1785                 WARN_ON(!buf);
1786                 sg_init_one(&sg, buf, buflen);
1787                 psg = &sg;
1788                 n_elem++;
1789         }
1790
1791         return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
1792                                     timeout);
1793 }
1794
1795 /**
1796  *      ata_do_simple_cmd - execute simple internal command
1797  *      @dev: Device to which the command is sent
1798  *      @cmd: Opcode to execute
1799  *
1800  *      Execute a 'simple' command, that only consists of the opcode
1801  *      'cmd' itself, without filling any other registers
1802  *
1803  *      LOCKING:
1804  *      Kernel thread context (may sleep).
1805  *
1806  *      RETURNS:
1807  *      Zero on success, AC_ERR_* mask on failure
1808  */
1809 unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
1810 {
1811         struct ata_taskfile tf;
1812
1813         ata_tf_init(dev, &tf);
1814
1815         tf.command = cmd;
1816         tf.flags |= ATA_TFLAG_DEVICE;
1817         tf.protocol = ATA_PROT_NODATA;
1818
1819         return ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1820 }
1821
1822 /**
1823  *      ata_pio_need_iordy      -       check if iordy needed
1824  *      @adev: ATA device
1825  *
1826  *      Check if the current speed of the device requires IORDY. Used
1827  *      by various controllers for chip configuration.
1828  */
1829
1830 unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1831 {
1832         /* Controller doesn't support  IORDY. Probably a pointless check
1833            as the caller should know this */
1834         if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1835                 return 0;
1836         /* PIO3 and higher it is mandatory */
1837         if (adev->pio_mode > XFER_PIO_2)
1838                 return 1;
1839         /* We turn it on when possible */
1840         if (ata_id_has_iordy(adev->id))
1841                 return 1;
1842         return 0;
1843 }
1844
1845 /**
1846  *      ata_pio_mask_no_iordy   -       Return the non IORDY mask
1847  *      @adev: ATA device
1848  *
1849  *      Compute the highest mode possible if we are not using iordy. Return
1850  *      -1 if no iordy mode is available.
1851  */
1852
1853 static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
1854 {
1855         /* If we have no drive specific rule, then PIO 2 is non IORDY */
1856         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1857                 u16 pio = adev->id[ATA_ID_EIDE_PIO];
1858                 /* Is the speed faster than the drive allows non IORDY ? */
1859                 if (pio) {
1860                         /* This is cycle times not frequency - watch the logic! */
1861                         if (pio > 240)  /* PIO2 is 240nS per cycle */
1862                                 return 3 << ATA_SHIFT_PIO;
1863                         return 7 << ATA_SHIFT_PIO;
1864                 }
1865         }
1866         return 3 << ATA_SHIFT_PIO;
1867 }
1868
1869 /**
1870  *      ata_dev_read_id - Read ID data from the specified device
1871  *      @dev: target device
1872  *      @p_class: pointer to class of the target device (may be changed)
1873  *      @flags: ATA_READID_* flags
1874  *      @id: buffer to read IDENTIFY data into
1875  *
1876  *      Read ID data from the specified device.  ATA_CMD_ID_ATA is
1877  *      performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
1878  *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
1879  *      for pre-ATA4 drives.
1880  *
1881  *      FIXME: ATA_CMD_ID_ATA is optional for early drives and right
1882  *      now we abort if we hit that case.
1883  *
1884  *      LOCKING:
1885  *      Kernel thread context (may sleep)
1886  *
1887  *      RETURNS:
1888  *      0 on success, -errno otherwise.
1889  */
1890 int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
1891                     unsigned int flags, u16 *id)
1892 {
1893         struct ata_port *ap = dev->link->ap;
1894         unsigned int class = *p_class;
1895         struct ata_taskfile tf;
1896         unsigned int err_mask = 0;
1897         const char *reason;
1898         int may_fallback = 1, tried_spinup = 0;
1899         int rc;
1900
1901         if (ata_msg_ctl(ap))
1902                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
1903
1904         ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1905  retry:
1906         ata_tf_init(dev, &tf);
1907
1908         switch (class) {
1909         case ATA_DEV_ATA:
1910                 tf.command = ATA_CMD_ID_ATA;
1911                 break;
1912         case ATA_DEV_ATAPI:
1913                 tf.command = ATA_CMD_ID_ATAPI;
1914                 break;
1915         default:
1916                 rc = -ENODEV;
1917                 reason = "unsupported class";
1918                 goto err_out;
1919         }
1920
1921         tf.protocol = ATA_PROT_PIO;
1922
1923         /* Some devices choke if TF registers contain garbage.  Make
1924          * sure those are properly initialized.
1925          */
1926         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1927
1928         /* Device presence detection is unreliable on some
1929          * controllers.  Always poll IDENTIFY if available.
1930          */
1931         tf.flags |= ATA_TFLAG_POLLING;
1932
1933         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1934                                      id, sizeof(id[0]) * ATA_ID_WORDS, 0);
1935         if (err_mask) {
1936                 if (err_mask & AC_ERR_NODEV_HINT) {
1937                         DPRINTK("ata%u.%d: NODEV after polling detection\n",
1938                                 ap->print_id, dev->devno);
1939                         return -ENOENT;
1940                 }
1941
1942                 /* Device or controller might have reported the wrong
1943                  * device class.  Give a shot at the other IDENTIFY if
1944                  * the current one is aborted by the device.
1945                  */
1946                 if (may_fallback &&
1947                     (err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
1948                         may_fallback = 0;
1949
1950                         if (class == ATA_DEV_ATA)
1951                                 class = ATA_DEV_ATAPI;
1952                         else
1953                                 class = ATA_DEV_ATA;
1954                         goto retry;
1955                 }
1956
1957                 rc = -EIO;
1958                 reason = "I/O error";
1959                 goto err_out;
1960         }
1961
1962         /* Falling back doesn't make sense if ID data was read
1963          * successfully at least once.
1964          */
1965         may_fallback = 0;
1966
1967         swap_buf_le16(id, ATA_ID_WORDS);
1968
1969         /* sanity check */
1970         rc = -EINVAL;
1971         reason = "device reports invalid type";
1972
1973         if (class == ATA_DEV_ATA) {
1974                 if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
1975                         goto err_out;
1976         } else {
1977                 if (ata_id_is_ata(id))
1978                         goto err_out;
1979         }
1980
1981         if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
1982                 tried_spinup = 1;
1983                 /*
1984                  * Drive powered-up in standby mode, and requires a specific
1985                  * SET_FEATURES spin-up subcommand before it will accept
1986                  * anything other than the original IDENTIFY command.
1987                  */
1988                 err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);
1989                 if (err_mask && id[2] != 0x738c) {
1990                         rc = -EIO;
1991                         reason = "SPINUP failed";
1992                         goto err_out;
1993                 }
1994                 /*
1995                  * If the drive initially returned incomplete IDENTIFY info,
1996                  * we now must reissue the IDENTIFY command.
1997                  */
1998                 if (id[2] == 0x37c8)
1999                         goto retry;
2000         }
2001
2002         if ((flags & ATA_READID_POSTRESET) && class == ATA_DEV_ATA) {
2003                 /*
2004                  * The exact sequence expected by certain pre-ATA4 drives is:
2005                  * SRST RESET
2006                  * IDENTIFY (optional in early ATA)
2007                  * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
2008                  * anything else..
2009                  * Some drives were very specific about that exact sequence.
2010                  *
2011                  * Note that ATA4 says lba is mandatory so the second check
2012                  * shoud never trigger.
2013                  */
2014                 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
2015                         err_mask = ata_dev_init_params(dev, id[3], id[6]);
2016                         if (err_mask) {
2017                                 rc = -EIO;
2018                                 reason = "INIT_DEV_PARAMS failed";
2019                                 goto err_out;
2020                         }
2021
2022                         /* current CHS translation info (id[53-58]) might be
2023                          * changed. reread the identify device info.
2024                          */
2025                         flags &= ~ATA_READID_POSTRESET;
2026                         goto retry;
2027                 }
2028         }
2029
2030         *p_class = class;
2031
2032         return 0;
2033
2034  err_out:
2035         if (ata_msg_warn(ap))
2036                 ata_dev_printk(dev, KERN_WARNING, "failed to IDENTIFY "
2037                                "(%s, err_mask=0x%x)\n", reason, err_mask);
2038         return rc;
2039 }
2040
2041 static inline u8 ata_dev_knobble(struct ata_device *dev)
2042 {
2043         struct ata_port *ap = dev->link->ap;
2044         return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
2045 }
2046
2047 static void ata_dev_config_ncq(struct ata_device *dev,
2048                                char *desc, size_t desc_sz)
2049 {
2050         struct ata_port *ap = dev->link->ap;
2051         int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
2052
2053         if (!ata_id_has_ncq(dev->id)) {
2054                 desc[0] = '\0';
2055                 return;
2056         }
2057         if (dev->horkage & ATA_HORKAGE_NONCQ) {
2058                 snprintf(desc, desc_sz, "NCQ (not used)");
2059                 return;
2060         }
2061         if (ap->flags & ATA_FLAG_NCQ) {
2062                 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE - 1);
2063                 dev->flags |= ATA_DFLAG_NCQ;
2064         }
2065
2066         if (hdepth >= ddepth)
2067                 snprintf(desc, desc_sz, "NCQ (depth %d)", ddepth);
2068         else
2069                 snprintf(desc, desc_sz, "NCQ (depth %d/%d)", hdepth, ddepth);
2070 }
2071
2072 /**
2073  *      ata_dev_configure - Configure the specified ATA/ATAPI device
2074  *      @dev: Target device to configure
2075  *
2076  *      Configure @dev according to @dev->id.  Generic and low-level
2077  *      driver specific fixups are also applied.
2078  *
2079  *      LOCKING:
2080  *      Kernel thread context (may sleep)
2081  *
2082  *      RETURNS:
2083  *      0 on success, -errno otherwise
2084  */
2085 int ata_dev_configure(struct ata_device *dev)
2086 {
2087         struct ata_port *ap = dev->link->ap;
2088         struct ata_eh_context *ehc = &dev->link->eh_context;
2089         int print_info = ehc->i.flags & ATA_EHI_PRINTINFO;
2090         const u16 *id = dev->id;
2091         unsigned int xfer_mask;
2092         char revbuf[7];         /* XYZ-99\0 */
2093         char fwrevbuf[ATA_ID_FW_REV_LEN+1];
2094         char modelbuf[ATA_ID_PROD_LEN+1];
2095         int rc;
2096
2097         if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
2098                 ata_dev_printk(dev, KERN_INFO, "%s: ENTER/EXIT -- nodev\n",
2099                                __FUNCTION__);
2100                 return 0;
2101         }
2102
2103         if (ata_msg_probe(ap))
2104                 ata_dev_printk(dev, KERN_DEBUG, "%s: ENTER\n", __FUNCTION__);
2105
2106         /* set horkage */
2107         dev->horkage |= ata_dev_blacklisted(dev);
2108
2109         /* let ACPI work its magic */
2110         rc = ata_acpi_on_devcfg(dev);
2111         if (rc)
2112                 return rc;
2113
2114         /* massage HPA, do it early as it might change IDENTIFY data */
2115         rc = ata_hpa_resize(dev);
2116         if (rc)
2117                 return rc;
2118
2119         /* print device capabilities */
2120         if (ata_msg_probe(ap))
2121                 ata_dev_printk(dev, KERN_DEBUG,
2122                                "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
2123                                "85:%04x 86:%04x 87:%04x 88:%04x\n",
2124                                __FUNCTION__,
2125                                id[49], id[82], id[83], id[84],
2126                                id[85], id[86], id[87], id[88]);
2127
2128         /* initialize to-be-configured parameters */
2129         dev->flags &= ~ATA_DFLAG_CFG_MASK;
2130         dev->max_sectors = 0;
2131         dev->cdb_len = 0;
2132         dev->n_sectors = 0;
2133         dev->cylinders = 0;
2134         dev->heads = 0;
2135         dev->sectors = 0;
2136
2137         /*
2138          * common ATA, ATAPI feature tests
2139          */
2140
2141         /* find max transfer mode; for printk only */
2142         xfer_mask = ata_id_xfermask(id);
2143
2144         if (ata_msg_probe(ap))
2145                 ata_dump_id(id);
2146
2147         /* SCSI only uses 4-char revisions, dump full 8 chars from ATA */
2148         ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
2149                         sizeof(fwrevbuf));
2150
2151         ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
2152                         sizeof(modelbuf));
2153
2154         /* ATA-specific feature tests */
2155         if (dev->class == ATA_DEV_ATA) {
2156                 if (ata_id_is_cfa(id)) {
2157                         if (id[162] & 1) /* CPRM may make this media unusable */
2158                                 ata_dev_printk(dev, KERN_WARNING,
2159                                                "supports DRM functions and may "
2160                                                "not be fully accessable.\n");
2161                         snprintf(revbuf, 7, "CFA");
2162                 } else
2163                         snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
2164
2165                 dev->n_sectors = ata_id_n_sectors(id);
2166
2167                 if (dev->id[59] & 0x100)
2168                         dev->multi_count = dev->id[59] & 0xff;
2169
2170                 if (ata_id_has_lba(id)) {
2171                         const char *lba_desc;
2172                         char ncq_desc[20];
2173
2174                         lba_desc = "LBA";
2175                         dev->flags |= ATA_DFLAG_LBA;
2176                         if (ata_id_has_lba48(id)) {
2177                                 dev->flags |= ATA_DFLAG_LBA48;
2178                                 lba_desc = "LBA48";
2179
2180                                 if (dev->n_sectors >= (1UL << 28) &&
2181                                     ata_id_has_flush_ext(id))
2182                                         dev->flags |= ATA_DFLAG_FLUSH_EXT;
2183                         }
2184
2185                         /* config NCQ */
2186                         ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
2187
2188                         /* print device info to dmesg */
2189                         if (ata_msg_drv(ap) && print_info) {
2190                                 ata_dev_printk(dev, KERN_INFO,
2191                                         "%s: %s, %s, max %s\n",
2192                                         revbuf, modelbuf, fwrevbuf,
2193                                         ata_mode_string(xfer_mask));
2194                                 ata_dev_printk(dev, KERN_INFO,
2195                                         "%Lu sectors, multi %u: %s %s\n",
2196                                         (unsigned long long)dev->n_sectors,
2197                                         dev->multi_count, lba_desc, ncq_desc);
2198                         }
2199                 } else {
2200                         /* CHS */
2201
2202                         /* Default translation */
2203                         dev->cylinders  = id[1];
2204                         dev->heads      = id[3];
2205                         dev->sectors    = id[6];
2206
2207                         if (ata_id_current_chs_valid(id)) {
2208                                 /* Current CHS translation is valid. */
2209                                 dev->cylinders = id[54];
2210                                 dev->heads     = id[55];
2211                                 dev->sectors   = id[56];
2212                         }
2213
2214                         /* print device info to dmesg */
2215                         if (ata_msg_drv(ap) && print_info) {
2216                                 ata_dev_printk(dev, KERN_INFO,
2217                                         "%s: %s, %s, max %s\n",
2218                                         revbuf, modelbuf, fwrevbuf,
2219                                         ata_mode_string(xfer_mask));
2220                                 ata_dev_printk(dev, KERN_INFO,
2221                                         "%Lu sectors, multi %u, CHS %u/%u/%u\n",
2222                                         (unsigned long long)dev->n_sectors,
2223                                         dev->multi_count, dev->cylinders,
2224                                         dev->heads, dev->sectors);
2225                         }
2226                 }
2227
2228                 dev->cdb_len = 16;
2229         }
2230
2231         /* ATAPI-specific feature tests */
2232         else if (dev->class == ATA_DEV_ATAPI) {
2233                 const char *cdb_intr_string = "";
2234                 const char *atapi_an_string = "";
2235                 u32 sntf;
2236
2237                 rc = atapi_cdb_len(id);
2238                 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
2239                         if (ata_msg_warn(ap))
2240                                 ata_dev_printk(dev, KERN_WARNING,
2241                                                "unsupported CDB len\n");
2242                         rc = -EINVAL;
2243                         goto err_out_nosup;
2244                 }
2245                 dev->cdb_len = (unsigned int) rc;
2246
2247                 /* Enable ATAPI AN if both the host and device have
2248                  * the support.  If PMP is attached, SNTF is required
2249                  * to enable ATAPI AN to discern between PHY status
2250                  * changed notifications and ATAPI ANs.
2251                  */
2252                 if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
2253                     (!ap->nr_pmp_links ||
2254                      sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
2255                         unsigned int err_mask;
2256
2257                         /* issue SET feature command to turn this on */
2258                         err_mask = ata_dev_set_feature(dev,
2259                                         SETFEATURES_SATA_ENABLE, SATA_AN);
2260                         if (err_mask)
2261                                 ata_dev_printk(dev, KERN_ERR,
2262                                         "failed to enable ATAPI AN "
2263                                         "(err_mask=0x%x)\n", err_mask);
2264                         else {
2265                                 dev->flags |= ATA_DFLAG_AN;
2266                                 atapi_an_string = ", ATAPI AN";
2267                         }
2268                 }
2269
2270                 if (ata_id_cdb_intr(dev->id)) {
2271                         dev->flags |= ATA_DFLAG_CDB_INTR;
2272                         cdb_intr_string = ", CDB intr";
2273                 }
2274
2275                 /* print device info to dmesg */
2276                 if (ata_msg_drv(ap) && print_info)
2277                         ata_dev_printk(dev, KERN_INFO,
2278                                        "ATAPI: %s, %s, max %s%s%s\n",
2279                                        modelbuf, fwrevbuf,
2280                                        ata_mode_string(xfer_mask),
2281                                        cdb_intr_string, atapi_an_string);
2282         }
2283
2284         /* determine max_sectors */
2285         dev->max_sectors = ATA_MAX_SECTORS;
2286         if (dev->flags & ATA_DFLAG_LBA48)
2287                 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2288
2289         if (!(dev->horkage & ATA_HORKAGE_IPM)) {
2290                 if (ata_id_has_hipm(dev->id))
2291                         dev->flags |= ATA_DFLAG_HIPM;
2292                 if (ata_id_has_dipm(dev->id))
2293                         dev->flags |= ATA_DFLAG_DIPM;
2294         }
2295
2296         if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
2297                 /* Let the user know. We don't want to disallow opens for
2298                    rescue purposes, or in case the vendor is just a blithering
2299                    idiot */
2300                 if (print_info) {
2301                         ata_dev_printk(dev, KERN_WARNING,
2302 "Drive reports diagnostics failure. This may indicate a drive\n");
2303                         ata_dev_printk(dev, KERN_WARNING,
2304 "fault or invalid emulation. Contact drive vendor for information.\n");
2305                 }
2306         }
2307
2308         /* limit bridge transfers to udma5, 200 sectors */
2309         if (ata_dev_knobble(dev)) {
2310                 if (ata_msg_drv(ap) && print_info)
2311                         ata_dev_printk(dev, KERN_INFO,
2312                                        "applying bridge limits\n");
2313                 dev->udma_mask &= ATA_UDMA5;
2314                 dev->max_sectors = ATA_MAX_SECTORS;
2315         }
2316
2317         if ((dev->class == ATA_DEV_ATAPI) &&
2318             (atapi_command_packet_set(id) == TYPE_TAPE)) {
2319                 dev->max_sectors = ATA_MAX_SECTORS_TAPE;
2320                 dev->horkage |= ATA_HORKAGE_STUCK_ERR;
2321         }
2322
2323         if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
2324                 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
2325                                          dev->max_sectors);
2326
2327         if (ata_dev_blacklisted(dev) & ATA_HORKAGE_IPM) {
2328                 dev->horkage |= ATA_HORKAGE_IPM;
2329
2330                 /* reset link pm_policy for this port to no pm */
2331                 ap->pm_policy = MAX_PERFORMANCE;
2332         }
2333
2334         if (ap->ops->dev_config)
2335                 ap->ops->dev_config(dev);
2336
2337         if (ata_msg_probe(ap))
2338                 ata_dev_printk(dev, KERN_DEBUG, "%s: EXIT, drv_stat = 0x%x\n",
2339                         __FUNCTION__, ata_chk_status(ap));
2340         return 0;
2341
2342 err_out_nosup:
2343         if (ata_msg_probe(ap))
2344                 ata_dev_printk(dev, KERN_DEBUG,
2345                                "%s: EXIT, err\n", __FUNCTION__);
2346         return rc;
2347 }
2348
2349 /**
2350  *      ata_cable_40wire        -       return 40 wire cable type
2351  *      @ap: port
2352  *
2353  *      Helper method for drivers which want to hardwire 40 wire cable
2354  *      detection.
2355  */
2356
2357 int ata_cable_40wire(struct ata_port *ap)
2358 {
2359         return ATA_CBL_PATA40;
2360 }
2361
2362 /**
2363  *      ata_cable_80wire        -       return 80 wire cable type
2364  *      @ap: port
2365  *
2366  *      Helper method for drivers which want to hardwire 80 wire cable
2367  *      detection.
2368  */
2369
2370 int ata_cable_80wire(struct ata_port *ap)
2371 {
2372         return ATA_CBL_PATA80;
2373 }
2374
2375 /**
2376  *      ata_cable_unknown       -       return unknown PATA cable.
2377  *      @ap: port
2378  *
2379  *      Helper method for drivers which have no PATA cable detection.
2380  */
2381
2382 int ata_cable_unknown(struct ata_port *ap)
2383 {
2384         return ATA_CBL_PATA_UNK;
2385 }
2386
2387 /**
2388  *      ata_cable_sata  -       return SATA cable type
2389  *      @ap: port
2390  *
2391  *      Helper method for drivers which have SATA cables
2392  */
2393
2394 int ata_cable_sata(struct ata_port *ap)
2395 {
2396         return ATA_CBL_SATA;
2397 }
2398
2399 /**
2400  *      ata_bus_probe - Reset and probe ATA bus
2401  *      @ap: Bus to probe
2402  *
2403  *      Master ATA bus probing function.  Initiates a hardware-dependent
2404  *      bus reset, then attempts to identify any devices found on
2405  *      the bus.
2406  *
2407  *      LOCKING:
2408  *      PCI/etc. bus probe sem.
2409  *
2410  *      RETURNS:
2411  *      Zero on success, negative errno otherwise.
2412  */
2413
2414 int ata_bus_probe(struct ata_port *ap)
2415 {
2416         unsigned int classes[ATA_MAX_DEVICES];
2417         int tries[ATA_MAX_DEVICES];
2418         int rc;
2419         struct ata_device *dev;
2420
2421         ata_port_probe(ap);
2422
2423         ata_link_for_each_dev(dev, &ap->link)
2424                 tries[dev->devno] = ATA_PROBE_MAX_TRIES;
2425
2426  retry:
2427         ata_link_for_each_dev(dev, &ap->link) {
2428                 /* If we issue an SRST then an ATA drive (not ATAPI)
2429                  * may change configuration and be in PIO0 timing. If
2430                  * we do a hard reset (or are coming from power on)
2431                  * this is true for ATA or ATAPI. Until we've set a
2432                  * suitable controller mode we should not touch the
2433                  * bus as we may be talking too fast.
2434                  */
2435                 dev->pio_mode = XFER_PIO_0;
2436
2437                 /* If the controller has a pio mode setup function
2438                  * then use it to set the chipset to rights. Don't
2439                  * touch the DMA setup as that will be dealt with when
2440                  * configuring devices.
2441                  */
2442                 if (ap->ops->set_piomode)
2443                         ap->ops->set_piomode(ap, dev);
2444         }
2445
2446         /* reset and determine device classes */
2447         ap->ops->phy_reset(ap);
2448
2449         ata_link_for_each_dev(dev, &ap->link) {
2450                 if (!(ap->flags & ATA_FLAG_DISABLED) &&
2451                     dev->class != ATA_DEV_UNKNOWN)
2452                         classes[dev->devno] = dev->class;
2453                 else
2454                         classes[dev->devno] = ATA_DEV_NONE;
2455
2456                 dev->class = ATA_DEV_UNKNOWN;
2457         }
2458
2459         ata_port_probe(ap);
2460
2461         /* read IDENTIFY page and configure devices. We have to do the identify
2462            specific sequence bass-ackwards so that PDIAG- is released by
2463            the slave device */
2464
2465         ata_link_for_each_dev(dev, &ap->link) {
2466                 if (tries[dev->devno])
2467                         dev->class = classes[dev->devno];
2468
2469                 if (!ata_dev_enabled(dev))
2470                         continue;
2471
2472                 rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET,
2473                                      dev->id);
2474                 if (rc)
2475                         goto fail;
2476         }
2477
2478         /* Now ask for the cable type as PDIAG- should have been released */
2479         if (ap->ops->cable_detect)
2480                 ap->cbl = ap->ops->cable_detect(ap);
2481
2482         /* We may have SATA bridge glue hiding here irrespective of the
2483            reported cable types and sensed types */
2484         ata_link_for_each_dev(dev, &ap->link) {
2485                 if (!ata_dev_enabled(dev))
2486                         continue;
2487                 /* SATA drives indicate we have a bridge. We don't know which
2488                    end of the link the bridge is which is a problem */
2489                 if (ata_id_is_sata(dev->id))
2490                         ap->cbl = ATA_CBL_SATA;
2491         }
2492
2493         /* After the identify sequence we can now set up the devices. We do
2494            this in the normal order so that the user doesn't get confused */
2495
2496         ata_link_for_each_dev(dev, &ap->link) {
2497                 if (!ata_dev_enabled(dev))
2498                         continue;
2499
2500                 ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
2501                 rc = ata_dev_configure(dev);
2502                 ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
2503                 if (rc)
2504                         goto fail;
2505         }
2506
2507         /* configure transfer mode */
2508         rc = ata_set_mode(&ap->link, &dev);
2509         if (rc)
2510                 goto fail;
2511
2512         ata_link_for_each_dev(dev, &ap->link)
2513                 if (ata_dev_enabled(dev))
2514                         return 0;
2515
2516         /* no device present, disable port */
2517         ata_port_disable(ap);
2518         return -ENODEV;
2519
2520  fail:
2521         tries[dev->devno]--;
2522
2523         switch (rc) {
2524         case -EINVAL:
2525                 /* eeek, something went very wrong, give up */
2526                 tries[dev->devno] = 0;
2527                 break;
2528
2529         case -ENODEV:
2530                 /* give it just one more chance */
2531                 tries[dev->devno] = min(tries[dev->devno], 1);
2532         case -EIO:
2533                 if (tries[dev->devno] == 1) {
2534                         /* This is the last chance, better to slow
2535                          * down than lose it.
2536                          */
2537                         sata_down_spd_limit(&ap->link);
2538                         ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
2539                 }
2540         }
2541
2542         if (!tries[dev->devno])
2543                 ata_dev_disable(dev);
2544
2545         goto retry;
2546 }
2547
2548 /**
2549  *      ata_port_probe - Mark port as enabled
2550  *      @ap: Port for which we indicate enablement
2551  *
2552  *      Modify @ap data structure such that the system
2553  *      thinks that the entire port is enabled.
2554  *
2555  *      LOCKING: host lock, or some other form of
2556  *      serialization.
2557  */
2558
2559 void ata_port_probe(struct ata_port *ap)
2560 {
2561         ap->flags &= ~ATA_FLAG_DISABLED;
2562 }
2563
2564 /**
2565  *      sata_print_link_status - Print SATA link status
2566  *      @link: SATA link to printk link status about
2567  *
2568  *      This function prints link speed and status of a SATA link.
2569  *
2570  *      LOCKING:
2571  *      None.
2572  */
2573 void sata_print_link_status(struct ata_link *link)
2574 {
2575         u32 sstatus, scontrol, tmp;
2576
2577         if (sata_scr_read(link, SCR_STATUS, &sstatus))
2578                 return;
2579         sata_scr_read(link, SCR_CONTROL, &scontrol);
2580
2581         if (ata_link_online(link)) {
2582                 tmp = (sstatus >> 4) & 0xf;
2583                 ata_link_printk(link, KERN_INFO,
2584                                 "SATA link up %s (SStatus %X SControl %X)\n",
2585                                 sata_spd_string(tmp), sstatus, scontrol);
2586         } else {
2587                 ata_link_printk(link, KERN_INFO,
2588                                 "SATA link down (SStatus %X SControl %X)\n",
2589                                 sstatus, scontrol);
2590         }
2591 }
2592
2593 /**
2594  *      ata_dev_pair            -       return other device on cable
2595  *      @adev: device
2596  *
2597  *      Obtain the other device on the same cable, or if none is
2598  *      present NULL is returned
2599  */
2600
2601 struct ata_device *ata_dev_pair(struct ata_device *adev)
2602 {
2603         struct ata_link *link = adev->link;
2604         struct ata_device *pair = &link->device[1 - adev->devno];
2605         if (!ata_dev_enabled(pair))
2606                 return NULL;
2607         return pair;
2608 }
2609
2610 /**
2611  *      ata_port_disable - Disable port.
2612  *      @ap: Port to be disabled.
2613  *
2614  *      Modify @ap data structure such that the system
2615  *      thinks that the entire port is disabled, and should
2616  *      never attempt to probe or communicate with devices
2617  *      on this port.
2618  *
2619  *      LOCKING: host lock, or some other form of
2620  *      serialization.
2621  */
2622
2623 void ata_port_disable(struct ata_port *ap)
2624 {
2625         ap->link.device[0].class = ATA_DEV_NONE;
2626         ap->link.device[1].class = ATA_DEV_NONE;
2627         ap->flags |= ATA_FLAG_DISABLED;
2628 }
2629
2630 /**
2631  *      sata_down_spd_limit - adjust SATA spd limit downward
2632  *      @link: Link to adjust SATA spd limit for
2633  *
2634  *      Adjust SATA spd limit of @link downward.  Note that this
2635  *      function only adjusts the limit.  The change must be applied
2636  *      using sata_set_spd().
2637  *
2638  *      LOCKING:
2639  *      Inherited from caller.
2640  *
2641  *      RETURNS:
2642  *      0 on success, negative errno on failure
2643  */
2644 int sata_down_spd_limit(struct ata_link *link)
2645 {
2646         u32 sstatus, spd, mask;
2647         int rc, highbit;
2648
2649         if (!sata_scr_valid(link))
2650                 return -EOPNOTSUPP;
2651
2652         /* If SCR can be read, use it to determine the current SPD.
2653          * If not, use cached value in link->sata_spd.
2654          */
2655         rc = sata_scr_read(link, SCR_STATUS, &sstatus);
2656         if (rc == 0)
2657                 spd = (sstatus >> 4) & 0xf;
2658         else
2659                 spd = link->sata_spd;
2660
2661         mask = link->sata_spd_limit;
2662         if (mask <= 1)
2663                 return -EINVAL;
2664
2665         /* unconditionally mask off the highest bit */
2666         highbit = fls(mask) - 1;
2667         mask &= ~(1 << highbit);
2668
2669         /* Mask off all speeds higher than or equal to the current
2670          * one.  Force 1.5Gbps if current SPD is not available.
2671          */
2672         if (spd > 1)
2673                 mask &= (1 << (spd - 1)) - 1;
2674         else
2675                 mask &= 1;
2676
2677         /* were we already at the bottom? */
2678         if (!mask)
2679                 return -EINVAL;
2680
2681         link->sata_spd_limit = mask;
2682
2683         ata_link_printk(link, KERN_WARNING, "limiting SATA link speed to %s\n",
2684                         sata_spd_string(fls(mask)));
2685
2686         return 0;
2687 }
2688
2689 static int __sata_set_spd_needed(struct ata_link *link, u32 *scontrol)
2690 {
2691         struct ata_link *host_link = &link->ap->link;
2692         u32 limit, target, spd;
2693
2694         limit = link->sata_spd_limit;
2695
2696         /* Don't configure downstream link faster than upstream link.
2697          * It doesn't speed up anything and some PMPs choke on such
2698          * configuration.
2699          */
2700         if (!ata_is_host_link(link) && host_link->sata_spd)
2701                 limit &= (1 << host_link->sata_spd) - 1;
2702
2703         if (limit == UINT_MAX)
2704                 target = 0;
2705         else
2706                 target = fls(limit);
2707
2708         spd = (*scontrol >> 4) & 0xf;
2709         *scontrol = (*scontrol & ~0xf0) | ((target & 0xf) << 4);
2710
2711         return spd != target;
2712 }
2713
2714 /**
2715  *      sata_set_spd_needed - is SATA spd configuration needed
2716  *      @link: Link in question
2717  *
2718  *      Test whether the spd limit in SControl matches
2719  *      @link->sata_spd_limit.  This function is used to determine
2720  *      whether hardreset is necessary to apply SATA spd
2721  *      configuration.
2722  *
2723  *      LOCKING:
2724  *      Inherited from caller.
2725  *
2726  *      RETURNS:
2727  *      1 if SATA spd configuration is needed, 0 otherwise.
2728  */
2729 int sata_set_spd_needed(struct ata_link *link)
2730 {
2731         u32 scontrol;
2732
2733         if (sata_scr_read(link, SCR_CONTROL, &scontrol))
2734                 return 1;
2735
2736         return __sata_set_spd_needed(link, &scontrol);
2737 }
2738
2739 /**
2740  *      sata_set_spd - set SATA spd according to spd limit
2741  *      @link: Link to set SATA spd for
2742  *
2743  *      Set SATA spd of @link according to sata_spd_limit.
2744  *
2745  *      LOCKING:
2746  *      Inherited from caller.
2747  *
2748  *      RETURNS:
2749  *      0 if spd doesn't need to be changed, 1 if spd has been
2750  *      changed.  Negative errno if SCR registers are inaccessible.
2751  */
2752 int sata_set_spd(struct ata_link *link)
2753 {
2754         u32 scontrol;
2755         int rc;
2756
2757         if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
2758                 return rc;
2759
2760         if (!__sata_set_spd_needed(link, &scontrol))
2761                 return 0;
2762
2763         if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
2764                 return rc;
2765
2766         return 1;
2767 }
2768
2769 /*
2770  * This mode timing computation functionality is ported over from
2771  * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
2772  */
2773 /*
2774  * PIO 0-4, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
2775  * These were taken from ATA/ATAPI-6 standard, rev 0a, except
2776  * for UDMA6, which is currently supported only by Maxtor drives.
2777  *
2778  * For PIO 5/6 MWDMA 3/4 see the CFA specification 3.0.
2779  */
2780
2781 static const struct ata_timing ata_timing[] = {
2782
2783         { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
2784         { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
2785         { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
2786         { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
2787
2788         { XFER_MW_DMA_4,  25,   0,   0,   0,  55,  20,  80,   0 },
2789         { XFER_MW_DMA_3,  25,   0,   0,   0,  65,  25, 100,   0 },
2790         { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
2791         { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
2792         { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
2793
2794 /*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
2795
2796         { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
2797         { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
2798         { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
2799
2800         { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
2801         { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
2802         { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
2803
2804         { XFER_PIO_6,     10,  55,  20,  80,  55,  20,  80,   0 },
2805         { XFER_PIO_5,     15,  65,  25, 100,  65,  25, 100,   0 },
2806         { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
2807         { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
2808
2809         { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
2810         { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
2811         { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
2812
2813 /*      { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
2814
2815         { 0xFF }
2816 };
2817
2818 #define ENOUGH(v, unit)         (((v)-1)/(unit)+1)
2819 #define EZ(v, unit)             ((v)?ENOUGH(v, unit):0)
2820
2821 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
2822 {
2823         q->setup   = EZ(t->setup   * 1000,  T);
2824         q->act8b   = EZ(t->act8b   * 1000,  T);
2825         q->rec8b   = EZ(t->rec8b   * 1000,  T);
2826         q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
2827         q->active  = EZ(t->active  * 1000,  T);
2828         q->recover = EZ(t->recover * 1000,  T);
2829         q->cycle   = EZ(t->cycle   * 1000,  T);
2830         q->udma    = EZ(t->udma    * 1000, UT);
2831 }
2832
2833 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
2834                       struct ata_timing *m, unsigned int what)
2835 {
2836         if (what & ATA_TIMING_SETUP  ) m->setup   = max(a->setup,   b->setup);
2837         if (what & ATA_TIMING_ACT8B  ) m->act8b   = max(a->act8b,   b->act8b);
2838         if (what & ATA_TIMING_REC8B  ) m->rec8b   = max(a->rec8b,   b->rec8b);
2839         if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
2840         if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
2841         if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
2842         if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
2843         if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
2844 }
2845
2846 static const struct ata_timing *ata_timing_find_mode(unsigned short speed)
2847 {
2848         const struct ata_timing *t;
2849
2850         for (t = ata_timing; t->mode != speed; t++)
2851                 if (t->mode == 0xFF)
2852                         return NULL;
2853         return t;
2854 }
2855
2856 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
2857                        struct ata_timing *t, int T, int UT)
2858 {
2859         const struct ata_timing *s;
2860         struct ata_timing p;
2861
2862         /*
2863          * Find the mode.
2864          */
2865
2866         if (!(s = ata_timing_find_mode(speed)))
2867                 return -EINVAL;
2868
2869         memcpy(t, s, sizeof(*s));
2870
2871         /*
2872          * If the drive is an EIDE drive, it can tell us it needs extended
2873          * PIO/MW_DMA cycle timing.
2874          */
2875
2876         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
2877                 memset(&p, 0, sizeof(p));
2878                 if (speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
2879                         if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
2880                                             else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
2881                 } else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
2882                         p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
2883                 }
2884                 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
2885         }
2886
2887         /*
2888          * Convert the timing to bus clock counts.
2889          */
2890
2891         ata_timing_quantize(t, t, T, UT);
2892
2893         /*
2894          * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
2895          * S.M.A.R.T * and some other commands. We have to ensure that the
2896          * DMA cycle timing is slower/equal than the fastest PIO timing.
2897          */
2898
2899         if (speed > XFER_PIO_6) {
2900                 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
2901                 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
2902         }
2903
2904         /*
2905          * Lengthen active & recovery time so that cycle time is correct.
2906          */
2907
2908         if (t->act8b + t->rec8b < t->cyc8b) {
2909                 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
2910                 t->rec8b = t->cyc8b - t->act8b;
2911         }
2912
2913         if (t->active + t->recover < t->cycle) {
2914                 t->active += (t->cycle - (t->active + t->recover)) / 2;
2915                 t->recover = t->cycle - t->active;
2916         }
2917
2918         /* In a few cases quantisation may produce enough errors to
2919            leave t->cycle too low for the sum of active and recovery
2920            if so we must correct this */
2921         if (t->active + t->recover > t->cycle)
2922                 t->cycle = t->active + t->recover;
2923
2924         return 0;
2925 }
2926
2927 /**
2928  *      ata_down_xfermask_limit - adjust dev xfer masks downward
2929  *      @dev: Device to adjust xfer masks
2930  *      @sel: ATA_DNXFER_* selector
2931  *
2932  *      Adjust xfer masks of @dev downward.  Note that this function
2933  *      does not apply the change.  Invoking ata_set_mode() afterwards
2934  *      will apply the limit.
2935  *
2936  *      LOCKING:
2937  *      Inherited from caller.
2938  *
2939  *      RETURNS:
2940  *      0 on success, negative errno on failure
2941  */
2942 int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
2943 {
2944         char buf[32];
2945         unsigned int orig_mask, xfer_mask;
2946         unsigned int pio_mask, mwdma_mask, udma_mask;
2947         int quiet, highbit;
2948
2949         quiet = !!(sel & ATA_DNXFER_QUIET);
2950         sel &= ~ATA_DNXFER_QUIET;
2951
2952         xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
2953                                                   dev->mwdma_mask,
2954                                                   dev->udma_mask);
2955         ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
2956
2957         switch (sel) {
2958         case ATA_DNXFER_PIO:
2959                 highbit = fls(pio_mask) - 1;
2960                 pio_mask &= ~(1 << highbit);
2961                 break;
2962
2963         case ATA_DNXFER_DMA:
2964                 if (udma_mask) {
2965                         highbit = fls(udma_mask) - 1;
2966                         udma_mask &= ~(1 << highbit);
2967                         if (!udma_mask)
2968                                 return -ENOENT;
2969                 } else if (mwdma_mask) {
2970                         highbit = fls(mwdma_mask) - 1;
2971                         mwdma_mask &= ~(1 << highbit);
2972                         if (!mwdma_mask)
2973                                 return -ENOENT;
2974                 }
2975                 break;
2976
2977         case ATA_DNXFER_40C:
2978                 udma_mask &= ATA_UDMA_MASK_40C;
2979                 break;
2980
2981         case ATA_DNXFER_FORCE_PIO0:
2982                 pio_mask &= 1;
2983         case ATA_DNXFER_FORCE_PIO:
2984                 mwdma_mask = 0;
2985                 udma_mask = 0;
2986                 break;
2987
2988         default:
2989                 BUG();
2990         }
2991
2992         xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
2993
2994         if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
2995                 return -ENOENT;
2996
2997         if (!quiet) {
2998                 if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
2999                         snprintf(buf, sizeof(buf), "%s:%s",
3000                                  ata_mode_string(xfer_mask),
3001                                  ata_mode_string(xfer_mask & ATA_MASK_PIO));
3002                 else
3003                         snprintf(buf, sizeof(buf), "%s",
3004                                  ata_mode_string(xfer_mask));
3005
3006                 ata_dev_printk(dev, KERN_WARNING,
3007                                "limiting speed to %s\n", buf);
3008         }
3009
3010         ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
3011                             &dev->udma_mask);
3012
3013         return 0;
3014 }
3015
3016 static int ata_dev_set_mode(struct ata_device *dev)
3017 {
3018         struct ata_eh_context *ehc = &dev->link->eh_context;
3019         unsigned int err_mask;
3020         int rc;
3021
3022         dev->flags &= ~ATA_DFLAG_PIO;
3023         if (dev->xfer_shift == ATA_SHIFT_PIO)
3024                 dev->flags |= ATA_DFLAG_PIO;
3025
3026         err_mask = ata_dev_set_xfermode(dev);
3027
3028         /* Old CFA may refuse this command, which is just fine */
3029         if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id))
3030                 err_mask &= ~AC_ERR_DEV;
3031
3032         /* Some very old devices and some bad newer ones fail any kind of
3033            SET_XFERMODE request but support PIO0-2 timings and no IORDY */
3034         if (dev->xfer_shift == ATA_SHIFT_PIO && !ata_id_has_iordy(dev->id) &&
3035                         dev->pio_mode <= XFER_PIO_2)
3036                 err_mask &= ~AC_ERR_DEV;
3037
3038         /* Early MWDMA devices do DMA but don't allow DMA mode setting.
3039            Don't fail an MWDMA0 set IFF the device indicates it is in MWDMA0 */
3040         if (dev->xfer_shift == ATA_SHIFT_MWDMA &&
3041             dev->dma_mode == XFER_MW_DMA_0 &&
3042             (dev->id[63] >> 8) & 1)
3043                 err_mask &= ~AC_ERR_DEV;
3044
3045         if (err_mask) {
3046                 ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
3047                                "(err_mask=0x%x)\n", err_mask);
3048                 return -EIO;
3049         }
3050
3051         ehc->i.flags |= ATA_EHI_POST_SETMODE;
3052         rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
3053         ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
3054         if (rc)
3055                 return rc;
3056
3057         DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
3058                 dev->xfer_shift, (int)dev->xfer_mode);
3059
3060         ata_dev_printk(dev, KERN_INFO, "configured for %s\n",
3061                        ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
3062         return 0;
3063 }
3064
3065 /**
3066  *      ata_do_set_mode - Program timings and issue SET FEATURES - XFER
3067  *      @link: link on which timings will be programmed
3068  *      @r_failed_dev: out paramter for failed device
3069  *
3070  *      Standard implementation of the function used to tune and set
3071  *      ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
3072  *      ata_dev_set_mode() fails, pointer to the failing device is
3073  *      returned in @r_failed_dev.
3074  *
3075  *      LOCKING:
3076  *      PCI/etc. bus probe sem.
3077  *
3078  *      RETURNS:
3079  *      0 on success, negative errno otherwise
3080  */
3081
3082 int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3083 {
3084         struct ata_port *ap = link->ap;
3085         struct ata_device *dev;
3086         int rc = 0, used_dma = 0, found = 0;
3087
3088         /* step 1: calculate xfer_mask */
3089         ata_link_for_each_dev(dev, link) {
3090                 unsigned int pio_mask, dma_mask;
3091                 unsigned int mode_mask;
3092
3093                 if (!ata_dev_enabled(dev))
3094                         continue;
3095
3096                 mode_mask = ATA_DMA_MASK_ATA;
3097                 if (dev->class == ATA_DEV_ATAPI)
3098                         mode_mask = ATA_DMA_MASK_ATAPI;
3099                 else if (ata_id_is_cfa(dev->id))
3100                         mode_mask = ATA_DMA_MASK_CFA;
3101
3102                 ata_dev_xfermask(dev);
3103
3104                 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
3105                 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
3106
3107                 if (libata_dma_mask & mode_mask)
3108                         dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
3109                 else
3110                         dma_mask = 0;
3111
3112                 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
3113                 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
3114
3115                 found = 1;
3116                 if (dev->dma_mode)
3117                         used_dma = 1;
3118         }
3119         if (!found)
3120                 goto out;
3121
3122         /* step 2: always set host PIO timings */
3123         ata_link_for_each_dev(dev, link) {
3124                 if (!ata_dev_enabled(dev))
3125                         continue;
3126
3127                 if (!dev->pio_mode) {
3128                         ata_dev_printk(dev, KERN_WARNING, "no PIO support\n");
3129                         rc = -EINVAL;
3130                         goto out;
3131                 }
3132
3133                 dev->xfer_mode = dev->pio_mode;
3134                 dev->xfer_shift = ATA_SHIFT_PIO;
3135                 if (ap->ops->set_piomode)
3136                         ap->ops->set_piomode(ap, dev);
3137         }
3138
3139         /* step 3: set host DMA timings */
3140         ata_link_for_each_dev(dev, link) {
3141                 if (!ata_dev_enabled(dev) || !dev->dma_mode)
3142                         continue;
3143
3144                 dev->xfer_mode = dev->dma_mode;
3145                 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
3146                 if (ap->ops->set_dmamode)
3147                         ap->ops->set_dmamode(ap, dev);
3148         }
3149
3150         /* step 4: update devices' xfer mode */
3151         ata_link_for_each_dev(dev, link) {
3152                 /* don't update suspended devices' xfer mode */
3153                 if (!ata_dev_enabled(dev))
3154                         continue;
3155
3156                 rc = ata_dev_set_mode(dev);
3157                 if (rc)
3158                         goto out;
3159         }
3160
3161         /* Record simplex status. If we selected DMA then the other
3162          * host channels are not permitted to do so.
3163          */
3164         if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
3165                 ap->host->simplex_claimed = ap;
3166
3167  out:
3168         if (rc)
3169                 *r_failed_dev = dev;
3170         return rc;
3171 }
3172
3173 /**
3174  *      ata_set_mode - Program timings and issue SET FEATURES - XFER
3175  *      @link: link on which timings will be programmed
3176  *      @r_failed_dev: out paramter for failed device
3177  *
3178  *      Set ATA device disk transfer mode (PIO3, UDMA6, etc.).  If
3179  *      ata_set_mode() fails, pointer to the failing device is
3180  *      returned in @r_failed_dev.
3181  *
3182  *      LOCKING:
3183  *      PCI/etc. bus probe sem.
3184  *
3185  *      RETURNS:
3186  *      0 on success, negative errno otherwise
3187  */
3188 int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3189 {
3190         struct ata_port *ap = link->ap;
3191
3192         /* has private set_mode? */
3193         if (ap->ops->set_mode)
3194                 return ap->ops->set_mode(link, r_failed_dev);
3195         return ata_do_set_mode(link, r_failed_dev);
3196 }
3197
3198 /**
3199  *      ata_tf_to_host - issue ATA taskfile to host controller
3200  *      @ap: port to which command is being issued
3201  *      @tf: ATA taskfile register set
3202  *
3203  *      Issues ATA taskfile register set to ATA host controller,
3204  *      with proper synchronization with interrupt handler and
3205  *      other threads.
3206  *
3207  *      LOCKING:
3208  *      spin_lock_irqsave(host lock)
3209  */
3210
3211 static inline void ata_tf_to_host(struct ata_port *ap,
3212                                   const struct ata_taskfile *tf)
3213 {
3214         ap->ops->tf_load(ap, tf);
3215         ap->ops->exec_command(ap, tf);
3216 }
3217
3218 /**
3219  *      ata_busy_sleep - sleep until BSY clears, or timeout
3220  *      @ap: port containing status register to be polled
3221  *      @tmout_pat: impatience timeout
3222  *      @tmout: overall timeout
3223  *
3224  *      Sleep until ATA Status register bit BSY clears,
3225  *      or a timeout occurs.
3226  *
3227  *      LOCKING:
3228  *      Kernel thread context (may sleep).
3229  *
3230  *      RETURNS:
3231  *      0 on success, -errno otherwise.
3232  */
3233 int ata_busy_sleep(struct ata_port *ap,
3234                    unsigned long tmout_pat, unsigned long tmout)
3235 {
3236         unsigned long timer_start, timeout;
3237         u8 status;
3238
3239         status = ata_busy_wait(ap, ATA_BUSY, 300);
3240         timer_start = jiffies;
3241         timeout = timer_start + tmout_pat;
3242         while (status != 0xff && (status & ATA_BUSY) &&
3243                time_before(jiffies, timeout)) {
3244                 msleep(50);
3245                 status = ata_busy_wait(ap, ATA_BUSY, 3);
3246         }
3247
3248         if (status != 0xff && (status & ATA_BUSY))
3249                 ata_port_printk(ap, KERN_WARNING,
3250                                 "port is slow to respond, please be patient "
3251                                 "(Status 0x%x)\n", status);
3252
3253         timeout = timer_start + tmout;
3254         while (status != 0xff && (status & ATA_BUSY) &&
3255                time_before(jiffies, timeout)) {
3256                 msleep(50);
3257                 status = ata_chk_status(ap);
3258         }
3259
3260         if (status == 0xff)
3261                 return -ENODEV;
3262
3263         if (status & ATA_BUSY) {
3264                 ata_port_printk(ap, KERN_ERR, "port failed to respond "
3265                                 "(%lu secs, Status 0x%x)\n",
3266                                 tmout / HZ, status);
3267                 return -EBUSY;
3268         }
3269
3270         return 0;
3271 }
3272
3273 /**
3274  *      ata_wait_after_reset - wait before checking status after reset
3275  *      @ap: port containing status register to be polled
3276  *      @deadline: deadline jiffies for the operation
3277  *
3278  *      After reset, we need to pause a while before reading status.
3279  *      Also, certain combination of controller and device report 0xff
3280  *      for some duration (e.g. until SATA PHY is up and running)
3281  *      which is interpreted as empty port in ATA world.  This
3282  *      function also waits for such devices to get out of 0xff
3283  *      status.
3284  *
3285  *      LOCKING:
3286  *      Kernel thread context (may sleep).
3287  */
3288 void ata_wait_after_reset(struct ata_port *ap, unsigned long deadline)
3289 {
3290         unsigned long until = jiffies + ATA_TMOUT_FF_WAIT;
3291
3292         if (time_before(until, deadline))
3293                 deadline = until;
3294
3295         /* Spec mandates ">= 2ms" before checking status.  We wait
3296          * 150ms, because that was the magic delay used for ATAPI
3297          * devices in Hale Landis's ATADRVR, for the period of time
3298          * between when the ATA command register is written, and then
3299          * status is checked.  Because waiting for "a while" before
3300          * checking status is fine, post SRST, we perform this magic
3301          * delay here as well.
3302          *
3303          * Old drivers/ide uses the 2mS rule and then waits for ready.
3304          */
3305         msleep(150);
3306
3307         /* Wait for 0xff to clear.  Some SATA devices take a long time
3308          * to clear 0xff after reset.  For example, HHD424020F7SV00
3309          * iVDR needs >= 800ms while.  Quantum GoVault needs even more
3310          * than that.
3311          *
3312          * Note that some PATA controllers (pata_ali) explode if
3313          * status register is read more than once when there's no
3314          * device attached.
3315          */
3316         if (ap->flags & ATA_FLAG_SATA) {
3317                 while (1) {
3318                         u8 status = ata_chk_status(ap);
3319
3320                         if (status != 0xff || time_after(jiffies, deadline))
3321                                 return;
3322
3323                         msleep(50);
3324                 }
3325         }
3326 }
3327
3328 /**
3329  *      ata_wait_ready - sleep until BSY clears, or timeout
3330  *      @ap: port containing status register to be polled
3331  *      @deadline: deadline jiffies for the operation
3332  *
3333  *      Sleep until ATA Status register bit BSY clears, or timeout
3334  *      occurs.
3335  *
3336  *      LOCKING:
3337  *      Kernel thread context (may sleep).
3338  *
3339  *      RETURNS:
3340  *      0 on success, -errno otherwise.
3341  */
3342 int ata_wait_ready(struct ata_port *ap, unsigned long deadline)
3343 {
3344         unsigned long start = jiffies;
3345         int warned = 0;
3346
3347         while (1) {
3348                 u8 status = ata_chk_status(ap);
3349                 unsigned long now = jiffies;
3350
3351                 if (!(status & ATA_BUSY))
3352                         return 0;
3353                 if (!ata_link_online(&ap->link) && status == 0xff)
3354                         return -ENODEV;
3355                 if (time_after(now, deadline))
3356                         return -EBUSY;
3357
3358                 if (!warned && time_after(now, start + 5 * HZ) &&
3359                     (deadline - now > 3 * HZ)) {
3360                         ata_port_printk(ap, KERN_WARNING,
3361                                 "port is slow to respond, please be patient "
3362                                 "(Status 0x%x)\n", status);
3363                         warned = 1;
3364                 }
3365
3366                 msleep(50);
3367         }
3368 }
3369
3370 static int ata_bus_post_reset(struct ata_port *ap, unsigned int devmask,
3371                               unsigned long deadline)
3372 {
3373         struct ata_ioports *ioaddr = &ap->ioaddr;
3374         unsigned int dev0 = devmask & (1 << 0);
3375         unsigned int dev1 = devmask & (1 << 1);
3376         int rc, ret = 0;
3377
3378         /* if device 0 was found in ata_devchk, wait for its
3379          * BSY bit to clear
3380          */
3381         if (dev0) {
3382                 rc = ata_wait_ready(ap, deadline);
3383                 if (rc) {
3384                         if (rc != -ENODEV)
3385                                 return rc;
3386                         ret = rc;
3387                 }
3388         }
3389
3390         /* if device 1 was found in ata_devchk, wait for register
3391          * access briefly, then wait for BSY to clear.
3392          */
3393         if (dev1) {
3394                 int i;
3395
3396                 ap->ops->dev_select(ap, 1);
3397
3398                 /* Wait for register access.  Some ATAPI devices fail
3399                  * to set nsect/lbal after reset, so don't waste too
3400                  * much time on it.  We're gonna wait for !BSY anyway.
3401                  */
3402                 for (i = 0; i < 2; i++) {
3403                         u8 nsect, lbal;
3404
3405                         nsect = ioread8(ioaddr->nsect_addr);
3406                         lbal = ioread8(ioaddr->lbal_addr);
3407                         if ((nsect == 1) && (lbal == 1))
3408                                 break;
3409                         msleep(50);     /* give drive a breather */
3410                 }
3411
3412                 rc = ata_wait_ready(ap, deadline);
3413                 if (rc) {
3414                         if (rc != -ENODEV)
3415                                 return rc;
3416                         ret = rc;
3417                 }
3418         }
3419
3420         /* is all this really necessary? */
3421         ap->ops->dev_select(ap, 0);
3422         if (dev1)
3423                 ap->ops->dev_select(ap, 1);
3424         if (dev0)
3425                 ap->ops->dev_select(ap, 0);
3426
3427         return ret;
3428 }
3429
3430 static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
3431                              unsigned long deadline)
3432 {
3433         struct ata_ioports *ioaddr = &ap->ioaddr;
3434
3435         DPRINTK("ata%u: bus reset via SRST\n", ap->print_id);
3436
3437         /* software reset.  causes dev0 to be selected */
3438         iowrite8(ap->ctl, ioaddr->ctl_addr);
3439         udelay(20);     /* FIXME: flush */
3440         iowrite8(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
3441         udelay(20);     /* FIXME: flush */
3442         iowrite8(ap->ctl, ioaddr->ctl_addr);
3443
3444         /* wait a while before checking status */
3445         ata_wait_after_reset(ap, deadline);
3446
3447         /* Before we perform post reset processing we want to see if
3448          * the bus shows 0xFF because the odd clown forgets the D7
3449          * pulldown resistor.
3450          */
3451         if (ata_chk_status(ap) == 0xFF)
3452                 return -ENODEV;
3453
3454         return ata_bus_post_reset(ap, devmask, deadline);
3455 }
3456
3457 /**
3458  *      ata_bus_reset - reset host port and associated ATA channel
3459  *      @ap: port to reset
3460  *
3461  *      This is typically the first time we actually start issuing
3462  *      commands to the ATA channel.  We wait for BSY to clear, then
3463  *      issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
3464  *      result.  Determine what devices, if any, are on the channel
3465  *      by looking at the device 0/1 error register.  Look at the signature
3466  *      stored in each device's taskfile registers, to determine if
3467  *      the device is ATA or ATAPI.
3468  *
3469  *      LOCKING:
3470  *      PCI/etc. bus probe sem.
3471  *      Obtains host lock.
3472  *
3473  *      SIDE EFFECTS:
3474  *      Sets ATA_FLAG_DISABLED if bus reset fails.
3475  */
3476
3477 void ata_bus_reset(struct ata_port *ap)
3478 {
3479         struct ata_device *device = ap->link.device;
3480         struct ata_ioports *ioaddr = &ap->ioaddr;
3481         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
3482         u8 err;
3483         unsigned int dev0, dev1 = 0, devmask = 0;
3484         int rc;
3485
3486         DPRINTK("ENTER, host %u, port %u\n", ap->print_id, ap->port_no);
3487
3488         /* determine if device 0/1 are present */
3489         if (ap->flags & ATA_FLAG_SATA_RESET)
3490                 dev0 = 1;
3491         else {
3492                 dev0 = ata_devchk(ap, 0);
3493                 if (slave_possible)
3494                         dev1 = ata_devchk(ap, 1);
3495         }
3496
3497         if (dev0)
3498                 devmask |= (1 << 0);
3499         if (dev1)
3500                 devmask |= (1 << 1);
3501
3502         /* select device 0 again */
3503         ap->ops->dev_select(ap, 0);
3504
3505         /* issue bus reset */
3506         if (ap->flags & ATA_FLAG_SRST) {
3507                 rc = ata_bus_softreset(ap, devmask, jiffies + 40 * HZ);
3508                 if (rc && rc != -ENODEV)
3509                         goto err_out;
3510         }
3511
3512         /*
3513          * determine by signature whether we have ATA or ATAPI devices
3514          */
3515         device[0].class = ata_dev_try_classify(&device[0], dev0, &err);
3516         if ((slave_possible) && (err != 0x81))
3517                 device[1].class = ata_dev_try_classify(&device[1], dev1, &err);
3518
3519         /* is double-select really necessary? */
3520         if (device[1].class != ATA_DEV_NONE)
3521                 ap->ops->dev_select(ap, 1);
3522         if (device[0].class != ATA_DEV_NONE)
3523                 ap->ops->dev_select(ap, 0);
3524
3525         /* if no devices were detected, disable this port */
3526         if ((device[0].class == ATA_DEV_NONE) &&
3527             (device[1].class == ATA_DEV_NONE))
3528                 goto err_out;
3529
3530         if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
3531                 /* set up device control for ATA_FLAG_SATA_RESET */
3532                 iowrite8(ap->ctl, ioaddr->ctl_addr);
3533         }
3534
3535         DPRINTK("EXIT\n");
3536         return;
3537
3538 err_out:
3539         ata_port_printk(ap, KERN_ERR, "disabling port\n");
3540         ata_port_disable(ap);
3541
3542         DPRINTK("EXIT\n");
3543 }
3544
3545 /**
3546  *      sata_link_debounce - debounce SATA phy status
3547  *      @link: ATA link to debounce SATA phy status for
3548  *      @params: timing parameters { interval, duratinon, timeout } in msec
3549  *      @deadline: deadline jiffies for the operation
3550  *
3551 *       Make sure SStatus of @link reaches stable state, determined by
3552  *      holding the same value where DET is not 1 for @duration polled
3553  *      every @interval, before @timeout.  Timeout constraints the
3554  *      beginning of the stable state.  Because DET gets stuck at 1 on
3555  *      some controllers after hot unplugging, this functions waits
3556  *      until timeout then returns 0 if DET is stable at 1.
3557  *
3558  *      @timeout is further limited by @deadline.  The sooner of the
3559  *      two is used.
3560  *
3561  *      LOCKING:
3562  *      Kernel thread context (may sleep)
3563  *
3564  *      RETURNS:
3565  *      0 on success, -errno on failure.
3566  */
3567 int sata_link_debounce(struct ata_link *link, const unsigned long *params,
3568                        unsigned long deadline)
3569 {
3570         unsigned long interval_msec = params[0];
3571         unsigned long duration = msecs_to_jiffies(params[1]);
3572         unsigned long last_jiffies, t;
3573         u32 last, cur;
3574         int rc;
3575
3576         t = jiffies + msecs_to_jiffies(params[2]);
3577         if (time_before(t, deadline))
3578                 deadline = t;
3579
3580         if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
3581                 return rc;
3582         cur &= 0xf;
3583
3584         last = cur;
3585         last_jiffies = jiffies;
3586
3587         while (1) {
3588                 msleep(interval_msec);
3589                 if ((rc = sata_scr_read(link, SCR_STATUS, &cur)))
3590                         return rc;
3591                 cur &= 0xf;
3592
3593                 /* DET stable? */
3594                 if (cur == last) {
3595                         if (cur == 1 && time_before(jiffies, deadline))
3596                                 continue;
3597                         if (time_after(jiffies, last_jiffies + duration))
3598                                 return 0;
3599                         continue;
3600                 }
3601
3602                 /* unstable, start over */
3603                 last = cur;
3604                 last_jiffies = jiffies;
3605
3606                 /* Check deadline.  If debouncing failed, return
3607                  * -EPIPE to tell upper layer to lower link speed.
3608                  */
3609                 if (time_after(jiffies, deadline))
3610                         return -EPIPE;
3611         }
3612 }
3613
3614 /**
3615  *      sata_link_resume - resume SATA link
3616  *      @link: ATA link to resume SATA
3617  *      @params: timing parameters { interval, duratinon, timeout } in msec
3618  *      @deadline: deadline jiffies for the operation
3619  *
3620  *      Resume SATA phy @link and debounce it.
3621  *
3622  *      LOCKING:
3623  *      Kernel thread context (may sleep)
3624  *
3625  *      RETURNS:
3626  *      0 on success, -errno on failure.
3627  */
3628 int sata_link_resume(struct ata_link *link, const unsigned long *params,
3629                      unsigned long deadline)
3630 {
3631         u32 scontrol;
3632         int rc;
3633
3634         if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3635                 return rc;
3636
3637         scontrol = (scontrol & 0x0f0) | 0x300;
3638
3639         if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3640                 return rc;
3641
3642         /* Some PHYs react badly if SStatus is pounded immediately
3643          * after resuming.  Delay 200ms before debouncing.
3644          */
3645         msleep(200);
3646
3647         return sata_link_debounce(link, params, deadline);
3648 }
3649
3650 /**
3651  *      ata_std_prereset - prepare for reset
3652  *      @link: ATA link to be reset
3653  *      @deadline: deadline jiffies for the operation
3654  *
3655  *      @link is about to be reset.  Initialize it.  Failure from
3656  *      prereset makes libata abort whole reset sequence and give up
3657  *      that port, so prereset should be best-effort.  It does its
3658  *      best to prepare for reset sequence but if things go wrong, it
3659  *      should just whine, not fail.
3660  *
3661  *      LOCKING:
3662  *      Kernel thread context (may sleep)
3663  *
3664  *      RETURNS:
3665  *      0 on success, -errno otherwise.
3666  */
3667 int ata_std_prereset(struct ata_link *link, unsigned long deadline)
3668 {
3669         struct ata_port *ap = link->ap;
3670         struct ata_eh_context *ehc = &link->eh_context;
3671         const unsigned long *timing = sata_ehc_deb_timing(ehc);
3672         int rc;
3673
3674         /* handle link resume */
3675         if ((ehc->i.flags & ATA_EHI_RESUME_LINK) &&
3676             (link->flags & ATA_LFLAG_HRST_TO_RESUME))
3677                 ehc->i.action |= ATA_EH_HARDRESET;
3678
3679         /* Some PMPs don't work with only SRST, force hardreset if PMP
3680          * is supported.
3681          */
3682         if (ap->flags & ATA_FLAG_PMP)
3683                 ehc->i.action |= ATA_EH_HARDRESET;
3684
3685         /* if we're about to do hardreset, nothing more to do */
3686         if (ehc->i.action & ATA_EH_HARDRESET)
3687                 return 0;
3688
3689         /* if SATA, resume link */
3690         if (ap->flags & ATA_FLAG_SATA) {
3691                 rc = sata_link_resume(link, timing, deadline);
3692                 /* whine about phy resume failure but proceed */
3693                 if (rc && rc != -EOPNOTSUPP)
3694                         ata_link_printk(link, KERN_WARNING, "failed to resume "
3695                                         "link for reset (errno=%d)\n", rc);
3696         }
3697
3698         /* Wait for !BSY if the controller can wait for the first D2H
3699          * Reg FIS and we don't know that no device is attached.
3700          */
3701         if (!(link->flags & ATA_LFLAG_SKIP_D2H_BSY) && !ata_link_offline(link)) {
3702                 rc = ata_wait_ready(ap, deadline);
3703                 if (rc && rc != -ENODEV) {
3704                         ata_link_printk(link, KERN_WARNING, "device not ready "
3705                                         "(errno=%d), forcing hardreset\n", rc);
3706                         ehc->i.action |= ATA_EH_HARDRESET;
3707                 }
3708         }
3709
3710         return 0;
3711 }
3712
3713 /**
3714  *      ata_std_softreset - reset host port via ATA SRST
3715  *      @link: ATA link to reset
3716  *      @classes: resulting classes of attached devices
3717  *      @deadline: deadline jiffies for the operation
3718  *
3719  *      Reset host port using ATA SRST.
3720  *
3721  *      LOCKING:
3722  *      Kernel thread context (may sleep)
3723  *
3724  *      RETURNS:
3725  *      0 on success, -errno otherwise.
3726  */
3727 int ata_std_softreset(struct ata_link *link, unsigned int *classes,
3728                       unsigned long deadline)
3729 {
3730         struct ata_port *ap = link->ap;
3731         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
3732         unsigned int devmask = 0;
3733         int rc;
3734         u8 err;
3735
3736         DPRINTK("ENTER\n");
3737
3738         if (ata_link_offline(link)) {
3739                 classes[0] = ATA_DEV_NONE;
3740                 goto out;
3741         }
3742
3743         /* determine if device 0/1 are present */
3744         if (ata_devchk(ap, 0))
3745                 devmask |= (1 << 0);
3746         if (slave_possible && ata_devchk(ap, 1))
3747                 devmask |= (1 << 1);
3748
3749         /* select device 0 again */
3750         ap->ops->dev_select(ap, 0);
3751
3752         /* issue bus reset */
3753         DPRINTK("about to softreset, devmask=%x\n", devmask);
3754         rc = ata_bus_softreset(ap, devmask, deadline);
3755         /* if link is occupied, -ENODEV too is an error */
3756         if (rc && (rc != -ENODEV || sata_scr_valid(link))) {
3757                 ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc);
3758                 return rc;
3759         }
3760
3761         /* determine by signature whether we have ATA or ATAPI devices */
3762         classes[0] = ata_dev_try_classify(&link->device[0],
3763                                           devmask & (1 << 0), &err);
3764         if (slave_possible && err != 0x81)
3765                 classes[1] = ata_dev_try_classify(&link->device[1],
3766                                                   devmask & (1 << 1), &err);
3767
3768  out:
3769         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
3770         return 0;
3771 }
3772
3773 /**
3774  *      sata_link_hardreset - reset link via SATA phy reset
3775  *      @link: link to reset
3776  *      @timing: timing parameters { interval, duratinon, timeout } in msec
3777  *      @deadline: deadline jiffies for the operation
3778  *
3779  *      SATA phy-reset @link using DET bits of SControl register.
3780  *
3781  *      LOCKING:
3782  *      Kernel thread context (may sleep)
3783  *
3784  *      RETURNS:
3785  *      0 on success, -errno otherwise.
3786  */
3787 int sata_link_hardreset(struct ata_link *link, const unsigned long *timing,
3788                         unsigned long deadline)
3789 {
3790         u32 scontrol;
3791         int rc;
3792
3793         DPRINTK("ENTER\n");
3794
3795         if (sata_set_spd_needed(link)) {
3796                 /* SATA spec says nothing about how to reconfigure
3797                  * spd.  To be on the safe side, turn off phy during
3798                  * reconfiguration.  This works for at least ICH7 AHCI
3799                  * and Sil3124.
3800                  */
3801                 if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3802                         goto out;
3803
3804                 scontrol = (scontrol & 0x0f0) | 0x304;
3805
3806                 if ((rc = sata_scr_write(link, SCR_CONTROL, scontrol)))
3807                         goto out;
3808
3809                 sata_set_spd(link);
3810         }
3811
3812         /* issue phy wake/reset */
3813         if ((rc = sata_scr_read(link, SCR_CONTROL, &scontrol)))
3814                 goto out;
3815
3816         scontrol = (scontrol & 0x0f0) | 0x301;
3817
3818         if ((rc = sata_scr_write_flush(link, SCR_CONTROL, scontrol)))
3819                 goto out;
3820
3821         /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
3822          * 10.4.2 says at least 1 ms.
3823          */
3824         msleep(1);
3825
3826         /* bring link back */
3827         rc = sata_link_resume(link, timing, deadline);
3828  out:
3829         DPRINTK("EXIT, rc=%d\n", rc);
3830         return rc;
3831 }
3832
3833 /**
3834  *      sata_std_hardreset - reset host port via SATA phy reset
3835  *      @link: link to reset
3836  *      @class: resulting class of attached device
3837  *      @deadline: deadline jiffies for the operation
3838  *
3839  *      SATA phy-reset host port using DET bits of SControl register,
3840  *      wait for !BSY and classify the attached device.
3841  *
3842  *      LOCKING:
3843  *      Kernel thread context (may sleep)
3844  *
3845  *      RETURNS:
3846  *      0 on success, -errno otherwise.
3847  */
3848 int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3849                        unsigned long deadline)
3850 {
3851         struct ata_port *ap = link->ap;
3852         const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
3853         int rc;
3854
3855         DPRINTK("ENTER\n");
3856
3857         /* do hardreset */
3858         rc = sata_link_hardreset(link, timing, deadline);
3859         if (rc) {
3860                 ata_link_printk(link, KERN_ERR,
3861                                 "COMRESET failed (errno=%d)\n", rc);
3862                 return rc;
3863         }
3864
3865         /* TODO: phy layer with polling, timeouts, etc. */
3866         if (ata_link_offline(link)) {
3867                 *class = ATA_DEV_NONE;
3868                 DPRINTK("EXIT, link offline\n");
3869                 return 0;
3870         }
3871
3872         /* wait a while before checking status */
3873         ata_wait_after_reset(ap, deadline);
3874
3875         /* If PMP is supported, we have to do follow-up SRST.  Note
3876          * that some PMPs don't send D2H Reg FIS after hardreset at
3877          * all if the first port is empty.  Wait for it just for a
3878          * second and request follow-up SRST.
3879          */
3880         if (ap->flags & ATA_FLAG_PMP) {
3881                 ata_wait_ready(ap, jiffies + HZ);
3882                 return -EAGAIN;
3883         }
3884
3885         rc = ata_wait_ready(ap, deadline);
3886         /* link occupied, -ENODEV too is an error */
3887         if (rc) {
3888                 ata_link_printk(link, KERN_ERR,
3889                                 "COMRESET failed (errno=%d)\n", rc);
3890                 return rc;
3891         }
3892
3893         ap->ops->dev_select(ap, 0);     /* probably unnecessary */
3894
3895         *class = ata_dev_try_classify(link->device, 1, NULL);
3896
3897         DPRINTK("EXIT, class=%u\n", *class);
3898         return 0;
3899 }
3900
3901 /**
3902  *      ata_std_postreset - standard postreset callback
3903  *      @link: the target ata_link
3904  *      @classes: classes of attached devices
3905  *
3906  *      This function is invoked after a successful reset.  Note that
3907  *      the device might have been reset more than once using
3908  *      different reset methods before postreset is invoked.
3909  *
3910  *      LOCKING:
3911  *      Kernel thread context (may sleep)
3912  */
3913 void ata_std_postreset(struct ata_link *link, unsigned int *classes)
3914 {
3915         struct ata_port *ap = link->ap;
3916         u32 serror;
3917
3918         DPRINTK("ENTER\n");
3919
3920         /* print link status */
3921         sata_print_link_status(link);
3922
3923         /* clear SError */
3924         if (sata_scr_read(link, SCR_ERROR, &serror) == 0)
3925                 sata_scr_write(link, SCR_ERROR, serror);
3926
3927         /* is double-select really necessary? */
3928         if (classes[0] != ATA_DEV_NONE)
3929                 ap->ops->dev_select(ap, 1);
3930         if (classes[1] != ATA_DEV_NONE)
3931                 ap->ops->dev_select(ap, 0);
3932
3933         /* bail out if no device is present */
3934         if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
3935                 DPRINTK("EXIT, no device\n");
3936                 return;
3937         }
3938
3939         /* set up device control */
3940         if (ap->ioaddr.ctl_addr)
3941                 iowrite8(ap->ctl, ap->ioaddr.ctl_addr);
3942
3943         DPRINTK("EXIT\n");
3944 }
3945
3946 /**
3947  *      ata_dev_same_device - Determine whether new ID matches configured device
3948  *      @dev: device to compare against
3949  *      @new_class: class of the new device
3950  *      @new_id: IDENTIFY page of the new device
3951  *
3952  *      Compare @new_class and @new_id against @dev and determine
3953  *      whether @dev is the device indicated by @new_class and
3954  *      @new_id.
3955  *
3956  *      LOCKING:
3957  *      None.
3958  *
3959  *      RETURNS:
3960  *      1 if @dev matches @new_class and @new_id, 0 otherwise.
3961  */
3962 static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
3963                                const u16 *new_id)
3964 {
3965         const u16 *old_id = dev->id;
3966         unsigned char model[2][ATA_ID_PROD_LEN + 1];
3967         unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
3968
3969         if (dev->class != new_class) {
3970                 ata_dev_printk(dev, KERN_INFO, "class mismatch %d != %d\n",
3971                                dev->class, new_class);
3972                 return 0;
3973         }
3974
3975         ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
3976         ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
3977         ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
3978         ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
3979
3980         if (strcmp(model[0], model[1])) {
3981                 ata_dev_printk(dev, KERN_INFO, "model number mismatch "
3982                                "'%s' != '%s'\n", model[0], model[1]);
3983                 return 0;
3984         }
3985
3986         if (strcmp(serial[0], serial[1])) {
3987                 ata_dev_printk(dev, KERN_INFO, "serial number mismatch "
3988                                "'%s' != '%s'\n", serial[0], serial[1]);
3989                 return 0;
3990         }
3991
3992         return 1;
3993 }
3994
3995 /**
3996  *      ata_dev_reread_id - Re-read IDENTIFY data
3997  *      @dev: target ATA device
3998  *      @readid_flags: read ID flags
3999  *
4000  *      Re-read IDENTIFY page and make sure @dev is still attached to
4001  *      the port.
4002  *
4003  *      LOCKING:
4004  *      Kernel thread context (may sleep)
4005  *
4006  *      RETURNS:
4007  *      0 on success, negative errno otherwise
4008  */
4009 int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
4010 {
4011         unsigned int class = dev->class;
4012         u16 *id = (void *)dev->link->ap->sector_buf;
4013         int rc;
4014
4015         /* read ID data */
4016         rc = ata_dev_read_id(dev, &class, readid_flags, id);
4017         if (rc)
4018                 return rc;
4019
4020         /* is the device still there? */
4021         if (!ata_dev_same_device(dev, class, id))
4022                 return -ENODEV;
4023
4024         memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
4025         return 0;
4026 }
4027
4028 /**
4029  *      ata_dev_revalidate - Revalidate ATA device
4030  *      @dev: device to revalidate
4031  *      @new_class: new class code
4032  *      @readid_flags: read ID flags
4033  *
4034  *      Re-read IDENTIFY page, make sure @dev is still attached to the
4035  *      port and reconfigure it according to the new IDENTIFY page.
4036  *
4037  *      LOCKING:
4038  *      Kernel thread context (may sleep)
4039  *
4040  *      RETURNS:
4041  *      0 on success, negative errno otherwise
4042  */
4043 int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
4044                        unsigned int readid_flags)
4045 {
4046         u64 n_sectors = dev->n_sectors;
4047         int rc;
4048
4049         if (!ata_dev_enabled(dev))
4050                 return -ENODEV;
4051
4052         /* fail early if !ATA && !ATAPI to avoid issuing [P]IDENTIFY to PMP */
4053         if (ata_class_enabled(new_class) &&
4054             new_class != ATA_DEV_ATA && new_class != ATA_DEV_ATAPI) {
4055                 ata_dev_printk(dev, KERN_INFO, "class mismatch %u != %u\n",
4056                                dev->class, new_class);
4057                 rc = -ENODEV;
4058                 goto fail;
4059         }
4060
4061         /* re-read ID */
4062         rc = ata_dev_reread_id(dev, readid_flags);
4063         if (rc)
4064                 goto fail;
4065
4066         /* configure device according to the new ID */
4067         rc = ata_dev_configure(dev);
4068         if (rc)
4069                 goto fail;
4070
4071         /* verify n_sectors hasn't changed */
4072         if (dev->class == ATA_DEV_ATA && n_sectors &&
4073             dev->n_sectors != n_sectors) {
4074                 ata_dev_printk(dev, KERN_INFO, "n_sectors mismatch "
4075                                "%llu != %llu\n",
4076                                (unsigned long long)n_sectors,
4077                                (unsigned long long)dev->n_sectors);
4078
4079                 /* restore original n_sectors */
4080                 dev->n_sectors = n_sectors;
4081
4082                 rc = -ENODEV;
4083                 goto fail;
4084         }
4085
4086         return 0;
4087
4088  fail:
4089         ata_dev_printk(dev, KERN_ERR, "revalidation failed (errno=%d)\n", rc);
4090         return rc;
4091 }
4092
4093 struct ata_blacklist_entry {
4094         const char *model_num;
4095         const char *model_rev;
4096         unsigned long horkage;
4097 };
4098
4099 static const struct ata_blacklist_entry ata_device_blacklist [] = {
4100         /* Devices with DMA related problems under Linux */
4101         { "WDC AC11000H",       NULL,           ATA_HORKAGE_NODMA },
4102         { "WDC AC22100H",       NULL,           ATA_HORKAGE_NODMA },
4103         { "WDC AC32500H",       NULL,           ATA_HORKAGE_NODMA },
4104         { "WDC AC33100H",       NULL,           ATA_HORKAGE_NODMA },
4105         { "WDC AC31600H",       NULL,           ATA_HORKAGE_NODMA },
4106         { "WDC AC32100H",       "24.09P07",     ATA_HORKAGE_NODMA },
4107         { "WDC AC23200L",       "21.10N21",     ATA_HORKAGE_NODMA },
4108         { "Compaq CRD-8241B",   NULL,           ATA_HORKAGE_NODMA },
4109         { "CRD-8400B",          NULL,           ATA_HORKAGE_NODMA },
4110         { "CRD-8480B",          NULL,           ATA_HORKAGE_NODMA },
4111         { "CRD-8482B",          NULL,           ATA_HORKAGE_NODMA },
4112         { "CRD-84",             NULL,           ATA_HORKAGE_NODMA },
4113         { "SanDisk SDP3B",      NULL,           ATA_HORKAGE_NODMA },
4114         { "SanDisk SDP3B-64",   NULL,           ATA_HORKAGE_NODMA },
4115         { "SANYO CD-ROM CRD",   NULL,           ATA_HORKAGE_NODMA },
4116         { "HITACHI CDR-8",      NULL,           ATA_HORKAGE_NODMA },
4117         { "HITACHI CDR-8335",   NULL,           ATA_HORKAGE_NODMA },
4118         { "HITACHI CDR-8435",   NULL,           ATA_HORKAGE_NODMA },
4119         { "Toshiba CD-ROM XM-6202B", NULL,      ATA_HORKAGE_NODMA },
4120         { "TOSHIBA CD-ROM XM-1702BC", NULL,     ATA_HORKAGE_NODMA },
4121         { "CD-532E-A",          NULL,           ATA_HORKAGE_NODMA },
4122         { "E-IDE CD-ROM CR-840",NULL,           ATA_HORKAGE_NODMA },
4123         { "CD-ROM Drive/F5A",   NULL,           ATA_HORKAGE_NODMA },
4124         { "WPI CDD-820",        NULL,           ATA_HORKAGE_NODMA },
4125         { "SAMSUNG CD-ROM SC-148C", NULL,       ATA_HORKAGE_NODMA },
4126         { "SAMSUNG CD-ROM SC",  NULL,           ATA_HORKAGE_NODMA },
4127         { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
4128         { "_NEC DV5800A",       NULL,           ATA_HORKAGE_NODMA },
4129         { "SAMSUNG CD-ROM SN-124", "N001",      ATA_HORKAGE_NODMA },
4130         { "Seagate STT20000A", NULL,            ATA_HORKAGE_NODMA },
4131         /* Odd clown on sil3726/4726 PMPs */
4132         { "Config  Disk",       NULL,           ATA_HORKAGE_NODMA |
4133                                                 ATA_HORKAGE_SKIP_PM },
4134
4135         /* Weird ATAPI devices */
4136         { "TORiSAN DVD-ROM DRD-N216", NULL,     ATA_HORKAGE_MAX_SEC_128 },
4137
4138         /* Devices we expect to fail diagnostics */
4139
4140         /* Devices where NCQ should be avoided */
4141         /* NCQ is slow */
4142         { "WDC WD740ADFD-00",   NULL,           ATA_HORKAGE_NONCQ },
4143         /* http://thread.gmane.org/gmane.linux.ide/14907 */
4144         { "FUJITSU MHT2060BH",  NULL,           ATA_HORKAGE_NONCQ },
4145         /* NCQ is broken */
4146         { "Maxtor *",           "BANC*",        ATA_HORKAGE_NONCQ },
4147         { "Maxtor 7V300F0",     "VA111630",     ATA_HORKAGE_NONCQ },
4148         { "HITACHI HDS7250SASUN500G*", NULL,    ATA_HORKAGE_NONCQ },
4149         { "HITACHI HDS7225SBSUN250G*", NULL,    ATA_HORKAGE_NONCQ },
4150         { "ST380817AS",         "3.42",         ATA_HORKAGE_NONCQ },
4151
4152         /* Blacklist entries taken from Silicon Image 3124/3132
4153            Windows driver .inf file - also several Linux problem reports */
4154         { "HTS541060G9SA00",    "MB3OC60D",     ATA_HORKAGE_NONCQ, },
4155         { "HTS541080G9SA00",    "MB4OC60D",     ATA_HORKAGE_NONCQ, },
4156         { "HTS541010G9SA00",    "MBZOC60D",     ATA_HORKAGE_NONCQ, },
4157         /* Drives which do spurious command completion */
4158         { "HTS541680J9SA00",    "SB2IC7EP",     ATA_HORKAGE_NONCQ, },
4159         { "HTS541612J9SA00",    "SBDIC7JP",     ATA_HORKAGE_NONCQ, },
4160         { "HDT722516DLA380",    "V43OA96A",     ATA_HORKAGE_NONCQ, },
4161         { "Hitachi HTS541616J9SA00", "SB4OC70P", ATA_HORKAGE_NONCQ, },
4162         { "Hitachi HTS542525K9SA00", "BBFOC31P", ATA_HORKAGE_NONCQ, },
4163         { "WDC WD740ADFD-00NLR1", NULL,         ATA_HORKAGE_NONCQ, },
4164         { "WDC WD3200AAJS-00RYA0", "12.01B01",  ATA_HORKAGE_NONCQ, },
4165         { "FUJITSU MHV2080BH",  "00840028",     ATA_HORKAGE_NONCQ, },
4166         { "ST9120822AS",        "3.CLF",        ATA_HORKAGE_NONCQ, },
4167         { "ST9160821AS",        "3.CLF",        ATA_HORKAGE_NONCQ, },
4168         { "ST9160821AS",        "3.ALD",        ATA_HORKAGE_NONCQ, },
4169         { "ST9160821AS",        "3.CCD",        ATA_HORKAGE_NONCQ, },
4170         { "ST3160812AS",        "3.ADJ",        ATA_HORKAGE_NONCQ, },
4171         { "ST980813AS",         "3.ADB",        ATA_HORKAGE_NONCQ, },
4172         { "SAMSUNG HD401LJ",    "ZZ100-15",     ATA_HORKAGE_NONCQ, },
4173         { "Maxtor 7V300F0",     "VA111900",     ATA_HORKAGE_NONCQ, },
4174
4175         /* devices which puke on READ_NATIVE_MAX */
4176         { "HDS724040KLSA80",    "KFAOA20N",     ATA_HORKAGE_BROKEN_HPA, },
4177         { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
4178         { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
4179         { "MAXTOR 6L080L4",     "A93.0500",     ATA_HORKAGE_BROKEN_HPA },
4180
4181         /* Devices which report 1 sector over size HPA */
4182         { "ST340823A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
4183         { "ST320413A",          NULL,           ATA_HORKAGE_HPA_SIZE, },
4184
4185         /* Devices which get the IVB wrong */
4186         { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, },
4187         { "TSSTcorp CDDVDW SH-S202J", "SB00",     ATA_HORKAGE_IVB, },
4188
4189         /* End Marker */
4190         { }
4191 };
4192
4193 static int strn_pattern_cmp(const char *patt, const char *name, int wildchar)
4194 {
4195         const char *p;
4196         int len;
4197
4198         /*
4199          * check for trailing wildcard: *\0
4200          */
4201         p = strchr(patt, wildchar);
4202         if (p && ((*(p + 1)) == 0))
4203                 len = p - patt;
4204         else {
4205                 len = strlen(name);
4206                 if (!len) {
4207                         if (!*patt)
4208                                 return 0;
4209                         return -1;
4210                 }
4211         }
4212
4213         return strncmp(patt, name, len);
4214 }
4215
4216 static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
4217 {
4218         unsigned char model_num[ATA_ID_PROD_LEN + 1];
4219         unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
4220         const struct ata_blacklist_entry *ad = ata_device_blacklist;
4221
4222         ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
4223         ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
4224
4225         while (ad->model_num) {
4226                 if (!strn_pattern_cmp(ad->model_num, model_num, '*')) {
4227                         if (ad->model_rev == NULL)
4228                                 return ad->horkage;
4229                         if (!strn_pattern_cmp(ad->model_rev, model_rev, '*'))
4230                                 return ad->horkage;
4231                 }
4232                 ad++;
4233         }
4234         return 0;
4235 }
4236
4237 static int ata_dma_blacklisted(const struct ata_device *dev)
4238 {
4239         /* We don't support polling DMA.
4240          * DMA blacklist those ATAPI devices with CDB-intr (and use PIO)
4241          * if the LLDD handles only interrupts in the HSM_ST_LAST state.
4242          */
4243         if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4244             (dev->flags & ATA_DFLAG_CDB_INTR))
4245                 return 1;
4246         return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
4247 }
4248
4249 /**
4250  *      ata_is_40wire           -       check drive side detection
4251  *      @dev: device
4252  *
4253  *      Perform drive side detection decoding, allowing for device vendors
4254  *      who can't follow the documentation.
4255  */
4256
4257 static int ata_is_40wire(struct ata_device *dev)
4258 {
4259         if (dev->horkage & ATA_HORKAGE_IVB)
4260                 return ata_drive_40wire_relaxed(dev->id);
4261         return ata_drive_40wire(dev->id);
4262 }
4263
4264 /**
4265  *      ata_dev_xfermask - Compute supported xfermask of the given device
4266  *      @dev: Device to compute xfermask for
4267  *
4268  *      Compute supported xfermask of @dev and store it in
4269  *      dev->*_mask.  This function is responsible for applying all
4270  *      known limits including host controller limits, device
4271  *      blacklist, etc...
4272  *
4273  *      LOCKING:
4274  *      None.
4275  */
4276 static void ata_dev_xfermask(struct ata_device *dev)
4277 {
4278         struct ata_link *link = dev->link;
4279         struct ata_port *ap = link->ap;
4280         struct ata_host *host = ap->host;
4281         unsigned long xfer_mask;
4282
4283         /* controller modes available */
4284         xfer_mask = ata_pack_xfermask(ap->pio_mask,
4285                                       ap->mwdma_mask, ap->udma_mask);
4286
4287         /* drive modes available */
4288         xfer_mask &= ata_pack_xfermask(dev->pio_mask,
4289                                        dev->mwdma_mask, dev->udma_mask);
4290         xfer_mask &= ata_id_xfermask(dev->id);
4291
4292         /*
4293          *      CFA Advanced TrueIDE timings are not allowed on a shared
4294          *      cable
4295          */
4296         if (ata_dev_pair(dev)) {
4297                 /* No PIO5 or PIO6 */
4298                 xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
4299                 /* No MWDMA3 or MWDMA 4 */
4300                 xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
4301         }
4302
4303         if (ata_dma_blacklisted(dev)) {
4304                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4305                 ata_dev_printk(dev, KERN_WARNING,
4306                                "device is on DMA blacklist, disabling DMA\n");
4307         }
4308
4309         if ((host->flags & ATA_HOST_SIMPLEX) &&
4310             host->simplex_claimed && host->simplex_claimed != ap) {
4311                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4312                 ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by "
4313                                "other device, disabling DMA\n");
4314         }
4315
4316         if (ap->flags & ATA_FLAG_NO_IORDY)
4317                 xfer_mask &= ata_pio_mask_no_iordy(dev);
4318
4319         if (ap->ops->mode_filter)
4320                 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
4321
4322         /* Apply cable rule here.  Don't apply it early because when
4323          * we handle hot plug the cable type can itself change.
4324          * Check this last so that we know if the transfer rate was
4325          * solely limited by the cable.
4326          * Unknown or 80 wire cables reported host side are checked
4327          * drive side as well. Cases where we know a 40wire cable
4328          * is used safely for 80 are not checked here.
4329          */
4330         if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
4331                 /* UDMA/44 or higher would be available */
4332                 if ((ap->cbl == ATA_CBL_PATA40) ||
4333                     (ata_is_40wire(dev) &&
4334                     (ap->cbl == ATA_CBL_PATA_UNK ||
4335                      ap->cbl == ATA_CBL_PATA80))) {
4336                         ata_dev_printk(dev, KERN_WARNING,
4337                                  "limited to UDMA/33 due to 40-wire cable\n");
4338                         xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
4339                 }
4340
4341         ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
4342                             &dev->mwdma_mask, &dev->udma_mask);
4343 }
4344
4345 /**
4346  *      ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
4347  *      @dev: Device to which command will be sent
4348  *
4349  *      Issue SET FEATURES - XFER MODE command to device @dev
4350  *      on port @ap.
4351  *
4352  *      LOCKING:
4353  *      PCI/etc. bus probe sem.
4354  *
4355  *      RETURNS:
4356  *      0 on success, AC_ERR_* mask otherwise.
4357  */
4358
4359 static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
4360 {
4361         struct ata_taskfile tf;
4362         unsigned int err_mask;
4363
4364         /* set up set-features taskfile */
4365         DPRINTK("set features - xfer mode\n");
4366
4367         /* Some controllers and ATAPI devices show flaky interrupt
4368          * behavior after setting xfer mode.  Use polling instead.
4369          */
4370         ata_tf_init(dev, &tf);
4371         tf.command = ATA_CMD_SET_FEATURES;
4372         tf.feature = SETFEATURES_XFER;
4373         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
4374         tf.protocol = ATA_PROT_NODATA;
4375         tf.nsect = dev->xfer_mode;
4376
4377         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4378
4379         DPRINTK("EXIT, err_mask=%x\n", err_mask);
4380         return err_mask;
4381 }
4382 /**
4383  *      ata_dev_set_feature - Issue SET FEATURES - SATA FEATURES
4384  *      @dev: Device to which command will be sent
4385  *      @enable: Whether to enable or disable the feature
4386  *      @feature: The sector count represents the feature to set
4387  *
4388  *      Issue SET FEATURES - SATA FEATURES command to device @dev
4389  *      on port @ap with sector count
4390  *
4391  *      LOCKING:
4392  *      PCI/etc. bus probe sem.
4393  *
4394  *      RETURNS:
4395  *      0 on success, AC_ERR_* mask otherwise.
4396  */
4397 static unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable,
4398                                         u8 feature)
4399 {
4400         struct ata_taskfile tf;
4401         unsigned int err_mask;
4402
4403         /* set up set-features taskfile */
4404         DPRINTK("set features - SATA features\n");
4405
4406         ata_tf_init(dev, &tf);
4407         tf.command = ATA_CMD_SET_FEATURES;
4408         tf.feature = enable;
4409         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4410         tf.protocol = ATA_PROT_NODATA;
4411         tf.nsect = feature;
4412
4413         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4414
4415         DPRINTK("EXIT, err_mask=%x\n", err_mask);
4416         return err_mask;
4417 }
4418
4419 /**
4420  *      ata_dev_init_params - Issue INIT DEV PARAMS command
4421  *      @dev: Device to which command will be sent
4422  *      @heads: Number of heads (taskfile parameter)
4423  *      @sectors: Number of sectors (taskfile parameter)
4424  *
4425  *      LOCKING:
4426  *      Kernel thread context (may sleep)
4427  *
4428  *      RETURNS:
4429  *      0 on success, AC_ERR_* mask otherwise.
4430  */
4431 static unsigned int ata_dev_init_params(struct ata_device *dev,
4432                                         u16 heads, u16 sectors)
4433 {
4434         struct ata_taskfile tf;
4435         unsigned int err_mask;
4436
4437         /* Number of sectors per track 1-255. Number of heads 1-16 */
4438         if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
4439                 return AC_ERR_INVALID;
4440
4441         /* set up init dev params taskfile */
4442         DPRINTK("init dev params \n");
4443
4444         ata_tf_init(dev, &tf);
4445         tf.command = ATA_CMD_INIT_DEV_PARAMS;
4446         tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4447         tf.protocol = ATA_PROT_NODATA;
4448         tf.nsect = sectors;
4449         tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
4450
4451         err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4452         /* A clean abort indicates an original or just out of spec drive
4453            and we should continue as we issue the setup based on the
4454            drive reported working geometry */
4455         if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
4456                 err_mask = 0;
4457
4458         DPRINTK("EXIT, err_mask=%x\n", err_mask);
4459         return err_mask;
4460 }
4461
4462 /**
4463  *      ata_sg_clean - Unmap DMA memory associated with command
4464  *      @qc: Command containing DMA memory to be released
4465  *
4466  *      Unmap all mapped DMA memory associated with this command.
4467  *
4468  *      LOCKING:
4469  *      spin_lock_irqsave(host lock)
4470  */
4471 void ata_sg_clean(struct ata_queued_cmd *qc)
4472 {
4473         struct ata_port *ap = qc->ap;
4474         struct scatterlist *sg = qc->__sg;
4475         int dir = qc->dma_dir;
4476         void *pad_buf = NULL;
4477
4478         WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
4479         WARN_ON(sg == NULL);
4480
4481         if (qc->flags & ATA_QCFLAG_SINGLE)
4482                 WARN_ON(qc->n_elem > 1);
4483
4484         VPRINTK("unmapping %u sg elements\n", qc->n_elem);
4485
4486         /* if we padded the buffer out to 32-bit bound, and data
4487          * xfer direction is from-device, we must copy from the
4488          * pad buffer back into the supplied buffer
4489          */
4490         if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
4491                 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
4492
4493         if (qc->flags & ATA_QCFLAG_SG) {
4494                 if (qc->n_elem)
4495                         dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
4496                 /* restore last sg */
4497                 sg_last(sg, qc->orig_n_elem)->length += qc->pad_len;
4498                 if (pad_buf) {
4499                         struct scatterlist *psg = &qc->pad_sgent;
4500                         void *addr = kmap_atomic(sg_page(psg), KM_IRQ0);
4501                         memcpy(addr + psg->offset, pad_buf, qc->pad_len);
4502                         kunmap_atomic(addr, KM_IRQ0);
4503                 }
4504         } else {
4505                 if (qc->n_elem)
4506                         dma_unmap_single(ap->dev,
4507                                 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
4508                                 dir);
4509                 /* restore sg */
4510                 sg->length += qc->pad_len;
4511                 if (pad_buf)
4512                         memcpy(qc->buf_virt + sg->length - qc->pad_len,
4513                                pad_buf, qc->pad_len);
4514         }
4515
4516         qc->flags &= ~ATA_QCFLAG_DMAMAP;
4517         qc->__sg = NULL;
4518 }
4519
4520 /**
4521  *      ata_fill_sg - Fill PCI IDE PRD table
4522  *      @qc: Metadata associated with taskfile to be transferred
4523  *
4524  *      Fill PCI IDE PRD (scatter-gather) table with segments
4525  *      associated with the current disk command.
4526  *
4527  *      LOCKING:
4528  *      spin_lock_irqsave(host lock)
4529  *
4530  */
4531 static void ata_fill_sg(struct ata_queued_cmd *qc)
4532 {
4533         struct ata_port *ap = qc->ap;
4534         struct scatterlist *sg;
4535         unsigned int idx;
4536
4537         WARN_ON(qc->__sg == NULL);
4538         WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
4539
4540         idx = 0;
4541         ata_for_each_sg(sg, qc) {
4542                 u32 addr, offset;
4543                 u32 sg_len, len;
4544
4545                 /* determine if physical DMA addr spans 64K boundary.
4546                  * Note h/w doesn't support 64-bit, so we unconditionally
4547                  * truncate dma_addr_t to u32.
4548                  */
4549                 addr = (u32) sg_dma_address(sg);
4550                 sg_len = sg_dma_len(sg);
4551
4552                 while (sg_len) {
4553                         offset = addr & 0xffff;
4554                         len = sg_len;
4555                         if ((offset + sg_len) > 0x10000)
4556                                 len = 0x10000 - offset;
4557
4558                         ap->prd[idx].addr = cpu_to_le32(addr);
4559                         ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
4560                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
4561
4562                         idx++;
4563                         sg_len -= len;
4564                         addr += len;
4565                 }
4566         }
4567
4568         if (idx)
4569                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
4570 }
4571
4572 /**
4573  *      ata_fill_sg_dumb - Fill PCI IDE PRD table
4574  *      @qc: Metadata associated with taskfile to be transferred
4575  *
4576  *      Fill PCI IDE PRD (scatter-gather) table with segments
4577  *      associated with the current disk command. Perform the fill
4578  *      so that we avoid writing any length 64K records for
4579  *      controllers that don't follow the spec.
4580  *
4581  *      LOCKING:
4582  *      spin_lock_irqsave(host lock)
4583  *
4584  */
4585 static void ata_fill_sg_dumb(struct ata_queued_cmd *qc)
4586 {
4587         struct ata_port *ap = qc->ap;
4588         struct scatterlist *sg;
4589         unsigned int idx;
4590
4591         WARN_ON(qc->__sg == NULL);
4592         WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
4593
4594         idx = 0;
4595         ata_for_each_sg(sg, qc) {
4596                 u32 addr, offset;
4597                 u32 sg_len, len, blen;
4598
4599                 /* determine if physical DMA addr spans 64K boundary.
4600                  * Note h/w doesn't support 64-bit, so we unconditionally
4601                  * truncate dma_addr_t to u32.
4602                  */
4603                 addr = (u32) sg_dma_address(sg);
4604                 sg_len = sg_dma_len(sg);
4605
4606                 while (sg_len) {
4607                         offset = addr & 0xffff;
4608                         len = sg_len;
4609                         if ((offset + sg_len) > 0x10000)
4610                                 len = 0x10000 - offset;
4611
4612                         blen = len & 0xffff;
4613                         ap->prd[idx].addr = cpu_to_le32(addr);
4614                         if (blen == 0) {
4615                            /* Some PATA chipsets like the CS5530 can't
4616                               cope with 0x0000 meaning 64K as the spec says */
4617                                 ap->prd[idx].flags_len = cpu_to_le32(0x8000);
4618                                 blen = 0x8000;
4619                                 ap->prd[++idx].addr = cpu_to_le32(addr + 0x8000);
4620                         }
4621                         ap->prd[idx].flags_len = cpu_to_le32(blen);
4622                         VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
4623
4624                         idx++;
4625                         sg_len -= len;
4626                         addr += len;
4627                 }
4628         }
4629
4630         if (idx)
4631                 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
4632 }
4633
4634 /**
4635  *      ata_check_atapi_dma - Check whether ATAPI DMA can be supported
4636  *      @qc: Metadata associated with taskfile to check
4637  *
4638  *      Allow low-level driver to filter ATA PACKET commands, returning
4639  *      a status indicating whether or not it is OK to use DMA for the
4640  *      supplied PACKET command.
4641  *
4642  *      LOCKING:
4643  *      spin_lock_irqsave(host lock)
4644  *
4645  *      RETURNS: 0 when ATAPI DMA can be used
4646  *               nonzero otherwise
4647  */
4648 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
4649 {
4650         struct ata_port *ap = qc->ap;
4651
4652         /* Don't allow DMA if it isn't multiple of 16 bytes.  Quite a
4653          * few ATAPI devices choke on such DMA requests.
4654          */
4655         if (unlikely(qc->nbytes & 15))
4656                 return 1;
4657
4658         if (ap->ops->check_atapi_dma)
4659                 return ap->ops->check_atapi_dma(qc);
4660
4661         return 0;
4662 }
4663
4664 /**
4665  *      ata_std_qc_defer - Check whether a qc needs to be deferred
4666  *      @qc: ATA command in question
4667  *
4668  *      Non-NCQ commands cannot run with any other command, NCQ or
4669  *      not.  As upper layer only knows the queue depth, we are
4670  *      responsible for maintaining exclusion.  This function checks
4671  *      whether a new command @qc can be issued.
4672  *
4673  *      LOCKING:
4674  *      spin_lock_irqsave(host lock)
4675  *
4676  *      RETURNS:
4677  *      ATA_DEFER_* if deferring is needed, 0 otherwise.
4678  */
4679 int ata_std_qc_defer(struct ata_queued_cmd *qc)
4680 {
4681         struct ata_link *link = qc->dev->link;
4682
4683         if (qc->tf.protocol == ATA_PROT_NCQ) {
4684                 if (!ata_tag_valid(link->active_tag))
4685                         return 0;
4686         } else {
4687                 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4688                         return 0;
4689         }
4690
4691         return ATA_DEFER_LINK;
4692 }
4693
4694 /**
4695  *      ata_qc_prep - Prepare taskfile for submission
4696  *      @qc: Metadata associated with taskfile to be prepared
4697  *
4698  *      Prepare ATA taskfile for submission.
4699  *
4700  *      LOCKING:
4701  *      spin_lock_irqsave(host lock)
4702  */
4703 void ata_qc_prep(struct ata_queued_cmd *qc)
4704 {
4705         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
4706                 return;
4707
4708         ata_fill_sg(qc);
4709 }
4710
4711 /**
4712  *      ata_dumb_qc_prep - Prepare taskfile for submission
4713  *      @qc: Metadata associated with taskfile to be prepared
4714  *
4715  *      Prepare ATA taskfile for submission.
4716  *
4717  *      LOCKING:
4718  *      spin_lock_irqsave(host lock)
4719  */
4720 void ata_dumb_qc_prep(struct ata_queued_cmd *qc)
4721 {
4722         if (!(qc->flags & ATA_QCFLAG_DMAMAP))
4723                 return;
4724
4725         ata_fill_sg_dumb(qc);
4726 }
4727
4728 void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
4729
4730 /**
4731  *      ata_sg_init_one - Associate command with memory buffer
4732  *      @qc: Command to be associated
4733  *      @buf: Memory buffer
4734  *      @buflen: Length of memory buffer, in bytes.
4735  *
4736  *      Initialize the data-related elements of queued_cmd @qc
4737  *      to point to a single memory buffer, @buf of byte length @buflen.
4738  *
4739  *      LOCKING:
4740  *      spin_lock_irqsave(host lock)
4741  */
4742
4743 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
4744 {
4745         qc->flags |= ATA_QCFLAG_SINGLE;
4746
4747         qc->__sg = &qc->sgent;
4748         qc->n_elem = 1;
4749         qc->orig_n_elem = 1;
4750         qc->buf_virt = buf;
4751         qc->nbytes = buflen;
4752         qc->cursg = qc->__sg;
4753
4754         sg_init_one(&qc->sgent, buf, buflen);
4755 }
4756
4757 /**
4758  *      ata_sg_init - Associate command with scatter-gather table.
4759  *      @qc: Command to be associated
4760  *      @sg: Scatter-gather table.
4761  *      @n_elem: Number of elements in s/g table.
4762  *
4763  *      Initialize the data-related elements of queued_cmd @qc
4764  *      to point to a scatter-gather table @sg, containing @n_elem
4765  *      elements.
4766  *
4767  *      LOCKING:
4768  *      spin_lock_irqsave(host lock)
4769  */
4770
4771 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
4772                  unsigned int n_elem)
4773 {
4774         qc->flags |= ATA_QCFLAG_SG;
4775         qc->__sg = sg;
4776         qc->n_elem = n_elem;
4777         qc->orig_n_elem = n_elem;
4778         qc->cursg = qc->__sg;
4779 }
4780
4781 /**
4782  *      ata_sg_setup_one - DMA-map the memory buffer associated with a command.
4783  *      @qc: Command with memory buffer to be mapped.
4784  *
4785  *      DMA-map the memory buffer associated with queued_cmd @qc.
4786  *
4787  *      LOCKING:
4788  *      spin_lock_irqsave(host lock)
4789  *
4790  *      RETURNS:
4791  *      Zero on success, negative on error.
4792  */
4793
4794 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
4795 {
4796         struct ata_port *ap = qc->ap;
4797         int dir = qc->dma_dir;
4798         struct scatterlist *sg = qc->__sg;
4799         dma_addr_t dma_address;
4800         int trim_sg = 0;
4801
4802         /* we must lengthen transfers to end on a 32-bit boundary */
4803         qc->pad_len = sg->length & 3;
4804         if (qc->pad_len) {
4805                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
4806                 struct scatterlist *psg = &qc->pad_sgent;
4807
4808                 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
4809
4810                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
4811
4812                 if (qc->tf.flags & ATA_TFLAG_WRITE)
4813                         memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
4814                                qc->pad_len);
4815
4816                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
4817                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
4818                 /* trim sg */
4819                 sg->length -= qc->pad_len;
4820                 if (sg->length == 0)
4821                         trim_sg = 1;
4822
4823                 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
4824                         sg->length, qc->pad_len);
4825         }
4826
4827         if (trim_sg) {
4828                 qc->n_elem--;
4829                 goto skip_map;
4830         }
4831
4832         dma_address = dma_map_single(ap->dev, qc->buf_virt,
4833                                      sg->length, dir);
4834         if (dma_mapping_error(dma_address)) {
4835                 /* restore sg */
4836                 sg->length += qc->pad_len;
4837                 return -1;
4838         }
4839
4840         sg_dma_address(sg) = dma_address;
4841         sg_dma_len(sg) = sg->length;
4842
4843 skip_map:
4844         DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
4845                 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
4846
4847         return 0;
4848 }
4849
4850 /**
4851  *      ata_sg_setup - DMA-map the scatter-gather table associated with a command.
4852  *      @qc: Command with scatter-gather table to be mapped.
4853  *
4854  *      DMA-map the scatter-gather table associated with queued_cmd @qc.
4855  *
4856  *      LOCKING:
4857  *      spin_lock_irqsave(host lock)
4858  *
4859  *      RETURNS:
4860  *      Zero on success, negative on error.
4861  *
4862  */
4863
4864 static int ata_sg_setup(struct ata_queued_cmd *qc)
4865 {
4866         struct ata_port *ap = qc->ap;
4867         struct scatterlist *sg = qc->__sg;
4868         struct scatterlist *lsg = sg_last(qc->__sg, qc->n_elem);
4869         int n_elem, pre_n_elem, dir, trim_sg = 0;
4870
4871         VPRINTK("ENTER, ata%u\n", ap->print_id);
4872         WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
4873
4874         /* we must lengthen transfers to end on a 32-bit boundary */
4875         qc->pad_len = lsg->length & 3;
4876         if (qc->pad_len) {
4877                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
4878                 struct scatterlist *psg = &qc->pad_sgent;
4879                 unsigned int offset;
4880
4881                 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
4882
4883                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
4884
4885                 /*
4886                  * psg->page/offset are used to copy to-be-written
4887                  * data in this function or read data in ata_sg_clean.
4888                  */
4889                 offset = lsg->offset + lsg->length - qc->pad_len;
4890                 sg_init_table(psg, 1);
4891                 sg_set_page(psg, nth_page(sg_page(lsg), offset >> PAGE_SHIFT),
4892                                 qc->pad_len, offset_in_page(offset));
4893
4894                 if (qc->tf.flags & ATA_TFLAG_WRITE) {
4895                         void *addr = kmap_atomic(sg_page(psg), KM_IRQ0);
4896                         memcpy(pad_buf, addr + psg->offset, qc->pad_len);
4897                         kunmap_atomic(addr, KM_IRQ0);
4898                 }
4899
4900                 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
4901                 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
4902                 /* trim last sg */
4903                 lsg->length -= qc->pad_len;
4904                 if (lsg->length == 0)
4905                         trim_sg = 1;
4906
4907                 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
4908                         qc->n_elem - 1, lsg->length, qc->pad_len);
4909         }
4910
4911         pre_n_elem = qc->n_elem;
4912         if (trim_sg && pre_n_elem)
4913                 pre_n_elem--;
4914
4915         if (!pre_n_elem) {
4916                 n_elem = 0;
4917                 goto skip_map;
4918         }
4919
4920         dir = qc->dma_dir;
4921         n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
4922         if (n_elem < 1) {
4923                 /* restore last sg */
4924                 lsg->length += qc->pad_len;
4925                 return -1;
4926         }
4927
4928         DPRINTK("%d sg elements mapped\n", n_elem);
4929
4930 skip_map:
4931         qc->n_elem = n_elem;
4932
4933         return 0;
4934 }
4935
4936 /**
4937  *      swap_buf_le16 - swap halves of 16-bit words in place
4938  *      @buf:  Buffer to swap
4939  *      @buf_words:  Number of 16-bit words in buffer.
4940  *
4941  *      Swap halves of 16-bit words if needed to convert from
4942  *      little-endian byte order to native cpu byte order, or
4943  *      vice-versa.
4944  *
4945  *      LOCKING:
4946  *      Inherited from caller.
4947  */
4948 void swap_buf_le16(u16 *buf, unsigned int buf_words)
4949 {
4950 #ifdef __BIG_ENDIAN
4951         unsigned int i;
4952
4953         for (i = 0; i < buf_words; i++)
4954                 buf[i] = le16_to_cpu(buf[i]);
4955 #endif /* __BIG_ENDIAN */
4956 }
4957
4958 /**
4959  *      ata_data_xfer - Transfer data by PIO
4960  *      @adev: device to target
4961  *      @buf: data buffer
4962  *      @buflen: buffer length
4963  *      @write_data: read/write
4964  *
4965  *      Transfer data from/to the device data register by PIO.
4966  *
4967  *      LOCKING:
4968  *      Inherited from caller.
4969  */
4970 void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
4971                    unsigned int buflen, int write_data)
4972 {
4973         struct ata_port *ap = adev->link->ap;
4974         unsigned int words = buflen >> 1;
4975
4976         /* Transfer multiple of 2 bytes */
4977         if (write_data)
4978                 iowrite16_rep(ap->ioaddr.data_addr, buf, words);
4979         else
4980                 ioread16_rep(ap->ioaddr.data_addr, buf, words);
4981
4982         /* Transfer trailing 1 byte, if any. */
4983         if (unlikely(buflen & 0x01)) {
4984                 u16 align_buf[1] = { 0 };
4985                 unsigned char *trailing_buf = buf + buflen - 1;
4986
4987                 if (write_data) {
4988                         memcpy(align_buf, trailing_buf, 1);
4989                         iowrite16(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
4990                 } else {
4991                         align_buf[0] = cpu_to_le16(ioread16(ap->ioaddr.data_addr));
4992                         memcpy(trailing_buf, align_buf, 1);
4993                 }
4994         }
4995 }
4996
4997 /**
4998  *      ata_data_xfer_noirq - Transfer data by PIO
4999  *      @adev: device to target
5000  *      @buf: data buffer
5001  *      @buflen: buffer length
5002  *      @write_data: read/write
5003  *
5004  *      Transfer data from/to the device data register by PIO. Do the
5005  *      transfer with interrupts disabled.
5006  *
5007  *      LOCKING:
5008  *      Inherited from caller.
5009  */
5010 void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
5011                          unsigned int buflen, int write_data)
5012 {
5013         unsigned long flags;
5014         local_irq_save(flags);
5015         ata_data_xfer(adev, buf, buflen, write_data);
5016         local_irq_restore(flags);
5017 }
5018
5019
5020 /**
5021  *      ata_pio_sector - Transfer a sector of data.
5022  *      @qc: Command on going
5023  *
5024  *      Transfer qc->sect_size bytes of data from/to the ATA device.
5025  *
5026  *      LOCKING:
5027  *      Inherited from caller.
5028  */
5029
5030 static void ata_pio_sector(struct ata_queued_cmd *qc)
5031 {
5032         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
5033         struct ata_port *ap = qc->ap;
5034         struct page *page;
5035         unsigned int offset;
5036         unsigned char *buf;
5037
5038         if (qc->curbytes == qc->nbytes - qc->sect_size)
5039                 ap->hsm_task_state = HSM_ST_LAST;
5040
5041         page = sg_page(qc->cursg);
5042         offset = qc->cursg->offset + qc->cursg_ofs;
5043
5044         /* get the current page and offset */
5045         page = nth_page(page, (offset >> PAGE_SHIFT));
5046         offset %= PAGE_SIZE;
5047
5048         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
5049
5050         if (PageHighMem(page)) {
5051                 unsigned long flags;
5052
5053                 /* FIXME: use a bounce buffer */
5054                 local_irq_save(flags);
5055                 buf = kmap_atomic(page, KM_IRQ0);
5056
5057                 /* do the actual data transfer */
5058                 ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write);
5059
5060                 kunmap_atomic(buf, KM_IRQ0);
5061                 local_irq_restore(flags);
5062         } else {
5063                 buf = page_address(page);
5064                 ap->ops->data_xfer(qc->dev, buf + offset, qc->sect_size, do_write);
5065         }
5066
5067         qc->curbytes += qc->sect_size;
5068         qc->cursg_ofs += qc->sect_size;
5069
5070         if (qc->cursg_ofs == qc->cursg->length) {
5071                 qc->cursg = sg_next(qc->cursg);
5072                 qc->cursg_ofs = 0;
5073         }
5074 }
5075
5076 /**
5077  *      ata_pio_sectors - Transfer one or many sectors.
5078  *      @qc: Command on going
5079  *
5080  *      Transfer one or many sectors of data from/to the
5081  *      ATA device for the DRQ request.
5082  *
5083  *      LOCKING:
5084  *      Inherited from caller.
5085  */
5086
5087 static void ata_pio_sectors(struct ata_queued_cmd *qc)
5088 {
5089         if (is_multi_taskfile(&qc->tf)) {
5090                 /* READ/WRITE MULTIPLE */
5091                 unsigned int nsect;
5092
5093                 WARN_ON(qc->dev->multi_count == 0);
5094
5095                 nsect = min((qc->nbytes - qc->curbytes) / qc->sect_size,
5096                             qc->dev->multi_count);
5097                 while (nsect--)
5098                         ata_pio_sector(qc);
5099         } else
5100                 ata_pio_sector(qc);
5101
5102         ata_altstatus(qc->ap); /* flush */
5103 }
5104
5105 /**
5106  *      atapi_send_cdb - Write CDB bytes to hardware
5107  *      @ap: Port to which ATAPI device is attached.
5108  *      @qc: Taskfile currently active
5109  *
5110  *      When device has indicated its readiness to accept
5111  *      a CDB, this function is called.  Send the CDB.
5112  *
5113  *      LOCKING:
5114  *      caller.
5115  */
5116
5117 static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
5118 {
5119         /* send SCSI cdb */
5120         DPRINTK("send cdb\n");
5121         WARN_ON(qc->dev->cdb_len < 12);
5122
5123         ap->ops->data_xfer(qc->dev, qc->cdb, qc->dev->cdb_len, 1);
5124         ata_altstatus(ap); /* flush */
5125
5126         switch (qc->tf.protocol) {
5127         case ATA_PROT_ATAPI:
5128                 ap->hsm_task_state = HSM_ST;
5129                 break;
5130         case ATA_PROT_ATAPI_NODATA:
5131                 ap->hsm_task_state = HSM_ST_LAST;
5132                 break;
5133         case ATA_PROT_ATAPI_DMA:
5134                 ap->hsm_task_state = HSM_ST_LAST;
5135                 /* initiate bmdma */
5136                 ap->ops->bmdma_start(qc);
5137                 break;
5138         }
5139 }
5140
5141 /**
5142  *      __atapi_pio_bytes - Transfer data from/to the ATAPI device.
5143  *      @qc: Command on going
5144  *      @bytes: number of bytes
5145  *
5146  *      Transfer Transfer data from/to the ATAPI device.
5147  *
5148  *      LOCKING:
5149  *      Inherited from caller.
5150  *
5151  */
5152
5153 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
5154 {
5155         int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
5156         struct scatterlist *sg = qc->__sg;
5157         struct scatterlist *lsg = sg_last(qc->__sg, qc->n_elem);
5158         struct ata_port *ap = qc->ap;
5159         struct page *page;
5160         unsigned char *buf;
5161         unsigned int offset, count;
5162         int no_more_sg = 0;
5163
5164         if (qc->curbytes + bytes >= qc->nbytes)
5165                 ap->hsm_task_state = HSM_ST_LAST;
5166
5167 next_sg:
5168         if (unlikely(no_more_sg)) {
5169                 /*
5170                  * The end of qc->sg is reached and the device expects
5171                  * more data to transfer. In order not to overrun qc->sg
5172                  * and fulfill length specified in the byte count register,
5173                  *    - for read case, discard trailing data from the device
5174                  *    - for write case, padding zero data to the device
5175                  */
5176                 u16 pad_buf[1] = { 0 };
5177                 unsigned int words = bytes >> 1;
5178                 unsigned int i;
5179
5180                 if (words) /* warning if bytes > 1 */
5181                         ata_dev_printk(qc->dev, KERN_WARNING,
5182                                        "%u bytes trailing data\n", bytes);
5183
5184                 for (i = 0; i < words; i++)
5185                         ap->ops->data_xfer(qc->dev, (unsigned char *)pad_buf, 2, do_write);
5186
5187                 ap->hsm_task_state = HSM_ST_LAST;
5188                 return;
5189         }
5190
5191         sg = qc->cursg;
5192
5193         page = sg_page(sg);
5194         offset = sg->offset + qc->cursg_ofs;
5195
5196         /* get the current page and offset */
5197         page = nth_page(page, (offset >> PAGE_SHIFT));
5198         offset %= PAGE_SIZE;
5199
5200         /* don't overrun current sg */
5201         count = min(sg->length - qc->cursg_ofs, bytes);
5202
5203         /* don't cross page boundaries */
5204         count = min(count, (unsigned int)PAGE_SIZE - offset);
5205
5206         DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
5207
5208         if (PageHighMem(page)) {
5209                 unsigned long flags;
5210
5211                 /* FIXME: use bounce buffer */
5212                 local_irq_save(flags);
5213                 buf = kmap_atomic(page, KM_IRQ0);
5214
5215                 /* do the actual data transfer */
5216                 ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
5217
5218                 kunmap_atomic(buf, KM_IRQ0);
5219                 local_irq_restore(flags);
5220         } else {
5221                 buf = page_address(page);
5222                 ap->ops->data_xfer(qc->dev,  buf + offset, count, do_write);
5223         }
5224
5225         bytes -= count;
5226         qc->curbytes += count;
5227         qc->cursg_ofs += count;
5228
5229         if (qc->cursg_ofs == sg->length) {
5230                 if (qc->cursg == lsg)
5231                         no_more_sg = 1;
5232
5233                 qc->cursg = sg_next(qc->cursg);
5234                 qc->cursg_ofs = 0;
5235         }
5236
5237         if (bytes)
5238                 goto next_sg;
5239 }
5240
5241 /**
5242  *      atapi_pio_bytes - Transfer data from/to the ATAPI device.
5243  *      @qc: Command on going
5244  *
5245  *      Transfer Transfer data from/to the ATAPI device.
5246  *
5247  *      LOCKING:
5248  *      Inherited from caller.
5249  */
5250
5251 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
5252 {
5253         struct ata_port *ap = qc->ap;
5254         struct ata_device *dev = qc->dev;
5255         unsigned int ireason, bc_lo, bc_hi, bytes;
5256         int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
5257
5258         /* Abuse qc->result_tf for temp storage of intermediate TF
5259          * here to save some kernel stack usage.
5260          * For normal completion, qc->result_tf is not relevant. For
5261          * error, qc->result_tf is later overwritten by ata_qc_complete().
5262          * So, the correctness of qc->result_tf is not affected.
5263          */
5264         ap->ops->tf_read(ap, &qc->result_tf);
5265         ireason = qc->result_tf.nsect;
5266         bc_lo = qc->result_tf.lbam;
5267         bc_hi = qc->result_tf.lbah;
5268         bytes = (bc_hi << 8) | bc_lo;
5269
5270         /* shall be cleared to zero, indicating xfer of data */
5271         if (ireason & (1 << 0))
5272                 goto err_out;
5273
5274         /* make sure transfer direction matches expected */
5275         i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
5276         if (do_write != i_write)
5277                 goto err_out;
5278
5279         VPRINTK("ata%u: xfering %d bytes\n", ap->print_id, bytes);
5280
5281         __atapi_pio_bytes(qc, bytes);
5282         ata_altstatus(ap); /* flush */
5283
5284         return;
5285
5286 err_out:
5287         ata_dev_printk(dev, KERN_INFO, "ATAPI check failed\n");
5288         qc->err_mask |= AC_ERR_HSM;
5289         ap->hsm_task_state = HSM_ST_ERR;
5290 }
5291
5292 /**
5293  *      ata_hsm_ok_in_wq - Check if the qc can be handled in the workqueue.
5294  *      @ap: the target ata_port
5295  *      @qc: qc on going
5296  *
5297  *      RETURNS:
5298  *      1 if ok in workqueue, 0 otherwise.
5299  */
5300
5301 static inline int ata_hsm_ok_in_wq(struct ata_port *ap, struct ata_queued_cmd *qc)
5302 {
5303         if (qc->tf.flags & ATA_TFLAG_POLLING)
5304                 return 1;
5305
5306         if (ap->hsm_task_state == HSM_ST_FIRST) {
5307                 if (qc->tf.protocol == ATA_PROT_PIO &&
5308                     (qc->tf.flags & ATA_TFLAG_WRITE))
5309                     return 1;
5310
5311                 if (is_atapi_taskfile(&qc->tf) &&
5312                     !(qc->dev->flags & ATA_DFLAG_CDB_INTR))
5313                         return 1;
5314         }
5315
5316         return 0;
5317 }
5318
5319 /**
5320  *      ata_hsm_qc_complete - finish a qc running on standard HSM
5321  *      @qc: Command to complete
5322  *      @in_wq: 1 if called from workqueue, 0 otherwise
5323  *
5324  *      Finish @qc which is running on standard HSM.
5325  *
5326  *      LOCKING:
5327  *      If @in_wq is zero, spin_lock_irqsave(host lock).
5328  *      Otherwise, none on entry and grabs host lock.
5329  */
5330 static void ata_hsm_qc_complete(struct ata_queued_cmd *qc, int in_wq)
5331 {
5332         struct ata_port *ap = qc->ap;
5333         unsigned long flags;
5334
5335         if (ap->ops->error_handler) {
5336                 if (in_wq) {
5337                         spin_lock_irqsave(ap->lock, flags);
5338
5339                         /* EH might have kicked in while host lock is
5340                          * released.
5341                          */
5342                         qc = ata_qc_from_tag(ap, qc->tag);
5343                         if (qc) {
5344                                 if (likely(!(qc->err_mask & AC_ERR_HSM))) {
5345                                         ap->ops->irq_on(ap);
5346                                         ata_qc_complete(qc);
5347                                 } else
5348                                         ata_port_freeze(ap);
5349                         }
5350
5351                         spin_unlock_irqrestore(ap->lock, flags);
5352                 } else {
5353                         if (likely(!(qc->err_mask & AC_ERR_HSM)))
5354                                 ata_qc_complete(qc);
5355                         else
5356                                 ata_port_freeze(ap);
5357                 }
5358         } else {
5359                 if (in_wq) {
5360                         spin_lock_irqsave(ap->lock, flags);
5361                         ap->ops->irq_on(ap);
5362                         ata_qc_complete(qc);
5363                         spin_unlock_irqrestore(ap->lock, flags);
5364                 } else
5365                         ata_qc_complete(qc);
5366         }
5367 }
5368
5369 /**
5370  *      ata_hsm_move - move the HSM to the next state.
5371  *      @ap: the target ata_port
5372  *      @qc: qc on going
5373  *      @status: current device status
5374  *      @in_wq: 1 if called from workqueue, 0 otherwise
5375  *
5376  *      RETURNS:
5377  *      1 when poll next status needed, 0 otherwise.
5378  */
5379 int ata_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
5380                  u8 status, int in_wq)
5381 {
5382         unsigned long flags = 0;
5383         int poll_next;
5384
5385         WARN_ON((qc->flags & ATA_QCFLAG_ACTIVE) == 0);
5386
5387         /* Make sure ata_qc_issue_prot() does not throw things
5388          * like DMA polling into the workqueue. Notice that
5389          * in_wq is not equivalent to (qc->tf.flags & ATA_TFLAG_POLLING).
5390          */
5391         WARN_ON(in_wq != ata_hsm_ok_in_wq(ap, qc));
5392
5393 fsm_start:
5394         DPRINTK("ata%u: protocol %d task_state %d (dev_stat 0x%X)\n",
5395                 ap->print_id, qc->tf.protocol, ap->hsm_task_state, status);
5396
5397         switch (ap->hsm_task_state) {
5398         case HSM_ST_FIRST:
5399                 /* Send first data block or PACKET CDB */
5400
5401                 /* If polling, we will stay in the work queue after
5402                  * sending the data. Otherwise, interrupt handler
5403                  * takes over after sending the data.
5404                  */
5405                 poll_next = (qc->tf.flags & ATA_TFLAG_POLLING);
5406
5407                 /* check device status */
5408                 if (unlikely((status & ATA_DRQ) == 0)) {
5409                         /* handle BSY=0, DRQ=0 as error */
5410                         if (likely(status & (ATA_ERR | ATA_DF)))
5411                                 /* device stops HSM for abort/error */
5412                                 qc->err_mask |= AC_ERR_DEV;
5413                         else
5414                                 /* HSM violation. Let EH handle this */
5415                                 qc->err_mask |= AC_ERR_HSM;
5416
5417                         ap->hsm_task_state = HSM_ST_ERR;
5418                         goto fsm_start;
5419                 }
5420
5421                 /* Device should not ask for data transfer (DRQ=1)
5422                  * when it finds something wrong.
5423                  * We ignore DRQ here and stop the HSM by
5424                  * changing hsm_task_state to HSM_ST_ERR and
5425                  * let the EH abort the command or reset the device.
5426                  */
5427                 if (unlikely(status & (ATA_ERR | ATA_DF))) {
5428                         /* Some ATAPI tape drives forget to clear the ERR bit
5429                          * when doing the next command (mostly request sense).
5430                          * We ignore ERR here to workaround and proceed sending
5431                          * the CDB.
5432                          */
5433                         if (!(qc->dev->horkage & ATA_HORKAGE_STUCK_ERR)) {
5434                                 ata_port_printk(ap, KERN_WARNING,
5435                                                 "DRQ=1 with device error, "
5436                                                 "dev_stat 0x%X\n", status);
5437                                 qc->err_mask |= AC_ERR_HSM;
5438                                 ap->hsm_task_state = HSM_ST_ERR;
5439                                 goto fsm_start;
5440                         }
5441                 }
5442
5443                 /* Send the CDB (atapi) or the first data block (ata pio out).
5444                  * During the state transition, interrupt handler shouldn't
5445                  * be invoked before the data transfer is complete and
5446                  * hsm_task_state is changed. Hence, the following locking.
5447                  */
5448                 if (in_wq)
5449                         spin_lock_irqsave(ap->lock, flags);
5450
5451                 if (qc->tf.protocol == ATA_PROT_PIO) {
5452                         /* PIO data out protocol.
5453                          * send first data block.
5454                          */
5455
5456                         /* ata_pio_sectors() might change the state
5457                          * to HSM_ST_LAST. so, the state is changed here
5458                          * before ata_pio_sectors().
5459                          */
5460                         ap->hsm_task_state = HSM_ST;
5461                         ata_pio_sectors(qc);
5462                 } else
5463                         /* send CDB */
5464                         atapi_send_cdb(ap, qc);
5465
5466                 if (in_wq)
5467                         spin_unlock_irqrestore(ap->lock, flags);
5468
5469                 /* if polling, ata_pio_task() handles the rest.
5470                  * otherwise, interrupt handler takes over from here.
5471                  */
5472                 break;
5473
5474         case HSM_ST:
5475                 /* complete command or read/write the data register */
5476                 if (qc->tf.protocol == ATA_PROT_ATAPI) {
5477                         /* ATAPI PIO protocol */
5478                         if ((status & ATA_DRQ) == 0) {
5479                                 /* No more data to transfer or device error.
5480                                  * Device error will be tagged in HSM_ST_LAST.
5481                                  */
5482                                 ap->hsm_task_state = HSM_ST_LAST;
5483                                 goto fsm_start;
5484                         }
5485
5486                         /* Device should not ask for data transfer (DRQ=1)
5487                          * when it finds something wrong.
5488                          * We ignore DRQ here and stop the HSM by
5489                          * changing hsm_task_state to HSM_ST_ERR and
5490                          * let the EH abort the command or reset the device.
5491                          */
5492                         if (unlikely(status & (ATA_ERR | ATA_DF))) {
5493                                 ata_port_printk(ap, KERN_WARNING, "DRQ=1 with "
5494                                                 "device error, dev_stat 0x%X\n",
5495                                                 status);
5496                                 qc->err_mask |= AC_ERR_HSM;
5497                                 ap->hsm_task_state = HSM_ST_ERR;
5498                                 goto fsm_start;
5499                         }
5500
5501                         atapi_pio_bytes(qc);
5502
5503                         if (unlikely(ap->hsm_task_state == HSM_ST_ERR))
5504                                 /* bad ireason reported by device */
5505                                 goto fsm_start;
5506
5507                 } else {
5508                         /* ATA PIO protocol */
5509                         if (unlikely((status & ATA_DRQ) == 0)) {
5510                                 /* handle BSY=0, DRQ=0 as error */
5511                                 if (likely(status & (ATA_ERR | ATA_DF)))
5512                                         /* device stops HSM for abort/error */
5513                                         qc->err_mask |= AC_ERR_DEV;
5514                                 else
5515                                         /* HSM violation. Let EH handle this.
5516                                          * Phantom devices also trigger this
5517                                          * condition.  Mark hint.
5518                                          */
5519                                         qc->err_mask |= AC_ERR_HSM |
5520                                                         AC_ERR_NODEV_HINT;
5521
5522                                 ap->hsm_task_state = HSM_ST_ERR;
5523                                 goto fsm_start;
5524                         }
5525
5526                         /* For PIO reads, some devices may ask for
5527                          * data transfer (DRQ=1) alone with ERR=1.
5528                          * We respect DRQ here and transfer one
5529                          * block of junk data before changing the
5530                          * hsm_task_state to HSM_ST_ERR.
5531                          *
5532                          * For PIO writes, ERR=1 DRQ=1 doesn't make
5533                          * sense since the data block has been
5534                          * transferred to the device.
5535                          */
5536                         if (unlikely(status & (ATA_ERR | ATA_DF))) {
5537                                 /* data might be corrputed */
5538                                 qc->err_mask |= AC_ERR_DEV;
5539
5540                                 if (!(qc->tf.flags & ATA_TFLAG_WRITE)) {
5541                                         ata_pio_sectors(qc);
5542                                         status = ata_wait_idle(ap);
5543                                 }
5544
5545                                 if (status & (ATA_BUSY | ATA_DRQ))
5546                                         qc->err_mask |= AC_ERR_HSM;
5547
5548                                 /* ata_pio_sectors() might change the
5549                                  * state to HSM_ST_LAST. so, the state
5550                                  * is changed after ata_pio_sectors().
5551                                  */
5552                                 ap->hsm_task_state = HSM_ST_ERR;
5553                                 goto fsm_start;
5554                         }
5555
5556                         ata_pio_sectors(qc);
5557
5558                         if (ap->hsm_task_state == HSM_ST_LAST &&
5559                             (!(qc->tf.flags & ATA_TFLAG_WRITE))) {
5560                                 /* all data read */
5561                                 status = ata_wait_idle(ap);
5562                                 goto fsm_start;
5563                         }
5564                 }
5565
5566                 poll_next = 1;
5567                 break;
5568
5569         case HSM_ST_LAST:
5570                 if (unlikely(!ata_ok(status))) {
5571                         qc->err_mask |= __ac_err_mask(status);
5572                         ap->hsm_task_state = HSM_ST_ERR;
5573                         goto fsm_start;
5574                 }
5575
5576                 /* no more data to transfer */
5577                 DPRINTK("ata%u: dev %u command complete, drv_stat 0x%x\n",
5578                         ap->print_id, qc->dev->devno, status);
5579
5580                 WARN_ON(qc->err_mask);
5581
5582                 ap->hsm_task_state = HSM_ST_IDLE;
5583
5584                 /* complete taskfile transaction */
5585                 ata_hsm_qc_complete(qc, in_wq);
5586
5587                 poll_next = 0;
5588                 break;
5589
5590         case HSM_ST_ERR:
5591                 /* make sure qc->err_mask is available to
5592                  * know what's wrong and recover
5593                  */
5594                 WARN_ON(qc->err_mask == 0);
5595
5596                 ap->hsm_task_state = HSM_ST_IDLE;
5597
5598                 /* complete taskfile transaction */
5599                 ata_hsm_qc_complete(qc, in_wq);
5600
5601                 poll_next = 0;
5602                 break;
5603         default:
5604                 poll_next = 0;
5605                 BUG();
5606         }
5607
5608         return poll_next;
5609 }
5610
5611 static void ata_pio_task(struct work_struct *work)
5612 {
5613         struct ata_port *ap =
5614                 container_of(work, struct ata_port, port_task.work);
5615         struct ata_queued_cmd *qc = ap->port_task_data;
5616         u8 status;
5617         int poll_next;
5618
5619 fsm_start:
5620         WARN_ON(ap->hsm_task_state == HSM_ST_IDLE);
5621
5622         /*
5623          * This is purely heuristic.  This is a fast path.
5624          * Sometimes when we enter, BSY will be cleared in
5625          * a chk-status or two.  If not, the drive is probably seeking
5626          * or something.  Snooze for a couple msecs, then
5627          * chk-status again.  If still busy, queue delayed work.
5628          */
5629         status = ata_busy_wait(ap, ATA_BUSY, 5);
5630         if (status & ATA_BUSY) {
5631                 msleep(2);
5632                 status = ata_busy_wait(ap, ATA_BUSY, 10);
5633                 if (status & ATA_BUSY) {
5634                         ata_port_queue_task(ap, ata_pio_task, qc, ATA_SHORT_PAUSE);
5635                         return;
5636                 }
5637         }
5638
5639         /* move the HSM */
5640         poll_next = ata_hsm_move(ap, qc, status, 1);
5641
5642         /* another command or interrupt handler
5643          * may be running at this point.
5644          */
5645         if (poll_next)
5646                 goto fsm_start;
5647 }
5648
5649 /**
5650  *      ata_qc_new - Request an available ATA command, for queueing
5651  *      @ap: Port associated with device @dev
5652  *      @dev: Device from whom we request an available command structure
5653  *
5654  *      LOCKING:
5655  *      None.
5656  */
5657
5658 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
5659 {
5660         struct ata_queued_cmd *qc = NULL;
5661         unsigned int i;
5662
5663         /* no command while frozen */
5664         if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
5665                 return NULL;
5666
5667         /* the last tag is reserved for internal command. */
5668         for (i = 0; i < ATA_MAX_QUEUE - 1; i++)
5669                 if (!test_and_set_bit(i, &ap->qc_allocated)) {
5670                         qc = __ata_qc_from_tag(ap, i);
5671                         break;
5672                 }
5673
5674         if (qc)
5675                 qc->tag = i;
5676
5677         return qc;
5678 }
5679
5680 /**
5681  *      ata_qc_new_init - Request an available ATA command, and initialize it
5682  *      @dev: Device from whom we request an available command structure
5683  *
5684  *      LOCKING:
5685  *      None.
5686  */
5687
5688 struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev)
5689 {
5690         struct ata_port *ap = dev->link->ap;
5691         struct ata_queued_cmd *qc;
5692
5693         qc = ata_qc_new(ap);
5694         if (qc) {
5695                 qc->scsicmd = NULL;
5696                 qc->ap = ap;
5697                 qc->dev = dev;
5698
5699                 ata_qc_reinit(qc);
5700         }
5701
5702         return qc;
5703 }
5704
5705 /**
5706  *      ata_qc_free - free unused ata_queued_cmd
5707  *      @qc: Command to complete
5708  *
5709  *      Designed to free unused ata_queued_cmd object
5710  *      in case something prevents using it.
5711  *
5712  *      LOCKING:
5713  *      spin_lock_irqsave(host lock)
5714  */
5715 void ata_qc_free(struct ata_queued_cmd *qc)
5716 {
5717         struct ata_port *ap = qc->ap;
5718         unsigned int tag;
5719
5720         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
5721
5722         qc->flags = 0;
5723         tag = qc->tag;
5724         if (likely(ata_tag_valid(tag))) {
5725                 qc->tag = ATA_TAG_POISON;
5726                 clear_bit(tag, &ap->qc_allocated);
5727         }
5728 }
5729
5730 void __ata_qc_complete(struct ata_queued_cmd *qc)
5731 {
5732         struct ata_port *ap = qc->ap;
5733         struct ata_link *link = qc->dev->link;
5734
5735         WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
5736         WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
5737
5738         if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
5739                 ata_sg_clean(qc);
5740
5741         /* command should be marked inactive atomically with qc completion */
5742         if (qc->tf.protocol == ATA_PROT_NCQ) {
5743                 link->sactive &= ~(1 << qc->tag);
5744                 if (!link->sactive)
5745                         ap->nr_active_links--;
5746         } else {
5747                 link->active_tag = ATA_TAG_POISON;
5748                 ap->nr_active_links--;
5749         }
5750
5751         /* clear exclusive status */
5752         if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
5753                      ap->excl_link == link))
5754                 ap->excl_link = NULL;
5755
5756         /* atapi: mark qc as inactive to prevent the interrupt handler
5757          * from completing the command twice later, before the error handler
5758          * is called. (when rc != 0 and atapi request sense is needed)
5759          */
5760         qc->flags &= ~ATA_QCFLAG_ACTIVE;
5761         ap->qc_active &= ~(1 << qc->tag);
5762
5763         /* call completion callback */
5764         qc->complete_fn(qc);
5765 }
5766
5767 static void fill_result_tf(struct ata_queued_cmd *qc)
5768 {
5769         struct ata_port *ap = qc->ap;
5770
5771         qc->result_tf.flags = qc->tf.flags;
5772         ap->ops->tf_read(ap, &qc->result_tf);
5773 }
5774
5775 /**
5776  *      ata_qc_complete - Complete an active ATA command
5777  *      @qc: Command to complete
5778  *      @err_mask: ATA Status register contents
5779  *
5780  *      Indicate to the mid and upper layers that an ATA
5781  *      command has completed, with either an ok or not-ok status.
5782  *
5783  *      LOCKING:
5784  *      spin_lock_irqsave(host lock)
5785  */
5786 void ata_qc_complete(struct ata_queued_cmd *qc)
5787 {
5788         struct ata_port *ap = qc->ap;
5789
5790         /* XXX: New EH and old EH use different mechanisms to
5791          * synchronize EH with regular execution path.
5792          *
5793          * In new EH, a failed qc is marked with ATA_QCFLAG_FAILED.
5794          * Normal execution path is responsible for not accessing a
5795          * failed qc.  libata core enforces the rule by returning NULL
5796          * from ata_qc_from_tag() for failed qcs.
5797          *
5798          * Old EH depends on ata_qc_complete() nullifying completion
5799          * requests if ATA_QCFLAG_EH_SCHEDULED is set.  Old EH does
5800          * not synchronize with interrupt handler.  Only PIO task is
5801          * taken care of.
5802          */
5803         if (ap->ops->error_handler) {
5804                 struct ata_device *dev = qc->dev;
5805                 struct ata_eh_info *ehi = &dev->link->eh_info;
5806
5807                 WARN_ON(ap->pflags & ATA_PFLAG_FROZEN);
5808
5809                 if (unlikely(qc->err_mask))
5810                         qc->flags |= ATA_QCFLAG_FAILED;
5811
5812                 if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
5813                         if (!ata_tag_internal(qc->tag)) {
5814                                 /* always fill result TF for failed qc */
5815                                 fill_result_tf(qc);
5816                                 ata_qc_schedule_eh(qc);
5817                                 return;
5818                         }
5819                 }
5820
5821                 /* read result TF if requested */
5822                 if (qc->flags & ATA_QCFLAG_RESULT_TF)
5823                         fill_result_tf(qc);
5824
5825                 /* Some commands need post-processing after successful
5826                  * completion.
5827                  */
5828                 switch (qc->tf.command) {
5829                 case ATA_CMD_SET_FEATURES:
5830                         if (qc->tf.feature != SETFEATURES_WC_ON &&
5831                             qc->tf.feature != SETFEATURES_WC_OFF)
5832                                 break;
5833                         /* fall through */
5834                 case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
5835                 case ATA_CMD_SET_MULTI: /* multi_count changed */
5836                         /* revalidate device */
5837                         ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE;
5838                         ata_port_schedule_eh(ap);
5839                         break;
5840
5841                 case ATA_CMD_SLEEP:
5842                         dev->flags |= ATA_DFLAG_SLEEPING;
5843                         break;
5844                 }
5845
5846                 __ata_qc_complete(qc);
5847         } else {
5848                 if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
5849                         return;
5850
5851                 /* read result TF if failed or requested */
5852                 if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
5853                         fill_result_tf(qc);
5854
5855                 __ata_qc_complete(qc);
5856         }
5857 }
5858
5859 /**
5860  *      ata_qc_complete_multiple - Complete multiple qcs successfully
5861  *      @ap: port in question
5862  *      @qc_active: new qc_active mask
5863  *      @finish_qc: LLDD callback invoked before completing a qc
5864  *
5865  *      Complete in-flight commands.  This functions is meant to be
5866  *      called from low-level driver's interrupt routine to complete
5867  *      requests normally.  ap->qc_active and @qc_active is compared
5868  *      and commands are completed accordingly.
5869  *
5870  *      LOCKING:
5871  *      spin_lock_irqsave(host lock)
5872  *
5873  *      RETURNS:
5874  *      Number of completed commands on success, -errno otherwise.
5875  */
5876 int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active,
5877                              void (*finish_qc)(struct ata_queued_cmd *))
5878 {
5879         int nr_done = 0;
5880         u32 done_mask;
5881         int i;
5882
5883         done_mask = ap->qc_active ^ qc_active;
5884
5885         if (unlikely(done_mask & qc_active)) {
5886                 ata_port_printk(ap, KERN_ERR, "illegal qc_active transition "
5887                                 "(%08x->%08x)\n", ap->qc_active, qc_active);
5888                 return -EINVAL;
5889         }
5890
5891         for (i = 0; i < ATA_MAX_QUEUE; i++) {
5892                 struct ata_queued_cmd *qc;
5893
5894                 if (!(done_mask & (1 << i)))
5895                         continue;
5896
5897                 if ((qc = ata_qc_from_tag(ap, i))) {
5898                         if (finish_qc)
5899                                 finish_qc(qc);
5900                         ata_qc_complete(qc);
5901                         nr_done++;
5902                 }
5903         }
5904
5905         return nr_done;
5906 }
5907
5908 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
5909 {
5910         struct ata_port *ap = qc->ap;
5911
5912         switch (qc->tf.protocol) {
5913         case ATA_PROT_NCQ:
5914         case ATA_PROT_DMA:
5915         case ATA_PROT_ATAPI_DMA:
5916                 return 1;
5917
5918         case ATA_PROT_ATAPI:
5919         case ATA_PROT_PIO:
5920                 if (ap->flags & ATA_FLAG_PIO_DMA)
5921                         return 1;
5922
5923                 /* fall through */
5924
5925         default:
5926                 return 0;
5927         }
5928
5929         /* never reached */
5930 }
5931
5932 /**
5933  *      ata_qc_issue - issue taskfile to device
5934  *      @qc: command to issue to device
5935  *
5936  *      Prepare an ATA command to submission to device.
5937  *      This includes mapping the data into a DMA-able
5938  *      area, filling in the S/G table, and finally
5939  *      writing the taskfile to hardware, starting the command.
5940  *
5941  *      LOCKING:
5942  *      spin_lock_irqsave(host lock)
5943  */
5944 void ata_qc_issue(struct ata_queued_cmd *qc)
5945 {
5946         struct ata_port *ap = qc->ap;
5947         struct ata_link *link = qc->dev->link;
5948
5949         /* Make sure only one non-NCQ command is outstanding.  The
5950          * check is skipped for old EH because it reuses active qc to
5951          * request ATAPI sense.
5952          */
5953         WARN_ON(ap->ops->error_handler && ata_tag_valid(link->active_tag));
5954
5955         if (qc->tf.protocol == ATA_PROT_NCQ) {
5956                 WARN_ON(link->sactive & (1 << qc->tag));
5957
5958                 if (!link->sactive)
5959                         ap->nr_active_links++;
5960                 link->sactive |= 1 << qc->tag;
5961         } else {
5962                 WARN_ON(link->sactive);
5963
5964                 ap->nr_active_links++;
5965                 link->active_tag = qc->tag;
5966         }
5967
5968         qc->flags |= ATA_QCFLAG_ACTIVE;
5969         ap->qc_active |= 1 << qc->tag;
5970
5971         if (ata_should_dma_map(qc)) {
5972                 if (qc->flags & ATA_QCFLAG_SG) {
5973                         if (ata_sg_setup(qc))
5974                                 goto sg_err;
5975                 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
5976                         if (ata_sg_setup_one(qc))
5977                                 goto sg_err;
5978                 }
5979         } else {
5980                 qc->flags &= ~ATA_QCFLAG_DMAMAP;
5981         }
5982
5983         /* if device is sleeping, schedule softreset and abort the link */
5984         if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
5985                 link->eh_info.action |= ATA_EH_SOFTRESET;
5986                 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
5987                 ata_link_abort(link);
5988                 return;
5989         }
5990
5991         ap->ops->qc_prep(qc);
5992
5993         qc->err_mask |= ap->ops->qc_issue(qc);
5994         if (unlikely(qc->err_mask))
5995                 goto err;
5996         return;
5997
5998 sg_err:
5999         qc->flags &= ~ATA_QCFLAG_DMAMAP;
6000         qc->err_mask |= AC_ERR_SYSTEM;
6001 err:
6002         ata_qc_complete(qc);
6003 }
6004
6005 /**
6006  *      ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
6007  *      @qc: command to issue to device
6008  *
6009  *      Using various libata functions and hooks, this function
6010  *      starts an ATA command.  ATA commands are grouped into
6011  *      classes called "protocols", and issuing each type of protocol
6012  *      is slightly different.
6013  *
6014  *      May be used as the qc_issue() entry in ata_port_operations.
6015  *
6016  *      LOCKING:
6017  *      spin_lock_irqsave(host lock)
6018  *
6019  *      RETURNS:
6020  *      Zero on success, AC_ERR_* mask on failure
6021  */
6022
6023 unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
6024 {
6025         struct ata_port *ap = qc->ap;
6026
6027         /* Use polling pio if the LLD doesn't handle
6028          * interrupt driven pio and atapi CDB interrupt.
6029          */
6030         if (ap->flags & ATA_FLAG_PIO_POLLING) {
6031                 switch (qc->tf.protocol) {
6032                 case ATA_PROT_PIO:
6033                 case ATA_PROT_NODATA:
6034                 case ATA_PROT_ATAPI:
6035                 case ATA_PROT_ATAPI_NODATA:
6036                         qc->tf.flags |= ATA_TFLAG_POLLING;
6037                         break;
6038                 case ATA_PROT_ATAPI_DMA:
6039                         if (qc->dev->flags & ATA_DFLAG_CDB_INTR)
6040                                 /* see ata_dma_blacklisted() */
6041                                 BUG();
6042                         break;
6043                 default:
6044                         break;
6045                 }
6046         }
6047
6048         /* select the device */
6049         ata_dev_select(ap, qc->dev->devno, 1, 0);
6050
6051         /* start the command */
6052         switch (qc->tf.protocol) {
6053         case ATA_PROT_NODATA:
6054                 if (qc->tf.flags & ATA_TFLAG_POLLING)
6055                         ata_qc_set_polling(qc);
6056
6057                 ata_tf_to_host(ap, &qc->tf);
6058                 ap->hsm_task_state = HSM_ST_LAST;
6059
6060                 if (qc->tf.flags & ATA_TFLAG_POLLING)
6061                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
6062
6063                 break;
6064
6065         case ATA_PROT_DMA:
6066                 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
6067
6068                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
6069                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
6070                 ap->ops->bmdma_start(qc);           /* initiate bmdma */
6071                 ap->hsm_task_state = HSM_ST_LAST;
6072                 break;
6073
6074         case ATA_PROT_PIO:
6075                 if (qc->tf.flags & ATA_TFLAG_POLLING)
6076                         ata_qc_set_polling(qc);
6077
6078                 ata_tf_to_host(ap, &qc->tf);
6079
6080                 if (qc->tf.flags & ATA_TFLAG_WRITE) {
6081                         /* PIO data out protocol */
6082                         ap->hsm_task_state = HSM_ST_FIRST;
6083                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
6084
6085                         /* always send first data block using
6086                          * the ata_pio_task() codepath.
6087                          */
6088                 } else {
6089                         /* PIO data in protocol */
6090                         ap->hsm_task_state = HSM_ST;
6091
6092                         if (qc->tf.flags & ATA_TFLAG_POLLING)
6093                                 ata_port_queue_task(ap, ata_pio_task, qc, 0);
6094
6095                         /* if polling, ata_pio_task() handles the rest.
6096                          * otherwise, interrupt handler takes over from here.
6097                          */
6098                 }
6099
6100                 break;
6101
6102         case ATA_PROT_ATAPI:
6103         case ATA_PROT_ATAPI_NODATA:
6104                 if (qc->tf.flags & ATA_TFLAG_POLLING)
6105                         ata_qc_set_polling(qc);
6106
6107                 ata_tf_to_host(ap, &qc->tf);
6108
6109                 ap->hsm_task_state = HSM_ST_FIRST;
6110
6111                 /* send cdb by polling if no cdb interrupt */
6112                 if ((!(qc->dev->flags & ATA_DFLAG_CDB_INTR)) ||
6113                     (qc->tf.flags & ATA_TFLAG_POLLING))
6114                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
6115                 break;
6116
6117         case ATA_PROT_ATAPI_DMA:
6118                 WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
6119
6120                 ap->ops->tf_load(ap, &qc->tf);   /* load tf registers */
6121                 ap->ops->bmdma_setup(qc);           /* set up bmdma */
6122                 ap->hsm_task_state = HSM_ST_FIRST;
6123
6124                 /* send cdb by polling if no cdb interrupt */
6125                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
6126                         ata_port_queue_task(ap, ata_pio_task, qc, 0);
6127                 break;
6128
6129         default:
6130                 WARN_ON(1);
6131                 return AC_ERR_SYSTEM;
6132         }
6133
6134         return 0;
6135 }
6136
6137 /**
6138  *      ata_host_intr - Handle host interrupt for given (port, task)
6139  *      @ap: Port on which interrupt arrived (possibly...)
6140  *      @qc: Taskfile currently active in engine
6141  *
6142  *      Handle host interrupt for given queued command.  Currently,
6143  *      only DMA interrupts are handled.  All other commands are
6144  *      handled via polling with interrupts disabled (nIEN bit).
6145  *
6146  *      LOCKING:
6147  *      spin_lock_irqsave(host lock)
6148  *
6149  *      RETURNS:
6150  *      One if interrupt was handled, zero if not (shared irq).
6151  */
6152
6153 inline unsigned int ata_host_intr(struct ata_port *ap,
6154                                   struct ata_queued_cmd *qc)
6155 {
6156         struct ata_eh_info *ehi = &ap->link.eh_info;
6157         u8 status, host_stat = 0;
6158
6159         VPRINTK("ata%u: protocol %d task_state %d\n",
6160                 ap->print_id, qc->tf.protocol, ap->hsm_task_state);
6161
6162         /* Check whether we are expecting interrupt in this state */
6163         switch (ap->hsm_task_state) {
6164         case HSM_ST_FIRST:
6165                 /* Some pre-ATAPI-4 devices assert INTRQ
6166                  * at this state when ready to receive CDB.
6167                  */
6168
6169                 /* Check the ATA_DFLAG_CDB_INTR flag is enough here.
6170                  * The flag was turned on only for atapi devices.
6171                  * No need to check is_atapi_taskfile(&qc->tf) again.
6172                  */
6173                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
6174                         goto idle_irq;
6175                 break;
6176         case HSM_ST_LAST:
6177                 if (qc->tf.protocol == ATA_PROT_DMA ||
6178                     qc->tf.protocol == ATA_PROT_ATAPI_DMA) {
6179                         /* check status of DMA engine */
6180                         host_stat = ap->ops->bmdma_status(ap);
6181                         VPRINTK("ata%u: host_stat 0x%X\n",
6182                                 ap->print_id, host_stat);
6183
6184                         /* if it's not our irq... */
6185                         if (!(host_stat & ATA_DMA_INTR))
6186                                 goto idle_irq;
6187
6188                         /* before we do anything else, clear DMA-Start bit */
6189                         ap->ops->bmdma_stop(qc);
6190
6191                         if (unlikely(host_stat & ATA_DMA_ERR)) {
6192                                 /* error when transfering data to/from memory */
6193                                 qc->err_mask |= AC_ERR_HOST_BUS;
6194                                 ap->hsm_task_state = HSM_ST_ERR;
6195                         }
6196                 }
6197                 break;
6198         case HSM_ST:
6199                 break;
6200         default:
6201                 goto idle_irq;
6202         }
6203
6204         /* check altstatus */
6205         status = ata_altstatus(ap);
6206         if (status & ATA_BUSY)
6207                 goto idle_irq;
6208
6209         /* check main status, clearing INTRQ */
6210         status = ata_chk_status(ap);
6211         if (unlikely(status & ATA_BUSY))
6212                 goto idle_irq;
6213
6214         /* ack bmdma irq events */
6215         ap->ops->irq_clear(ap);
6216
6217         ata_hsm_move(ap, qc, status, 0);
6218
6219         if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA ||
6220                                        qc->tf.protocol == ATA_PROT_ATAPI_DMA))
6221                 ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
6222
6223         return 1;       /* irq handled */
6224
6225 idle_irq:
6226         ap->stats.idle_irq++;
6227
6228 #ifdef ATA_IRQ_TRAP
6229         if ((ap->stats.idle_irq % 1000) == 0) {
6230                 ata_chk_status(ap);
6231                 ap->ops->irq_clear(ap);
6232                 ata_port_printk(ap, KERN_WARNING, "irq trap\n");
6233                 return 1;
6234         }
6235 #endif
6236         return 0;       /* irq not handled */
6237 }
6238
6239 /**
6240  *      ata_interrupt - Default ATA host interrupt handler
6241  *      @irq: irq line (unused)
6242  *      @dev_instance: pointer to our ata_host information structure
6243  *
6244  *      Default interrupt handler for PCI IDE devices.  Calls
6245  *      ata_host_intr() for each port that is not disabled.
6246  *
6247  *      LOCKING:
6248  *      Obtains host lock during operation.
6249  *
6250  *      RETURNS:
6251  *      IRQ_NONE or IRQ_HANDLED.
6252  */
6253
6254 irqreturn_t ata_interrupt(int irq, void *dev_instance)
6255 {
6256         struct ata_host *host = dev_instance;
6257         unsigned int i;
6258         unsigned int handled = 0;
6259         unsigned long flags;
6260
6261         /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
6262         spin_lock_irqsave(&host->lock, flags);
6263
6264         for (i = 0; i < host->n_ports; i++) {
6265                 struct ata_port *ap;
6266
6267                 ap = host->ports[i];
6268                 if (ap &&
6269                     !(ap->flags & ATA_FLAG_DISABLED)) {
6270                         struct ata_queued_cmd *qc;
6271
6272                         qc = ata_qc_from_tag(ap, ap->link.active_tag);
6273                         if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
6274                             (qc->flags & ATA_QCFLAG_ACTIVE))
6275                                 handled |= ata_host_intr(ap, qc);
6276                 }
6277         }
6278
6279         spin_unlock_irqrestore(&host->lock, flags);
6280
6281         return IRQ_RETVAL(handled);
6282 }
6283
6284 /**
6285  *      sata_scr_valid - test whether SCRs are accessible
6286  *      @link: ATA link to test SCR accessibility for
6287  *
6288  *      Test whether SCRs are accessible for @link.
6289  *
6290  *      LOCKING:
6291  *      None.
6292  *
6293  *      RETURNS:
6294  *      1 if SCRs are accessible, 0 otherwise.
6295  */
6296 int sata_scr_valid(struct ata_link *link)
6297 {
6298         struct ata_port *ap = link->ap;
6299
6300         return (ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read;
6301 }
6302
6303 /**
6304  *      sata_scr_read - read SCR register of the specified port
6305  *      @link: ATA link to read SCR for
6306  *      @reg: SCR to read
6307  *      @val: Place to store read value
6308  *
6309  *      Read SCR register @reg of @link into *@val.  This function is
6310  *      guaranteed to succeed if @link is ap->link, the cable type of
6311  *      the port is SATA and the port implements ->scr_read.
6312  *
6313  *      LOCKING:
6314  *      None if @link is ap->link.  Kernel thread context otherwise.
6315  *
6316  *      RETURNS:
6317  *      0 on success, negative errno on failure.
6318  */
6319 int sata_scr_read(struct ata_link *link, int reg, u32 *val)
6320 {
6321         if (ata_is_host_link(link)) {
6322                 struct ata_port *ap = link->ap;
6323
6324                 if (sata_scr_valid(link))
6325                         return ap->ops->scr_read(ap, reg, val);
6326                 return -EOPNOTSUPP;
6327         }
6328
6329         return sata_pmp_scr_read(link, reg, val);
6330 }
6331
6332 /**
6333  *      sata_scr_write - write SCR register of the specified port
6334  *      @link: ATA link to write SCR for
6335  *      @reg: SCR to write
6336  *      @val: value to write
6337  *
6338  *      Write @val to SCR register @reg of @link.  This function is
6339  *      guaranteed to succeed if @link is ap->link, the cable type of
6340  *      the port is SATA and the port implements ->scr_read.
6341  *
6342  *      LOCKING:
6343  *      None if @link is ap->link.  Kernel thread context otherwise.
6344  *
6345  *      RETURNS:
6346  *      0 on success, negative errno on failure.
6347  */
6348 int sata_scr_write(struct ata_link *link, int reg, u32 val)
6349 {
6350         if (ata_is_host_link(link)) {
6351                 struct ata_port *ap = link->ap;
6352
6353                 if (sata_scr_valid(link))
6354                         return ap->ops->scr_write(ap, reg, val);
6355                 return -EOPNOTSUPP;
6356         }
6357
6358         return sata_pmp_scr_write(link, reg, val);
6359 }
6360
6361 /**
6362  *      sata_scr_write_flush - write SCR register of the specified port and flush
6363  *      @link: ATA link to write SCR for
6364  *      @reg: SCR to write
6365  *      @val: value to write
6366  *
6367  *      This function is identical to sata_scr_write() except that this
6368  *      function performs flush after writing to the register.
6369  *
6370  *      LOCKING:
6371  *      None if @link is ap->link.  Kernel thread context otherwise.
6372  *
6373  *      RETURNS:
6374  *      0 on success, negative errno on failure.
6375  */
6376 int sata_scr_write_flush(struct ata_link *link, int reg, u32 val)
6377 {
6378         if (ata_is_host_link(link)) {
6379                 struct ata_port *ap = link->ap;
6380                 int rc;
6381
6382                 if (sata_scr_valid(link)) {
6383                         rc = ap->ops->scr_write(ap, reg, val);
6384                         if (rc == 0)
6385                                 rc = ap->ops->scr_read(ap, reg, &val);
6386                         return rc;
6387                 }
6388                 return -EOPNOTSUPP;
6389         }
6390
6391         return sata_pmp_scr_write(link, reg, val);
6392 }
6393
6394 /**
6395  *      ata_link_online - test whether the given link is online
6396  *      @link: ATA link to test
6397  *
6398  *      Test whether @link is online.  Note that this function returns
6399  *      0 if online status of @link cannot be obtained, so
6400  *      ata_link_online(link) != !ata_link_offline(link).
6401  *
6402  *      LOCKING:
6403  *      None.
6404  *
6405  *      RETURNS:
6406  *      1 if the port online status is available and online.
6407  */
6408 int ata_link_online(struct ata_link *link)
6409 {
6410         u32 sstatus;
6411
6412         if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
6413             (sstatus & 0xf) == 0x3)
6414                 return 1;
6415         return 0;
6416 }
6417
6418 /**
6419  *      ata_link_offline - test whether the given link is offline
6420  *      @link: ATA link to test
6421  *
6422  *      Test whether @link is offline.  Note that this function
6423  *      returns 0 if offline status of @link cannot be obtained, so
6424  *      ata_link_online(link) != !ata_link_offline(link).
6425  *
6426  *      LOCKING:
6427  *      None.
6428  *
6429  *      RETURNS:
6430  *      1 if the port offline status is available and offline.
6431  */
6432 int ata_link_offline(struct ata_link *link)
6433 {
6434         u32 sstatus;
6435
6436         if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
6437             (sstatus & 0xf) != 0x3)
6438                 return 1;
6439         return 0;
6440 }
6441
6442 int ata_flush_cache(struct ata_device *dev)
6443 {
6444         unsigned int err_mask;
6445         u8 cmd;
6446
6447         if (!ata_try_flush_cache(dev))
6448                 return 0;
6449
6450         if (dev->flags & ATA_DFLAG_FLUSH_EXT)
6451                 cmd = ATA_CMD_FLUSH_EXT;
6452         else
6453                 cmd = ATA_CMD_FLUSH;
6454
6455         /* This is wrong. On a failed flush we get back the LBA of the lost
6456            sector and we should (assuming it wasn't aborted as unknown) issue
6457            a further flush command to continue the writeback until it
6458            does not error */
6459         err_mask = ata_do_simple_cmd(dev, cmd);
6460         if (err_mask) {
6461                 ata_dev_printk(dev, KERN_ERR, "failed to flush cache\n");
6462                 return -EIO;
6463         }
6464
6465         return 0;
6466 }
6467
6468 #ifdef CONFIG_PM
6469 static int ata_host_request_pm(struct ata_host *host, pm_message_t mesg,
6470                                unsigned int action, unsigned int ehi_flags,
6471                                int wait)
6472 {
6473         unsigned long flags;
6474         int i, rc;
6475
6476         for (i = 0; i < host->n_ports; i++) {
6477                 struct ata_port *ap = host->ports[i];
6478                 struct ata_link *link;
6479
6480                 /* Previous resume operation might still be in
6481                  * progress.  Wait for PM_PENDING to clear.
6482                  */
6483                 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
6484                         ata_port_wait_eh(ap);
6485                         WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
6486                 }
6487
6488                 /* request PM ops to EH */
6489                 spin_lock_irqsave(ap->lock, flags);
6490
6491                 ap->pm_mesg = mesg;
6492                 if (wait) {
6493                         rc = 0;
6494                         ap->pm_result = &rc;
6495                 }
6496
6497                 ap->pflags |= ATA_PFLAG_PM_PENDING;
6498                 __ata_port_for_each_link(link, ap) {
6499                         link->eh_info.action |= action;
6500                         link->eh_info.flags |= ehi_flags;
6501                 }
6502
6503                 ata_port_schedule_eh(ap);
6504
6505                 spin_unlock_irqrestore(ap->lock, flags);
6506
6507                 /* wait and check result */
6508                 if (wait) {
6509                         ata_port_wait_eh(ap);
6510                         WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
6511                         if (rc)
6512                                 return rc;
6513                 }
6514         }
6515
6516         return 0;
6517 }
6518
6519 /**
6520  *      ata_host_suspend - suspend host
6521  *      @host: host to suspend
6522  *      @mesg: PM message
6523  *
6524  *      Suspend @host.  Actual operation is performed by EH.  This
6525  *      function requests EH to perform PM operations and waits for EH
6526  *      to finish.
6527  *
6528  *      LOCKING:
6529  *      Kernel thread context (may sleep).
6530  *
6531  *      RETURNS:
6532  *      0 on success, -errno on failure.
6533  */
6534 int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
6535 {
6536         int rc;
6537
6538         /*
6539          * disable link pm on all ports before requesting
6540          * any pm activity
6541          */
6542         ata_lpm_enable(host);
6543
6544         rc = ata_host_request_pm(host, mesg, 0, ATA_EHI_QUIET, 1);
6545         if (rc == 0)
6546                 host->dev->power.power_state = mesg;
6547         return rc;
6548 }
6549
6550 /**
6551  *      ata_host_resume - resume host
6552  *      @host: host to resume
6553  *
6554  *      Resume @host.  Actual operation is performed by EH.  This
6555  *      function requests EH to perform PM operations and returns.
6556  *      Note that all resume operations are performed parallely.
6557  *
6558  *      LOCKING:
6559  *      Kernel thread context (may sleep).
6560  */
6561 void ata_host_resume(struct ata_host *host)
6562 {
6563         ata_host_request_pm(host, PMSG_ON, ATA_EH_SOFTRESET,
6564                             ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET, 0);
6565         host->dev->power.power_state = PMSG_ON;
6566
6567         /* reenable link pm */
6568         ata_lpm_disable(host);
6569 }
6570 #endif
6571
6572 /**
6573  *      ata_port_start - Set port up for dma.
6574  *      @ap: Port to initialize
6575  *
6576  *      Called just after data structures for each port are
6577  *      initialized.  Allocates space for PRD table.
6578  *
6579  *      May be used as the port_start() entry in ata_port_operations.
6580  *
6581  *      LOCKING:
6582  *      Inherited from caller.
6583  */
6584 int ata_port_start(struct ata_port *ap)
6585 {
6586         struct device *dev = ap->dev;
6587         int rc;
6588
6589         ap->prd = dmam_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma,
6590                                       GFP_KERNEL);
6591         if (!ap->prd)
6592                 return -ENOMEM;
6593
6594         rc = ata_pad_alloc(ap, dev);
6595         if (rc)
6596                 return rc;
6597
6598         DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd,
6599                 (unsigned long long)ap->prd_dma);
6600         return 0;
6601 }
6602
6603 /**
6604  *      ata_dev_init - Initialize an ata_device structure
6605  *      @dev: Device structure to initialize
6606  *
6607  *      Initialize @dev in preparation for probing.
6608  *
6609  *      LOCKING:
6610  *      Inherited from caller.
6611  */
6612 void ata_dev_init(struct ata_device *dev)
6613 {
6614         struct ata_link *link = dev->link;
6615         struct ata_port *ap = link->ap;
6616         unsigned long flags;
6617
6618         /* SATA spd limit is bound to the first device */
6619         link->sata_spd_limit = link->hw_sata_spd_limit;
6620         link->sata_spd = 0;
6621
6622         /* High bits of dev->flags are used to record warm plug
6623          * requests which occur asynchronously.  Synchronize using
6624          * host lock.
6625          */
6626         spin_lock_irqsave(ap->lock, flags);
6627         dev->flags &= ~ATA_DFLAG_INIT_MASK;
6628         dev->horkage = 0;
6629         spin_unlock_irqrestore(ap->lock, flags);
6630
6631         memset((void *)dev + ATA_DEVICE_CLEAR_OFFSET, 0,
6632                sizeof(*dev) - ATA_DEVICE_CLEAR_OFFSET);
6633         dev->pio_mask = UINT_MAX;
6634         dev->mwdma_mask = UINT_MAX;
6635         dev->udma_mask = UINT_MAX;
6636 }
6637
6638 /**
6639  *      ata_link_init - Initialize an ata_link structure
6640  *      @ap: ATA port link is attached to
6641  *      @link: Link structure to initialize
6642  *      @pmp: Port multiplier port number
6643  *
6644  *      Initialize @link.
6645  *
6646  *      LOCKING:
6647  *      Kernel thread context (may sleep)
6648  */
6649 void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
6650 {
6651         int i;
6652
6653         /* clear everything except for devices */
6654         memset(link, 0, offsetof(struct ata_link, device[0]));
6655
6656         link->ap = ap;
6657         link->pmp = pmp;
6658         link->active_tag = ATA_TAG_POISON;
6659         link->hw_sata_spd_limit = UINT_MAX;
6660
6661         /* can't use iterator, ap isn't initialized yet */
6662         for (i = 0; i < ATA_MAX_DEVICES; i++) {
6663                 struct ata_device *dev = &link->device[i];
6664
6665                 dev->link = link;
6666                 dev->devno = dev - link->device;
6667                 ata_dev_init(dev);
6668         }
6669 }
6670
6671 /**
6672  *      sata_link_init_spd - Initialize link->sata_spd_limit
6673  *      @link: Link to configure sata_spd_limit for
6674  *
6675  *      Initialize @link->[hw_]sata_spd_limit to the currently
6676  *      configured value.
6677  *
6678  *      LOCKING:
6679  *      Kernel thread context (may sleep).
6680  *
6681  *      RETURNS:
6682  *      0 on success, -errno on failure.
6683  */
6684 int sata_link_init_spd(struct ata_link *link)
6685 {
6686         u32 scontrol, spd;
6687         int rc;
6688
6689         rc = sata_scr_read(link, SCR_CONTROL, &scontrol);
6690         if (rc)
6691                 return rc;
6692
6693         spd = (scontrol >> 4) & 0xf;
6694         if (spd)
6695                 link->hw_sata_spd_limit &= (1 << spd) - 1;
6696
6697         link->sata_spd_limit = link->hw_sata_spd_limit;
6698
6699         return 0;
6700 }
6701
6702 /**
6703  *      ata_port_alloc - allocate and initialize basic ATA port resources
6704  *      @host: ATA host this allocated port belongs to
6705  *
6706  *      Allocate and initialize basic ATA port resources.
6707  *
6708  *      RETURNS:
6709  *      Allocate ATA port on success, NULL on failure.
6710  *
6711  *      LOCKING:
6712  *      Inherited from calling layer (may sleep).
6713  */
6714 struct ata_port *ata_port_alloc(struct ata_host *host)
6715 {
6716         struct ata_port *ap;
6717
6718         DPRINTK("ENTER\n");
6719
6720         ap = kzalloc(sizeof(*ap), GFP_KERNEL);
6721         if (!ap)
6722                 return NULL;
6723
6724         ap->pflags |= ATA_PFLAG_INITIALIZING;
6725         ap->lock = &host->lock;
6726         ap->flags = ATA_FLAG_DISABLED;
6727         ap->print_id = -1;
6728         ap->ctl = ATA_DEVCTL_OBS;
6729         ap->host = host;
6730         ap->dev = host->dev;
6731         ap->last_ctl = 0xFF;
6732
6733 #if defined(ATA_VERBOSE_DEBUG)
6734         /* turn on all debugging levels */
6735         ap->msg_enable = 0x00FF;
6736 #elif defined(ATA_DEBUG)
6737         ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
6738 #else
6739         ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
6740 #endif
6741
6742         INIT_DELAYED_WORK(&ap->port_task, NULL);
6743         INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
6744         INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
6745         INIT_LIST_HEAD(&ap->eh_done_q);
6746         init_waitqueue_head(&ap->eh_wait_q);
6747         init_timer_deferrable(&ap->fastdrain_timer);
6748         ap->fastdrain_timer.function = ata_eh_fastdrain_timerfn;
6749         ap->fastdrain_timer.data = (unsigned long)ap;
6750
6751         ap->cbl = ATA_CBL_NONE;
6752
6753         ata_link_init(ap, &ap->link, 0);
6754
6755 #ifdef ATA_IRQ_TRAP
6756         ap->stats.unhandled_irq = 1;
6757         ap->stats.idle_irq = 1;
6758 #endif
6759         return ap;
6760 }
6761
6762 static void ata_host_release(struct device *gendev, void *res)
6763 {
6764         struct ata_host *host = dev_get_drvdata(gendev);
6765         int i;
6766
6767         for (i = 0; i < host->n_ports; i++) {
6768                 struct ata_port *ap = host->ports[i];
6769
6770                 if (!ap)
6771                         continue;
6772
6773                 if (ap->scsi_host)
6774                         scsi_host_put(ap->scsi_host);
6775
6776                 kfree(ap->pmp_link);
6777                 kfree(ap);
6778                 host->ports[i] = NULL;
6779         }
6780
6781         dev_set_drvdata(gendev, NULL);
6782 }
6783
6784 /**
6785  *      ata_host_alloc - allocate and init basic ATA host resources
6786  *      @dev: generic device this host is associated with
6787  *      @max_ports: maximum number of ATA ports associated with this host
6788  *
6789  *      Allocate and initialize basic ATA host resources.  LLD calls
6790  *      this function to allocate a host, initializes it fully and
6791  *      attaches it using ata_host_register().
6792  *
6793  *      @max_ports ports are allocated and host->n_ports is
6794  *      initialized to @max_ports.  The caller is allowed to decrease
6795  *      host->n_ports before calling ata_host_register().  The unused
6796  *      ports will be automatically freed on registration.
6797  *
6798  *      RETURNS:
6799  *      Allocate ATA host on success, NULL on failure.
6800  *
6801  *      LOCKING:
6802  *      Inherited from calling layer (may sleep).
6803  */
6804 struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
6805 {
6806         struct ata_host *host;
6807         size_t sz;
6808         int i;
6809
6810         DPRINTK("ENTER\n");
6811
6812         if (!devres_open_group(dev, NULL, GFP_KERNEL))
6813                 return NULL;
6814
6815         /* alloc a container for our list of ATA ports (buses) */
6816         sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *);
6817         /* alloc a container for our list of ATA ports (buses) */
6818         host = devres_alloc(ata_host_release, sz, GFP_KERNEL);
6819         if (!host)
6820                 goto err_out;
6821
6822         devres_add(dev, host);
6823         dev_set_drvdata(dev, host);
6824
6825         spin_lock_init(&host->lock);
6826         host->dev = dev;
6827         host->n_ports = max_ports;
6828
6829         /* allocate ports bound to this host */
6830         for (i = 0; i < max_ports; i++) {
6831                 struct ata_port *ap;
6832
6833                 ap = ata_port_alloc(host);
6834                 if (!ap)
6835                         goto err_out;
6836
6837                 ap->port_no = i;
6838                 host->ports[i] = ap;
6839         }
6840
6841         devres_remove_group(dev, NULL);
6842         return host;
6843
6844  err_out:
6845         devres_release_group(dev, NULL);
6846         return NULL;
6847 }
6848
6849 /**
6850  *      ata_host_alloc_pinfo - alloc host and init with port_info array
6851  *      @dev: generic device this host is associated with
6852  *      @ppi: array of ATA port_info to initialize host with
6853  *      @n_ports: number of ATA ports attached to this host
6854  *
6855  *      Allocate ATA host and initialize with info from @ppi.  If NULL
6856  *      terminated, @ppi may contain fewer entries than @n_ports.  The
6857  *      last entry will be used for the remaining ports.
6858  *
6859  *      RETURNS:
6860  *      Allocate ATA host on success, NULL on failure.
6861  *
6862  *      LOCKING:
6863  *      Inherited from calling layer (may sleep).
6864  */
6865 struct ata_host *ata_host_alloc_pinfo(struct device *dev,
6866                                       const struct ata_port_info * const * ppi,
6867                                       int n_ports)
6868 {
6869         const struct ata_port_info *pi;
6870         struct ata_host *host;
6871         int i, j;
6872
6873         host = ata_host_alloc(dev, n_ports);
6874         if (!host)
6875                 return NULL;
6876
6877         for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) {
6878                 struct ata_port *ap = host->ports[i];
6879
6880                 if (ppi[j])
6881                         pi = ppi[j++];
6882
6883                 ap->pio_mask = pi->pio_mask;
6884                 ap->mwdma_mask = pi->mwdma_mask;
6885                 ap->udma_mask = pi->udma_mask;
6886                 ap->flags |= pi->flags;
6887                 ap->link.flags |= pi->link_flags;
6888                 ap->ops = pi->port_ops;
6889
6890                 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
6891                         host->ops = pi->port_ops;
6892                 if (!host->private_data && pi->private_data)
6893                         host->private_data = pi->private_data;
6894         }
6895
6896         return host;
6897 }
6898
6899 static void ata_host_stop(struct device *gendev, void *res)
6900 {
6901         struct ata_host *host = dev_get_drvdata(gendev);
6902         int i;
6903
6904         WARN_ON(!(host->flags & ATA_HOST_STARTED));
6905
6906         for (i = 0; i < host->n_ports; i++) {
6907                 struct ata_port *ap = host->ports[i];
6908
6909                 if (ap->ops->port_stop)
6910                         ap->ops->port_stop(ap);
6911         }
6912
6913         if (host->ops->host_stop)
6914                 host->ops->host_stop(host);
6915 }
6916
6917 /**
6918  *      ata_host_start - start and freeze ports of an ATA host
6919  *      @host: ATA host to start ports for
6920  *
6921  *      Start and then freeze ports of @host.  Started status is
6922  *      recorded in host->flags, so this function can be called
6923  *      multiple times.  Ports are guaranteed to get started only
6924  *      once.  If host->ops isn't initialized yet, its set to the
6925  *      first non-dummy port ops.
6926  *
6927  *      LOCKING:
6928  *      Inherited from calling layer (may sleep).
6929  *
6930  *      RETURNS:
6931  *      0 if all ports are started successfully, -errno otherwise.
6932  */
6933 int ata_host_start(struct ata_host *host)
6934 {
6935         int have_stop = 0;
6936         void *start_dr = NULL;
6937         int i, rc;
6938
6939         if (host->flags & ATA_HOST_STARTED)
6940                 return 0;
6941
6942         for (i = 0; i < host->n_ports; i++) {
6943                 struct ata_port *ap = host->ports[i];
6944
6945                 if (!host->ops && !ata_port_is_dummy(ap))
6946                         host->ops = ap->ops;
6947
6948                 if (ap->ops->port_stop)
6949                         have_stop = 1;
6950         }
6951
6952         if (host->ops->host_stop)
6953                 have_stop = 1;
6954
6955         if (have_stop) {
6956                 start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL);
6957                 if (!start_dr)
6958                         return -ENOMEM;
6959         }
6960
6961         for (i = 0; i < host->n_ports; i++) {
6962                 struct ata_port *ap = host->ports[i];
6963
6964                 if (ap->ops->port_start) {
6965                         rc = ap->ops->port_start(ap);
6966                         if (rc) {
6967                                 ata_port_printk(ap, KERN_ERR, "failed to "
6968                                                 "start port (errno=%d)\n", rc);
6969                                 goto err_out;
6970                         }
6971                 }
6972
6973                 ata_eh_freeze_port(ap);
6974         }
6975
6976         if (start_dr)
6977                 devres_add(host->dev, start_dr);
6978         host->flags |= ATA_HOST_STARTED;
6979         return 0;
6980
6981  err_out:
6982         while (--i >= 0) {
6983                 struct ata_port *ap = host->ports[i];
6984
6985                 if (ap->ops->port_stop)
6986                         ap->ops->port_stop(ap);
6987         }
6988         devres_free(start_dr);
6989         return rc;
6990 }
6991
6992 /**
6993  *      ata_sas_host_init - Initialize a host struct
6994  *      @host:  host to initialize
6995  *      @dev:   device host is attached to
6996  *      @flags: host flags
6997  *      @ops:   port_ops
6998  *
6999  *      LOCKING:
7000  *      PCI/etc. bus probe sem.
7001  *
7002  */
7003 /* KILLME - the only user left is ipr */
7004 void ata_host_init(struct ata_host *host, struct device *dev,
7005                    unsigned long flags, const struct ata_port_operations *ops)
7006 {
7007         spin_lock_init(&host->lock);
7008         host->dev = dev;
7009         host->flags = flags;
7010         host->ops = ops;
7011 }
7012
7013 /**
7014  *      ata_host_register - register initialized ATA host
7015  *      @host: ATA host to register
7016  *      @sht: template for SCSI host
7017  *
7018  *      Register initialized ATA host.  @host is allocated using
7019  *      ata_host_alloc() and fully initialized by LLD.  This function
7020  *      starts ports, registers @host with ATA and SCSI layers and
7021  *      probe registered devices.
7022  *
7023  *      LOCKING:
7024  *      Inherited from calling layer (may sleep).
7025  *
7026  *      RETURNS:
7027  *      0 on success, -errno otherwise.
7028  */
7029 int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
7030 {
7031         int i, rc;
7032
7033         /* host must have been started */
7034         if (!(host->flags & ATA_HOST_STARTED)) {
7035                 dev_printk(KERN_ERR, host->dev,
7036                            "BUG: trying to register unstarted host\n");
7037                 WARN_ON(1);
7038                 return -EINVAL;
7039         }
7040
7041         /* Blow away unused ports.  This happens when LLD can't
7042          * determine the exact number of ports to allocate at
7043          * allocation time.
7044          */
7045         for (i = host->n_ports; host->ports[i]; i++)
7046                 kfree(host->ports[i]);
7047
7048         /* give ports names and add SCSI hosts */
7049         for (i = 0; i < host->n_ports; i++)
7050                 host->ports[i]->print_id = ata_print_id++;
7051
7052         rc = ata_scsi_add_hosts(host, sht);
7053         if (rc)
7054                 return rc;
7055
7056         /* associate with ACPI nodes */
7057         ata_acpi_associate(host);
7058
7059         /* set cable, sata_spd_limit and report */
7060         for (i = 0; i < host->n_ports; i++) {
7061                 struct ata_port *ap = host->ports[i];
7062                 unsigned long xfer_mask;
7063
7064                 /* set SATA cable type if still unset */
7065                 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
7066                         ap->cbl = ATA_CBL_SATA;
7067
7068                 /* init sata_spd_limit to the current value */
7069                 sata_link_init_spd(&ap->link);
7070
7071                 /* print per-port info to dmesg */
7072                 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
7073                                               ap->udma_mask);
7074
7075                 if (!ata_port_is_dummy(ap)) {
7076                         ata_port_printk(ap, KERN_INFO,
7077                                         "%cATA max %s %s\n",
7078                                         (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
7079                                         ata_mode_string(xfer_mask),
7080                                         ap->link.eh_info.desc);
7081                         ata_ehi_clear_desc(&ap->link.eh_info);
7082                 } else
7083                         ata_port_printk(ap, KERN_INFO, "DUMMY\n");
7084         }
7085
7086         /* perform each probe synchronously */
7087         DPRINTK("probe begin\n");
7088         for (i = 0; i < host->n_ports; i++) {
7089                 struct ata_port *ap = host->ports[i];
7090                 int rc;
7091
7092                 /* probe */
7093                 if (ap->ops->error_handler) {
7094                         struct ata_eh_info *ehi = &ap->link.eh_info;
7095                         unsigned long flags;
7096
7097                         ata_port_probe(ap);
7098
7099                         /* kick EH for boot probing */
7100                         spin_lock_irqsave(ap->lock, flags);
7101
7102                         ehi->probe_mask =
7103                                 (1 << ata_link_max_devices(&ap->link)) - 1;
7104                         ehi->action |= ATA_EH_SOFTRESET;
7105                         ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
7106
7107                         ap->pflags &= ~ATA_PFLAG_INITIALIZING;
7108                         ap->pflags |= ATA_PFLAG_LOADING;
7109                         ata_port_schedule_eh(ap);
7110
7111                         spin_unlock_irqrestore(ap->lock, flags);
7112
7113                         /* wait for EH to finish */
7114                         ata_port_wait_eh(ap);
7115                 } else {
7116                         DPRINTK("ata%u: bus probe begin\n", ap->print_id);
7117                         rc = ata_bus_probe(ap);
7118                         DPRINTK("ata%u: bus probe end\n", ap->print_id);
7119
7120                         if (rc) {
7121                                 /* FIXME: do something useful here?
7122                                  * Current libata behavior will
7123                                  * tear down everything when
7124                                  * the module is removed
7125                                  * or the h/w is unplugged.
7126                                  */
7127                         }
7128                 }
7129         }
7130
7131         /* probes are done, now scan each port's disk(s) */
7132         DPRINTK("host probe begin\n");
7133         for (i = 0; i < host->n_ports; i++) {
7134                 struct ata_port *ap = host->ports[i];
7135
7136                 ata_scsi_scan_host(ap, 1);
7137                 ata_lpm_schedule(ap, ap->pm_policy);
7138         }
7139
7140         return 0;
7141 }
7142
7143 /**
7144  *      ata_host_activate - start host, request IRQ and register it
7145  *      @host: target ATA host
7146  *      @irq: IRQ to request
7147  *      @irq_handler: irq_handler used when requesting IRQ
7148  *      @irq_flags: irq_flags used when requesting IRQ
7149  *      @sht: scsi_host_template to use when registering the host
7150  *
7151  *      After allocating an ATA host and initializing it, most libata
7152  *      LLDs perform three steps to activate the host - start host,
7153  *      request IRQ and register it.  This helper takes necessasry
7154  *      arguments and performs the three steps in one go.
7155  *
7156  *      An invalid IRQ skips the IRQ registration and expects the host to
7157  *      have set polling mode on the port. In this case, @irq_handler
7158  *      should be NULL.
7159  *
7160  *      LOCKING:
7161  *      Inherited from calling layer (may sleep).
7162  *
7163  *      RETURNS:
7164  *      0 on success, -errno otherwise.
7165  */
7166 int ata_host_activate(struct ata_host *host, int irq,
7167                       irq_handler_t irq_handler, unsigned long irq_flags,
7168                       struct scsi_host_template *sht)
7169 {
7170         int i, rc;
7171
7172         rc = ata_host_start(host);
7173         if (rc)
7174                 return rc;
7175
7176         /* Special case for polling mode */
7177         if (!irq) {
7178                 WARN_ON(irq_handler);
7179                 return ata_host_register(host, sht);
7180         }
7181
7182         rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags,
7183                               dev_driver_string(host->dev), host);
7184         if (rc)
7185                 return rc;
7186
7187         for (i = 0; i < host->n_ports; i++)
7188                 ata_port_desc(host->ports[i], "irq %d", irq);
7189
7190         rc = ata_host_register(host, sht);
7191         /* if failed, just free the IRQ and leave ports alone */
7192         if (rc)
7193                 devm_free_irq(host->dev, irq, host);
7194
7195         return rc;
7196 }
7197
7198 /**
7199  *      ata_port_detach - Detach ATA port in prepration of device removal
7200  *      @ap: ATA port to be detached
7201  *
7202  *      Detach all ATA devices and the associated SCSI devices of @ap;
7203  *      then, remove the associated SCSI host.  @ap is guaranteed to
7204  *      be quiescent on return from this function.
7205  *
7206  *      LOCKING:
7207  *      Kernel thread context (may sleep).
7208  */
7209 static void ata_port_detach(struct ata_port *ap)
7210 {
7211         unsigned long flags;
7212         struct ata_link *link;
7213         struct ata_device *dev;
7214
7215         if (!ap->ops->error_handler)
7216                 goto skip_eh;
7217
7218         /* tell EH we're leaving & flush EH */
7219         spin_lock_irqsave(ap->lock, flags);
7220         ap->pflags |= ATA_PFLAG_UNLOADING;
7221         spin_unlock_irqrestore(ap->lock, flags);
7222
7223         ata_port_wait_eh(ap);
7224
7225         /* EH is now guaranteed to see UNLOADING, so no new device
7226          * will be attached.  Disable all existing devices.
7227          */
7228         spin_lock_irqsave(ap->lock, flags);
7229
7230         ata_port_for_each_link(link, ap) {
7231                 ata_link_for_each_dev(dev, link)
7232                         ata_dev_disable(dev);
7233         }
7234
7235         spin_unlock_irqrestore(ap->lock, flags);
7236
7237         /* Final freeze & EH.  All in-flight commands are aborted.  EH
7238          * will be skipped and retrials will be terminated with bad
7239          * target.
7240          */
7241         spin_lock_irqsave(ap->lock, flags);
7242         ata_port_freeze(ap);    /* won't be thawed */
7243         spin_unlock_irqrestore(ap->lock, flags);
7244
7245         ata_port_wait_eh(ap);
7246         cancel_rearming_delayed_work(&ap->hotplug_task);
7247
7248  skip_eh:
7249         /* remove the associated SCSI host */
7250         scsi_remove_host(ap->scsi_host);
7251 }
7252
7253 /**
7254  *      ata_host_detach - Detach all ports of an ATA host
7255  *      @host: Host to detach
7256  *
7257  *      Detach all ports of @host.
7258  *
7259  *      LOCKING:
7260  *      Kernel thread context (may sleep).
7261  */
7262 void ata_host_detach(struct ata_host *host)
7263 {
7264         int i;
7265
7266         for (i = 0; i < host->n_ports; i++)
7267                 ata_port_detach(host->ports[i]);
7268 }
7269
7270 /**
7271  *      ata_std_ports - initialize ioaddr with standard port offsets.
7272  *      @ioaddr: IO address structure to be initialized
7273  *
7274  *      Utility function which initializes data_addr, error_addr,
7275  *      feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
7276  *      device_addr, status_addr, and command_addr to standard offsets
7277  *      relative to cmd_addr.
7278  *
7279  *      Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
7280  */
7281
7282 void ata_std_ports(struct ata_ioports *ioaddr)
7283 {
7284         ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
7285         ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
7286         ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
7287         ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
7288         ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
7289         ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
7290         ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
7291         ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
7292         ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
7293         ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
7294 }
7295
7296
7297 #ifdef CONFIG_PCI
7298
7299 /**
7300  *      ata_pci_remove_one - PCI layer callback for device removal
7301  *      @pdev: PCI device that was removed
7302  *
7303  *      PCI layer indicates to libata via this hook that hot-unplug or
7304  *      module unload event has occurred.  Detach all ports.  Resource
7305  *      release is handled via devres.
7306  *
7307  *      LOCKING:
7308  *      Inherited from PCI layer (may sleep).
7309  */
7310 void ata_pci_remove_one(struct pci_dev *pdev)
7311 {
7312         struct device *dev = &pdev->dev;
7313         struct ata_host *host = dev_get_drvdata(dev);
7314
7315         ata_host_detach(host);
7316 }
7317
7318 /* move to PCI subsystem */
7319 int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
7320 {
7321         unsigned long tmp = 0;
7322
7323         switch (bits->width) {
7324         case 1: {
7325                 u8 tmp8 = 0;
7326                 pci_read_config_byte(pdev, bits->reg, &tmp8);
7327                 tmp = tmp8;
7328                 break;
7329         }
7330         case 2: {
7331                 u16 tmp16 = 0;
7332                 pci_read_config_word(pdev, bits->reg, &tmp16);
7333                 tmp = tmp16;
7334                 break;
7335         }
7336         case 4: {
7337                 u32 tmp32 = 0;
7338                 pci_read_config_dword(pdev, bits->reg, &tmp32);
7339                 tmp = tmp32;
7340                 break;
7341         }
7342
7343         default:
7344                 return -EINVAL;
7345         }
7346
7347         tmp &= bits->mask;
7348
7349         return (tmp == bits->val) ? 1 : 0;
7350 }
7351
7352 #ifdef CONFIG_PM
7353 void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
7354 {
7355         pci_save_state(pdev);
7356         pci_disable_device(pdev);
7357
7358         if (mesg.event == PM_EVENT_SUSPEND)
7359                 pci_set_power_state(pdev, PCI_D3hot);
7360 }
7361
7362 int ata_pci_device_do_resume(struct pci_dev *pdev)
7363 {
7364         int rc;
7365
7366         pci_set_power_state(pdev, PCI_D0);
7367         pci_restore_state(pdev);
7368
7369         rc = pcim_enable_device(pdev);
7370         if (rc) {
7371                 dev_printk(KERN_ERR, &pdev->dev,
7372                            "failed to enable device after resume (%d)\n", rc);
7373                 return rc;
7374         }
7375
7376         pci_set_master(pdev);
7377         return 0;
7378 }
7379
7380 int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
7381 {
7382         struct ata_host *host = dev_get_drvdata(&pdev->dev);
7383         int rc = 0;
7384
7385         rc = ata_host_suspend(host, mesg);
7386         if (rc)
7387                 return rc;
7388
7389         ata_pci_device_do_suspend(pdev, mesg);
7390
7391         return 0;
7392 }
7393
7394 int ata_pci_device_resume(struct pci_dev *pdev)
7395 {
7396         struct ata_host *host = dev_get_drvdata(&pdev->dev);
7397         int rc;
7398
7399         rc = ata_pci_device_do_resume(pdev);
7400         if (rc == 0)
7401                 ata_host_resume(host);
7402         return rc;
7403 }
7404 #endif /* CONFIG_PM */
7405
7406 #endif /* CONFIG_PCI */
7407
7408
7409 static int __init ata_init(void)
7410 {
7411         ata_probe_timeout *= HZ;
7412         ata_wq = create_workqueue("ata");
7413         if (!ata_wq)
7414                 return -ENOMEM;
7415
7416         ata_aux_wq = create_singlethread_workqueue("ata_aux");
7417         if (!ata_aux_wq) {
7418                 destroy_workqueue(ata_wq);
7419                 return -ENOMEM;
7420         }
7421
7422         printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
7423         return 0;
7424 }
7425
7426 static void __exit ata_exit(void)
7427 {
7428         destroy_workqueue(ata_wq);
7429         destroy_workqueue(ata_aux_wq);
7430 }
7431
7432 subsys_initcall(ata_init);
7433 module_exit(ata_exit);
7434
7435 static unsigned long ratelimit_time;
7436 static DEFINE_SPINLOCK(ata_ratelimit_lock);
7437
7438 int ata_ratelimit(void)
7439 {
7440         int rc;
7441         unsigned long flags;
7442
7443         spin_lock_irqsave(&ata_ratelimit_lock, flags);
7444
7445         if (time_after(jiffies, ratelimit_time)) {
7446                 rc = 1;
7447                 ratelimit_time = jiffies + (HZ/5);
7448         } else
7449                 rc = 0;
7450
7451         spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
7452
7453         return rc;
7454 }
7455
7456 /**
7457  *      ata_wait_register - wait until register value changes
7458  *      @reg: IO-mapped register
7459  *      @mask: Mask to apply to read register value
7460  *      @val: Wait condition
7461  *      @interval_msec: polling interval in milliseconds
7462  *      @timeout_msec: timeout in milliseconds
7463  *
7464  *      Waiting for some bits of register to change is a common
7465  *      operation for ATA controllers.  This function reads 32bit LE
7466  *      IO-mapped register @reg and tests for the following condition.
7467  *
7468  *      (*@reg & mask) != val
7469  *
7470  *      If the condition is met, it returns; otherwise, the process is
7471  *      repeated after @interval_msec until timeout.
7472  *
7473  *      LOCKING:
7474  *      Kernel thread context (may sleep)
7475  *
7476  *      RETURNS:
7477  *      The final register value.
7478  */
7479 u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
7480                       unsigned long interval_msec,
7481                       unsigned long timeout_msec)
7482 {
7483         unsigned long timeout;
7484         u32 tmp;
7485
7486         tmp = ioread32(reg);
7487
7488         /* Calculate timeout _after_ the first read to make sure
7489          * preceding writes reach the controller before starting to
7490          * eat away the timeout.
7491          */
7492         timeout = jiffies + (timeout_msec * HZ) / 1000;
7493
7494         while ((tmp & mask) == val && time_before(jiffies, timeout)) {
7495                 msleep(interval_msec);
7496                 tmp = ioread32(reg);
7497         }
7498
7499         return tmp;
7500 }
7501
7502 /*
7503  * Dummy port_ops
7504  */
7505 static void ata_dummy_noret(struct ata_port *ap)        { }
7506 static int ata_dummy_ret0(struct ata_port *ap)          { return 0; }
7507 static void ata_dummy_qc_noret(struct ata_queued_cmd *qc) { }
7508
7509 static u8 ata_dummy_check_status(struct ata_port *ap)
7510 {
7511         return ATA_DRDY;
7512 }
7513
7514 static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
7515 {
7516         return AC_ERR_SYSTEM;
7517 }
7518
7519 const struct ata_port_operations ata_dummy_port_ops = {
7520         .check_status           = ata_dummy_check_status,
7521         .check_altstatus        = ata_dummy_check_status,
7522         .dev_select             = ata_noop_dev_select,
7523         .qc_prep                = ata_noop_qc_prep,
7524         .qc_issue               = ata_dummy_qc_issue,
7525         .freeze                 = ata_dummy_noret,
7526         .thaw                   = ata_dummy_noret,
7527         .error_handler          = ata_dummy_noret,
7528         .post_internal_cmd      = ata_dummy_qc_noret,
7529         .irq_clear              = ata_dummy_noret,
7530         .port_start             = ata_dummy_ret0,
7531         .port_stop              = ata_dummy_noret,
7532 };
7533
7534 const struct ata_port_info ata_dummy_port_info = {
7535         .port_ops               = &ata_dummy_port_ops,
7536 };
7537
7538 /*
7539  * libata is essentially a library of internal helper functions for
7540  * low-level ATA host controller drivers.  As such, the API/ABI is
7541  * likely to change as new drivers are added and updated.
7542  * Do not depend on ABI/API stability.
7543  */
7544 EXPORT_SYMBOL_GPL(sata_deb_timing_normal);
7545 EXPORT_SYMBOL_GPL(sata_deb_timing_hotplug);
7546 EXPORT_SYMBOL_GPL(sata_deb_timing_long);
7547 EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
7548 EXPORT_SYMBOL_GPL(ata_dummy_port_info);
7549 EXPORT_SYMBOL_GPL(ata_std_bios_param);
7550 EXPORT_SYMBOL_GPL(ata_std_ports);
7551 EXPORT_SYMBOL_GPL(ata_host_init);
7552 EXPORT_SYMBOL_GPL(ata_host_alloc);
7553 EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
7554 EXPORT_SYMBOL_GPL(ata_host_start);
7555 EXPORT_SYMBOL_GPL(ata_host_register);
7556 EXPORT_SYMBOL_GPL(ata_host_activate);
7557 EXPORT_SYMBOL_GPL(ata_host_detach);
7558 EXPORT_SYMBOL_GPL(ata_sg_init);
7559 EXPORT_SYMBOL_GPL(ata_sg_init_one);
7560 EXPORT_SYMBOL_GPL(ata_hsm_move);
7561 EXPORT_SYMBOL_GPL(ata_qc_complete);
7562 EXPORT_SYMBOL_GPL(ata_qc_complete_multiple);
7563 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
7564 EXPORT_SYMBOL_GPL(ata_tf_load);
7565 EXPORT_SYMBOL_GPL(ata_tf_read);
7566 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
7567 EXPORT_SYMBOL_GPL(ata_std_dev_select);
7568 EXPORT_SYMBOL_GPL(sata_print_link_status);
7569 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
7570 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
7571 EXPORT_SYMBOL_GPL(ata_check_status);
7572 EXPORT_SYMBOL_GPL(ata_altstatus);
7573 EXPORT_SYMBOL_GPL(ata_exec_command);
7574 EXPORT_SYMBOL_GPL(ata_port_start);
7575 EXPORT_SYMBOL_GPL(ata_sff_port_start);
7576 EXPORT_SYMBOL_GPL(ata_interrupt);
7577 EXPORT_SYMBOL_GPL(ata_do_set_mode);
7578 EXPORT_SYMBOL_GPL(ata_data_xfer);
7579 EXPORT_SYMBOL_GPL(ata_data_xfer_noirq);
7580 EXPORT_SYMBOL_GPL(ata_std_qc_defer);
7581 EXPORT_SYMBOL_GPL(ata_qc_prep);
7582 EXPORT_SYMBOL_GPL(ata_dumb_qc_prep);
7583 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
7584 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
7585 EXPORT_SYMBOL_GPL(ata_bmdma_start);
7586 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
7587 EXPORT_SYMBOL_GPL(ata_bmdma_status);
7588 EXPORT_SYMBOL_GPL(ata_bmdma_stop);
7589 EXPORT_SYMBOL_GPL(ata_bmdma_freeze);
7590 EXPORT_SYMBOL_GPL(ata_bmdma_thaw);
7591 EXPORT_SYMBOL_GPL(ata_bmdma_drive_eh);
7592 EXPORT_SYMBOL_GPL(ata_bmdma_error_handler);
7593 EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
7594 EXPORT_SYMBOL_GPL(ata_port_probe);
7595 EXPORT_SYMBOL_GPL(ata_dev_disable);
7596 EXPORT_SYMBOL_GPL(sata_set_spd);
7597 EXPORT_SYMBOL_GPL(sata_link_debounce);
7598 EXPORT_SYMBOL_GPL(sata_link_resume);
7599 EXPORT_SYMBOL_GPL(ata_bus_reset);
7600 EXPORT_SYMBOL_GPL(ata_std_prereset);
7601 EXPORT_SYMBOL_GPL(ata_std_softreset);
7602 EXPORT_SYMBOL_GPL(sata_link_hardreset);
7603 EXPORT_SYMBOL_GPL(sata_std_hardreset);
7604 EXPORT_SYMBOL_GPL(ata_std_postreset);
7605 EXPORT_SYMBOL_GPL(ata_dev_classify);
7606 EXPORT_SYMBOL_GPL(ata_dev_pair);
7607 EXPORT_SYMBOL_GPL(ata_port_disable);
7608 EXPORT_SYMBOL_GPL(ata_ratelimit);
7609 EXPORT_SYMBOL_GPL(ata_wait_register);
7610 EXPORT_SYMBOL_GPL(ata_busy_sleep);
7611 EXPORT_SYMBOL_GPL(ata_wait_after_reset);
7612 EXPORT_SYMBOL_GPL(ata_wait_ready);
7613 EXPORT_SYMBOL_GPL(ata_port_queue_task);
7614 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
7615 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
7616 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
7617 EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
7618 EXPORT_SYMBOL_GPL(ata_scsi_change_queue_depth);
7619 EXPORT_SYMBOL_GPL(ata_host_intr);
7620 EXPORT_SYMBOL_GPL(sata_scr_valid);
7621 EXPORT_SYMBOL_GPL(sata_scr_read);
7622 EXPORT_SYMBOL_GPL(sata_scr_write);
7623 EXPORT_SYMBOL_GPL(sata_scr_write_flush);
7624 EXPORT_SYMBOL_GPL(ata_link_online);
7625 EXPORT_SYMBOL_GPL(ata_link_offline);
7626 #ifdef CONFIG_PM
7627 EXPORT_SYMBOL_GPL(ata_host_suspend);
7628 EXPORT_SYMBOL_GPL(ata_host_resume);
7629 #endif /* CONFIG_PM */
7630 EXPORT_SYMBOL_GPL(ata_id_string);
7631 EXPORT_SYMBOL_GPL(ata_id_c_string);
7632 EXPORT_SYMBOL_GPL(ata_id_to_dma_mode);
7633 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
7634
7635 EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
7636 EXPORT_SYMBOL_GPL(ata_timing_compute);
7637 EXPORT_SYMBOL_GPL(ata_timing_merge);
7638
7639 #ifdef CONFIG_PCI
7640 EXPORT_SYMBOL_GPL(pci_test_config_bits);
7641 EXPORT_SYMBOL_GPL(ata_pci_init_sff_host);
7642 EXPORT_SYMBOL_GPL(ata_pci_init_bmdma);
7643 EXPORT_SYMBOL_GPL(ata_pci_prepare_sff_host);
7644 EXPORT_SYMBOL_GPL(ata_pci_init_one);
7645 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
7646 #ifdef CONFIG_PM
7647 EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
7648 EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
7649 EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
7650 EXPORT_SYMBOL_GPL(ata_pci_device_resume);
7651 #endif /* CONFIG_PM */
7652 EXPORT_SYMBOL_GPL(ata_pci_default_filter);
7653 EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
7654 #endif /* CONFIG_PCI */
7655
7656 EXPORT_SYMBOL_GPL(sata_pmp_qc_defer_cmd_switch);
7657 EXPORT_SYMBOL_GPL(sata_pmp_std_prereset);
7658 EXPORT_SYMBOL_GPL(sata_pmp_std_hardreset);
7659 EXPORT_SYMBOL_GPL(sata_pmp_std_postreset);
7660 EXPORT_SYMBOL_GPL(sata_pmp_do_eh);
7661
7662 EXPORT_SYMBOL_GPL(__ata_ehi_push_desc);
7663 EXPORT_SYMBOL_GPL(ata_ehi_push_desc);
7664 EXPORT_SYMBOL_GPL(ata_ehi_clear_desc);
7665 EXPORT_SYMBOL_GPL(ata_port_desc);
7666 #ifdef CONFIG_PCI
7667 EXPORT_SYMBOL_GPL(ata_port_pbar_desc);
7668 #endif /* CONFIG_PCI */
7669 EXPORT_SYMBOL_GPL(ata_port_schedule_eh);
7670 EXPORT_SYMBOL_GPL(ata_link_abort);
7671 EXPORT_SYMBOL_GPL(ata_port_abort);
7672 EXPORT_SYMBOL_GPL(ata_port_freeze);
7673 EXPORT_SYMBOL_GPL(sata_async_notification);
7674 EXPORT_SYMBOL_GPL(ata_eh_freeze_port);
7675 EXPORT_SYMBOL_GPL(ata_eh_thaw_port);
7676 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
7677 EXPORT_SYMBOL_GPL(ata_eh_qc_retry);
7678 EXPORT_SYMBOL_GPL(ata_do_eh);
7679 EXPORT_SYMBOL_GPL(ata_irq_on);
7680 EXPORT_SYMBOL_GPL(ata_dev_try_classify);
7681
7682 EXPORT_SYMBOL_GPL(ata_cable_40wire);
7683 EXPORT_SYMBOL_GPL(ata_cable_80wire);
7684 EXPORT_SYMBOL_GPL(ata_cable_unknown);
7685 EXPORT_SYMBOL_GPL(ata_cable_sata);