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