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