drivers/scsi/libata-core.c

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