drivers/scsi/libata-scsi.c

   1 /*
   2    libata-scsi.c - helper library for ATA
   3
   4    Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   5    Copyright 2003-2004 Jeff Garzik
   6
   7    The contents of this file are subject to the Open
   8    Software License version 1.1 that can be found at
   9    http://www.opensource.org/licenses/osl-1.1.txt and is included herein
  10    by reference.
  11
  12    Alternatively, the contents of this file may be used under the terms
  13    of the GNU General Public License version 2 (the "GPL") as distributed
  14    in the kernel source COPYING file, in which case the provisions of
  15    the GPL are applicable instead of the above.  If you wish to allow
  16    the use of your version of this file only under the terms of the
  17    GPL and not to allow others to use your version of this file under
  18    the OSL, indicate your decision by deleting the provisions above and
  19    replace them with the notice and other provisions required by the GPL.
  20    If you do not delete the provisions above, a recipient may use your
  21    version of this file under either the OSL or the GPL.
  22
  23  */
  24
  25 #include <linux/kernel.h>
  26 #include <linux/blkdev.h>
  27 #include <linux/spinlock.h>
  28 #include <scsi/scsi.h>
  29 #include "scsi.h"
  30 #include <scsi/scsi_host.h>
  31 #include <linux/libata.h>
  32 #include <asm/uaccess.h>
  33
  34 #include "libata.h"
  35
  36 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, u8 *scsicmd);
  37 static struct ata_device *
  38 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
  39
  40
  41 /**
  42  *      ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
  43  *      @sdev: SCSI device for which BIOS geometry is to be determined
  44  *      @bdev: block device associated with @sdev
  45  *      @capacity: capacity of SCSI device
  46  *      @geom: location to which geometry will be output
  47  *
  48  *      Generic bios head/sector/cylinder calculator
  49  *      used by sd. Most BIOSes nowadays expect a XXX/255/16  (CHS)
  50  *      mapping. Some situations may arise where the disk is not
  51  *      bootable if this is not used.
  52  *
  53  *      LOCKING:
  54  *      Defined by the SCSI layer.  We don't really care.
  55  *
  56  *      RETURNS:
  57  *      Zero.
  58  */
  59 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
  60                        sector_t capacity, int geom[])
  61 {
  62         geom[0] = 255;
  63         geom[1] = 63;
  64         sector_div(capacity, 255*63);
  65         geom[2] = capacity;
  66
  67         return 0;
  68 }
  69
  70 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
  71 {
  72         struct ata_port *ap;
  73         struct ata_device *dev;
  74         int val = -EINVAL, rc = -EINVAL;
  75
  76         ap = (struct ata_port *) &scsidev->host->hostdata[0];
  77         if (!ap)
  78                 goto out;
  79
  80         dev = ata_scsi_find_dev(ap, scsidev);
  81         if (!dev) {
  82                 rc = -ENODEV;
  83                 goto out;
  84         }
  85
  86         switch (cmd) {
  87         case ATA_IOC_GET_IO32:
  88                 val = 0;
  89                 if (copy_to_user(arg, &val, 1))
  90                         return -EFAULT;
  91                 return 0;
  92
  93         case ATA_IOC_SET_IO32:
  94                 val = (unsigned long) arg;
  95                 if (val != 0)
  96                         return -EINVAL;
  97                 return 0;
  98
  99         default:
 100                 rc = -ENOTTY;
 101                 break;
 102         }
 103
 104 out:
 105         return rc;
 106 }
 107
 108 /**
 109  *      ata_scsi_qc_new - acquire new ata_queued_cmd reference
 110  *      @ap: ATA port to which the new command is attached
 111  *      @dev: ATA device to which the new command is attached
 112  *      @cmd: SCSI command that originated this ATA command
 113  *      @done: SCSI command completion function
 114  *
 115  *      Obtain a reference to an unused ata_queued_cmd structure,
 116  *      which is the basic libata structure representing a single
 117  *      ATA command sent to the hardware.
 118  *
 119  *      If a command was available, fill in the SCSI-specific
 120  *      portions of the structure with information on the
 121  *      current command.
 122  *
 123  *      LOCKING:
 124  *      spin_lock_irqsave(host_set lock)
 125  *
 126  *      RETURNS:
 127  *      Command allocated, or %NULL if none available.
 128  */
 129 struct ata_queued_cmd *ata_scsi_qc_new(struct ata_port *ap,
 130                                        struct ata_device *dev,
 131                                        struct scsi_cmnd *cmd,
 132                                        void (*done)(struct scsi_cmnd *))
 133 {
 134         struct ata_queued_cmd *qc;
 135
 136         qc = ata_qc_new_init(ap, dev);
 137         if (qc) {
 138                 qc->scsicmd = cmd;
 139                 qc->scsidone = done;
 140
 141                 if (cmd->use_sg) {
 142                         qc->sg = (struct scatterlist *) cmd->request_buffer;
 143                         qc->n_elem = cmd->use_sg;
 144                 } else {
 145                         qc->sg = &qc->sgent;
 146                         qc->n_elem = 1;
 147                 }
 148         } else {
 149                 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
 150                 done(cmd);
 151         }
 152
 153         return qc;
 154 }
 155
 156 /**
 157  *      ata_to_sense_error - convert ATA error to SCSI error
 158  *      @qc: Command that we are erroring out
 159  *      @drv_stat: value contained in ATA status register
 160  *
 161  *      Converts an ATA error into a SCSI error. While we are at it
 162  *      we decode and dump the ATA error for the user so that they
 163  *      have some idea what really happened at the non make-believe
 164  *      layer.
 165  *
 166  *      LOCKING:
 167  *      spin_lock_irqsave(host_set lock)
 168  */
 169
 170 void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
 171 {
 172         struct scsi_cmnd *cmd = qc->scsicmd;
 173         u8 err = 0;
 174         unsigned char *sb = cmd->sense_buffer;
 175         /* Based on the 3ware driver translation table */
 176         static unsigned char sense_table[][4] = {
 177                 /* BBD|ECC|ID|MAR */
 178                 {0xd1,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
 179                 /* BBD|ECC|ID */
 180                 {0xd0,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
 181                 /* ECC|MC|MARK */
 182                 {0x61,          HARDWARE_ERROR, 0x00, 0x00},    // Device fault                 Hardware error
 183                 /* ICRC|ABRT */         /* NB: ICRC & !ABRT is BBD */
 184                 {0x84,          ABORTED_COMMAND, 0x47, 0x00},   // Data CRC error               SCSI parity error
 185                 /* MC|ID|ABRT|TRK0|MARK */
 186                 {0x37,          NOT_READY, 0x04, 0x00},         // Unit offline                 Not ready
 187                 /* MCR|MARK */
 188                 {0x09,          NOT_READY, 0x04, 0x00},         // Unrecovered disk error       Not ready
 189                 /*  Bad address mark */
 190                 {0x01,          MEDIUM_ERROR, 0x13, 0x00},      // Address mark not found       Address mark not found for data field
 191                 /* TRK0 */
 192                 {0x02,          HARDWARE_ERROR, 0x00, 0x00},    // Track 0 not found              Hardware error
 193                 /* Abort & !ICRC */
 194                 {0x04,          ABORTED_COMMAND, 0x00, 0x00},   // Aborted command              Aborted command
 195                 /* Media change request */
 196                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change request   FIXME: faking offline
 197                 /* SRV */
 198                 {0x10,          ABORTED_COMMAND, 0x14, 0x00},   // ID not found                 Recorded entity not found
 199                 /* Media change */
 200                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change           FIXME: faking offline
 201                 /* ECC */
 202                 {0x40,          MEDIUM_ERROR, 0x11, 0x04},      // Uncorrectable ECC error      Unrecovered read error
 203                 /* BBD - block marked bad */
 204                 {0x80,          MEDIUM_ERROR, 0x11, 0x04},      // Block marked bad               Medium error, unrecovered read error
 205                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
 206         };
 207         static unsigned char stat_table[][4] = {
 208                 /* Must be first because BUSY means no other bits valid */
 209                 {0x80,          ABORTED_COMMAND, 0x47, 0x00},   // Busy, fake parity for now
 210                 {0x20,          HARDWARE_ERROR,  0x00, 0x00},   // Device fault
 211                 {0x08,          ABORTED_COMMAND, 0x47, 0x00},   // Timed out in xfer, fake parity for now
 212                 {0x04,          RECOVERED_ERROR, 0x11, 0x00},   // Recovered ECC error    Medium error, recovered
 213                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
 214         };
 215         int i = 0;
 216
 217         cmd->result = SAM_STAT_CHECK_CONDITION;
 218
 219         /*
 220          *      Is this an error we can process/parse
 221          */
 222
 223         if(drv_stat & ATA_ERR)
 224                 /* Read the err bits */
 225                 err = ata_chk_err(qc->ap);
 226
 227         /* Display the ATA level error info */
 228
 229         printk(KERN_WARNING "ata%u: status=0x%02x { ", qc->ap->id, drv_stat);
 230         if(drv_stat & 0x80)
 231         {
 232                 printk("Busy ");
 233                 err = 0;        /* Data is not valid in this case */
 234         }
 235         else {
 236                 if(drv_stat & 0x40)     printk("DriveReady ");
 237                 if(drv_stat & 0x20)     printk("DeviceFault ");
 238                 if(drv_stat & 0x10)     printk("SeekComplete ");
 239                 if(drv_stat & 0x08)     printk("DataRequest ");
 240                 if(drv_stat & 0x04)     printk("CorrectedError ");
 241                 if(drv_stat & 0x02)     printk("Index ");
 242                 if(drv_stat & 0x01)     printk("Error ");
 243         }
 244         printk("}\n");
 245
 246         if(err)
 247         {
 248                 printk(KERN_WARNING "ata%u: error=0x%02x { ", qc->ap->id, err);
 249                 if(err & 0x04)          printk("DriveStatusError ");
 250                 if(err & 0x80)
 251                 {
 252                         if(err & 0x04)
 253                                 printk("BadCRC ");
 254                         else
 255                                 printk("Sector ");
 256                 }
 257                 if(err & 0x40)          printk("UncorrectableError ");
 258                 if(err & 0x10)          printk("SectorIdNotFound ");
 259                 if(err & 0x02)          printk("TrackZeroNotFound ");
 260                 if(err & 0x01)          printk("AddrMarkNotFound ");
 261                 printk("}\n");
 262
 263                 /* Should we dump sector info here too ?? */
 264         }
 265
 266
 267         /* Look for err */
 268         while(sense_table[i][0] != 0xFF)
 269         {
 270                 /* Look for best matches first */
 271                 if((sense_table[i][0] & err) == sense_table[i][0])
 272                 {
 273                         sb[0] = 0x70;
 274                         sb[2] = sense_table[i][1];
 275                         sb[7] = 0x0a;
 276                         sb[12] = sense_table[i][2];
 277                         sb[13] = sense_table[i][3];
 278                         return;
 279                 }
 280                 i++;
 281         }
 282         /* No immediate match */
 283         if(err)
 284                 printk(KERN_DEBUG "ata%u: no sense translation for 0x%02x\n", qc->ap->id, err);
 285
 286         i = 0;
 287         /* Fall back to interpreting status bits */
 288         while(stat_table[i][0] != 0xFF)
 289         {
 290                 if(stat_table[i][0] & drv_stat)
 291                 {
 292                         sb[0] = 0x70;
 293                         sb[2] = stat_table[i][1];
 294                         sb[7] = 0x0a;
 295                         sb[12] = stat_table[i][2];
 296                         sb[13] = stat_table[i][3];
 297                         return;
 298                 }
 299                 i++;
 300         }
 301         /* No error ?? */
 302         printk(KERN_ERR "ata%u: called with no error (%02X)!\n", qc->ap->id, drv_stat);
 303         /* additional-sense-code[-qualifier] */
 304
 305         sb[0] = 0x70;
 306         sb[2] = MEDIUM_ERROR;
 307         sb[7] = 0x0A;
 308         if (cmd->sc_data_direction == SCSI_DATA_READ) {
 309                 sb[12] = 0x11; /* "unrecovered read error" */
 310                 sb[13] = 0x04;
 311         } else {
 312                 sb[12] = 0x0C; /* "write error -             */
 313                 sb[13] = 0x02; /*  auto-reallocation failed" */
 314         }
 315 }
 316
 317 /**
 318  *      ata_scsi_slave_config - Set SCSI device attributes
 319  *      @sdev: SCSI device to examine
 320  *
 321  *      This is called before we actually start reading
 322  *      and writing to the device, to configure certain
 323  *      SCSI mid-layer behaviors.
 324  *
 325  *      LOCKING:
 326  *      Defined by SCSI layer.  We don't really care.
 327  */
 328
 329 int ata_scsi_slave_config(struct scsi_device *sdev)
 330 {
 331         sdev->use_10_for_rw = 1;
 332         sdev->use_10_for_ms = 1;
 333
 334         blk_queue_max_phys_segments(sdev->request_queue, LIBATA_MAX_PRD);
 335
 336         if (sdev->id < ATA_MAX_DEVICES) {
 337                 struct ata_port *ap;
 338                 struct ata_device *dev;
 339
 340                 ap = (struct ata_port *) &sdev->host->hostdata[0];
 341                 dev = &ap->device[sdev->id];
 342
 343                 /* TODO: 1024 is an arbitrary number, not the
 344                  * hardware maximum.  This should be increased to
 345                  * 65534 when Jens Axboe's patch for dynamically
 346                  * determining max_sectors is merged.
 347                  */
 348                 if ((dev->flags & ATA_DFLAG_LBA48) &&
 349                     ((dev->flags & ATA_DFLAG_LOCK_SECTORS) == 0)) {
 350                         sdev->host->max_sectors = 2048;
 351                         blk_queue_max_sectors(sdev->request_queue, 2048);
 352                 }
 353         }
 354
 355         return 0;       /* scsi layer doesn't check return value, sigh */
 356 }
 357
 358 /**
 359  *      ata_scsi_error - SCSI layer error handler callback
 360  *      @host: SCSI host on which error occurred
 361  *
 362  *      Handles SCSI-layer-thrown error events.
 363  *
 364  *      LOCKING:
 365  *      Inherited from SCSI layer (none, can sleep)
 366  *
 367  *      RETURNS:
 368  *      Zero.
 369  */
 370
 371 int ata_scsi_error(struct Scsi_Host *host)
 372 {
 373         struct ata_port *ap;
 374
 375         DPRINTK("ENTER\n");
 376
 377         ap = (struct ata_port *) &host->hostdata[0];
 378         ap->ops->eng_timeout(ap);
 379
 380         /* TODO: this is per-command; when queueing is supported
 381          * this code will either change or move to a more
 382          * appropriate place
 383          */
 384         host->host_failed--;
 385
 386         DPRINTK("EXIT\n");
 387         return 0;
 388 }
 389
 390 /**
 391  *      ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
 392  *      @qc: Storage for translated ATA taskfile
 393  *      @scsicmd: SCSI command to translate (ignored)
 394  *
 395  *      Sets up an ATA taskfile to issue FLUSH CACHE or
 396  *      FLUSH CACHE EXT.
 397  *
 398  *      LOCKING:
 399  *      spin_lock_irqsave(host_set lock)
 400  *
 401  *      RETURNS:
 402  *      Zero on success, non-zero on error.
 403  */
 404
 405 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 406 {
 407         struct ata_taskfile *tf = &qc->tf;
 408
 409         tf->flags |= ATA_TFLAG_DEVICE;
 410         tf->protocol = ATA_PROT_NODATA;
 411
 412         if ((tf->flags & ATA_TFLAG_LBA48) &&
 413             (ata_id_has_flush_ext(qc->dev->id)))
 414                 tf->command = ATA_CMD_FLUSH_EXT;
 415         else
 416                 tf->command = ATA_CMD_FLUSH;
 417
 418         return 0;
 419 }
 420
 421 /**
 422  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
 423  *      @qc: Storage for translated ATA taskfile
 424  *      @scsicmd: SCSI command to translate
 425  *
 426  *      Converts SCSI VERIFY command to an ATA READ VERIFY command.
 427  *
 428  *      LOCKING:
 429  *      spin_lock_irqsave(host_set lock)
 430  *
 431  *      RETURNS:
 432  *      Zero on success, non-zero on error.
 433  */
 434
 435 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 436 {
 437         struct ata_taskfile *tf = &qc->tf;
 438         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
 439         u64 dev_sectors = qc->dev->n_sectors;
 440         u64 sect = 0;
 441         u32 n_sect = 0;
 442
 443         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 444         tf->protocol = ATA_PROT_NODATA;
 445         tf->device |= ATA_LBA;
 446
 447         if (scsicmd[0] == VERIFY) {
 448                 sect |= ((u64)scsicmd[2]) << 24;
 449                 sect |= ((u64)scsicmd[3]) << 16;
 450                 sect |= ((u64)scsicmd[4]) << 8;
 451                 sect |= ((u64)scsicmd[5]);
 452
 453                 n_sect |= ((u32)scsicmd[7]) << 8;
 454                 n_sect |= ((u32)scsicmd[8]);
 455         }
 456
 457         else if (scsicmd[0] == VERIFY_16) {
 458                 sect |= ((u64)scsicmd[2]) << 56;
 459                 sect |= ((u64)scsicmd[3]) << 48;
 460                 sect |= ((u64)scsicmd[4]) << 40;
 461                 sect |= ((u64)scsicmd[5]) << 32;
 462                 sect |= ((u64)scsicmd[6]) << 24;
 463                 sect |= ((u64)scsicmd[7]) << 16;
 464                 sect |= ((u64)scsicmd[8]) << 8;
 465                 sect |= ((u64)scsicmd[9]);
 466
 467                 n_sect |= ((u32)scsicmd[10]) << 24;
 468                 n_sect |= ((u32)scsicmd[11]) << 16;
 469                 n_sect |= ((u32)scsicmd[12]) << 8;
 470                 n_sect |= ((u32)scsicmd[13]);
 471         }
 472
 473         else
 474                 return 1;
 475
 476         if (!n_sect)
 477                 return 1;
 478         if (sect >= dev_sectors)
 479                 return 1;
 480         if ((sect + n_sect) > dev_sectors)
 481                 return 1;
 482         if (lba48) {
 483                 if (n_sect > (64 * 1024))
 484                         return 1;
 485         } else {
 486                 if (n_sect > 256)
 487                         return 1;
 488         }
 489
 490         if (lba48) {
 491                 tf->command = ATA_CMD_VERIFY_EXT;
 492
 493                 tf->hob_nsect = (n_sect >> 8) & 0xff;
 494
 495                 tf->hob_lbah = (sect >> 40) & 0xff;
 496                 tf->hob_lbam = (sect >> 32) & 0xff;
 497                 tf->hob_lbal = (sect >> 24) & 0xff;
 498         } else {
 499                 tf->command = ATA_CMD_VERIFY;
 500
 501                 tf->device |= (sect >> 24) & 0xf;
 502         }
 503
 504         tf->nsect = n_sect & 0xff;
 505
 506         tf->lbah = (sect >> 16) & 0xff;
 507         tf->lbam = (sect >> 8) & 0xff;
 508         tf->lbal = sect & 0xff;
 509
 510         return 0;
 511 }
 512
 513 /**
 514  *      ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
 515  *      @qc: Storage for translated ATA taskfile
 516  *      @scsicmd: SCSI command to translate
 517  *
 518  *      Converts any of six SCSI read/write commands into the
 519  *      ATA counterpart, including starting sector (LBA),
 520  *      sector count, and taking into account the device's LBA48
 521  *      support.
 522  *
 523  *      Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
 524  *      %WRITE_16 are currently supported.
 525  *
 526  *      LOCKING:
 527  *      spin_lock_irqsave(host_set lock)
 528  *
 529  *      RETURNS:
 530  *      Zero on success, non-zero on error.
 531  */
 532
 533 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 534 {
 535         struct ata_taskfile *tf = &qc->tf;
 536         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
 537
 538         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 539         tf->protocol = qc->dev->xfer_protocol;
 540         tf->device |= ATA_LBA;
 541
 542         if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
 543             scsicmd[0] == READ_16) {
 544                 tf->command = qc->dev->read_cmd;
 545         } else {
 546                 tf->command = qc->dev->write_cmd;
 547                 tf->flags |= ATA_TFLAG_WRITE;
 548         }
 549
 550         if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
 551                 if (lba48) {
 552                         tf->hob_nsect = scsicmd[7];
 553                         tf->hob_lbal = scsicmd[2];
 554
 555                         qc->nsect = ((unsigned int)scsicmd[7] << 8) |
 556                                         scsicmd[8];
 557                 } else {
 558                         /* if we don't support LBA48 addressing, the request
 559                          * -may- be too large. */
 560                         if ((scsicmd[2] & 0xf0) || scsicmd[7])
 561                                 return 1;
 562
 563                         /* stores LBA27:24 in lower 4 bits of device reg */
 564                         tf->device |= scsicmd[2];
 565
 566                         qc->nsect = scsicmd[8];
 567                 }
 568
 569                 tf->nsect = scsicmd[8];
 570                 tf->lbal = scsicmd[5];
 571                 tf->lbam = scsicmd[4];
 572                 tf->lbah = scsicmd[3];
 573
 574                 VPRINTK("ten-byte command\n");
 575                 return 0;
 576         }
 577
 578         if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
 579                 qc->nsect = tf->nsect = scsicmd[4];
 580                 tf->lbal = scsicmd[3];
 581                 tf->lbam = scsicmd[2];
 582                 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
 583
 584                 VPRINTK("six-byte command\n");
 585                 return 0;
 586         }
 587
 588         if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
 589                 /* rule out impossible LBAs and sector counts */
 590                 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
 591                         return 1;
 592
 593                 if (lba48) {
 594                         tf->hob_nsect = scsicmd[12];
 595                         tf->hob_lbal = scsicmd[6];
 596                         tf->hob_lbam = scsicmd[5];
 597                         tf->hob_lbah = scsicmd[4];
 598
 599                         qc->nsect = ((unsigned int)scsicmd[12] << 8) |
 600                                         scsicmd[13];
 601                 } else {
 602                         /* once again, filter out impossible non-zero values */
 603                         if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
 604                             (scsicmd[6] & 0xf0))
 605                                 return 1;
 606
 607                         /* stores LBA27:24 in lower 4 bits of device reg */
 608                         tf->device |= scsicmd[6];
 609
 610                         qc->nsect = scsicmd[13];
 611                 }
 612
 613                 tf->nsect = scsicmd[13];
 614                 tf->lbal = scsicmd[9];
 615                 tf->lbam = scsicmd[8];
 616                 tf->lbah = scsicmd[7];
 617
 618                 VPRINTK("sixteen-byte command\n");
 619                 return 0;
 620         }
 621
 622         DPRINTK("no-byte command\n");
 623         return 1;
 624 }
 625
 626 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
 627 {
 628         struct scsi_cmnd *cmd = qc->scsicmd;
 629
 630         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
 631                 ata_to_sense_error(qc, drv_stat);
 632         else
 633                 cmd->result = SAM_STAT_GOOD;
 634
 635         qc->scsidone(cmd);
 636
 637         return 0;
 638 }
 639
 640 /**
 641  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
 642  *      @ap: ATA port to which the command is addressed
 643  *      @dev: ATA device to which the command is addressed
 644  *      @cmd: SCSI command to execute
 645  *      @done: SCSI command completion function
 646  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
 647  *
 648  *      Our ->queuecommand() function has decided that the SCSI
 649  *      command issued can be directly translated into an ATA
 650  *      command, rather than handled internally.
 651  *
 652  *      This function sets up an ata_queued_cmd structure for the
 653  *      SCSI command, and sends that ata_queued_cmd to the hardware.
 654  *
 655  *      LOCKING:
 656  *      spin_lock_irqsave(host_set lock)
 657  */
 658
 659 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
 660                               struct scsi_cmnd *cmd,
 661                               void (*done)(struct scsi_cmnd *),
 662                               ata_xlat_func_t xlat_func)
 663 {
 664         struct ata_queued_cmd *qc;
 665         u8 *scsicmd = cmd->cmnd;
 666
 667         VPRINTK("ENTER\n");
 668
 669         qc = ata_scsi_qc_new(ap, dev, cmd, done);
 670         if (!qc)
 671                 return;
 672
 673         /* data is present; dma-map it */
 674         if (cmd->sc_data_direction == SCSI_DATA_READ ||
 675             cmd->sc_data_direction == SCSI_DATA_WRITE) {
 676                 if (unlikely(cmd->request_bufflen < 1)) {
 677                         printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
 678                                ap->id, dev->devno);
 679                         goto err_out;
 680                 }
 681
 682                 if (cmd->use_sg)
 683                         ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
 684                 else
 685                         ata_sg_init_one(qc, cmd->request_buffer,
 686                                         cmd->request_bufflen);
 687
 688                 qc->dma_dir = cmd->sc_data_direction;
 689         }
 690
 691         qc->complete_fn = ata_scsi_qc_complete;
 692
 693         if (xlat_func(qc, scsicmd))
 694                 goto err_out;
 695
 696         /* select device, send command to hardware */
 697         if (ata_qc_issue(qc))
 698                 goto err_out;
 699
 700         VPRINTK("EXIT\n");
 701         return;
 702
 703 err_out:
 704         ata_qc_free(qc);
 705         ata_bad_cdb(cmd, done);
 706         DPRINTK("EXIT - badcmd\n");
 707 }
 708
 709 /**
 710  *      ata_scsi_rbuf_get - Map response buffer.
 711  *      @cmd: SCSI command containing buffer to be mapped.
 712  *      @buf_out: Pointer to mapped area.
 713  *
 714  *      Maps buffer contained within SCSI command @cmd.
 715  *
 716  *      LOCKING:
 717  *      spin_lock_irqsave(host_set lock)
 718  *
 719  *      RETURNS:
 720  *      Length of response buffer.
 721  */
 722
 723 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
 724 {
 725         u8 *buf;
 726         unsigned int buflen;
 727
 728         if (cmd->use_sg) {
 729                 struct scatterlist *sg;
 730
 731                 sg = (struct scatterlist *) cmd->request_buffer;
 732                 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
 733                 buflen = sg->length;
 734         } else {
 735                 buf = cmd->request_buffer;
 736                 buflen = cmd->request_bufflen;
 737         }
 738
 739         *buf_out = buf;
 740         return buflen;
 741 }
 742
 743 /**
 744  *      ata_scsi_rbuf_put - Unmap response buffer.
 745  *      @cmd: SCSI command containing buffer to be unmapped.
 746  *      @buf: buffer to unmap
 747  *
 748  *      Unmaps response buffer contained within @cmd.
 749  *
 750  *      LOCKING:
 751  *      spin_lock_irqsave(host_set lock)
 752  */
 753
 754 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
 755 {
 756         if (cmd->use_sg) {
 757                 struct scatterlist *sg;
 758
 759                 sg = (struct scatterlist *) cmd->request_buffer;
 760                 kunmap_atomic(buf - sg->offset, KM_USER0);
 761         }
 762 }
 763
 764 /**
 765  *      ata_scsi_rbuf_fill - wrapper for SCSI command simulators
 766  *      @args: device IDENTIFY data / SCSI command of interest.
 767  *      @actor: Callback hook for desired SCSI command simulator
 768  *
 769  *      Takes care of the hard work of simulating a SCSI command...
 770  *      Mapping the response buffer, calling the command's handler,
 771  *      and handling the handler's return value.  This return value
 772  *      indicates whether the handler wishes the SCSI command to be
 773  *      completed successfully, or not.
 774  *
 775  *      LOCKING:
 776  *      spin_lock_irqsave(host_set lock)
 777  */
 778
 779 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
 780                         unsigned int (*actor) (struct ata_scsi_args *args,
 781                                            u8 *rbuf, unsigned int buflen))
 782 {
 783         u8 *rbuf;
 784         unsigned int buflen, rc;
 785         struct scsi_cmnd *cmd = args->cmd;
 786
 787         buflen = ata_scsi_rbuf_get(cmd, &rbuf);
 788         memset(rbuf, 0, buflen);
 789         rc = actor(args, rbuf, buflen);
 790         ata_scsi_rbuf_put(cmd, rbuf);
 791
 792         if (rc)
 793                 ata_bad_cdb(cmd, args->done);
 794         else {
 795                 cmd->result = SAM_STAT_GOOD;
 796                 args->done(cmd);
 797         }
 798 }
 799
 800 /**
 801  *      ata_scsiop_inq_std - Simulate INQUIRY command
 802  *      @args: device IDENTIFY data / SCSI command of interest.
 803  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 804  *      @buflen: Response buffer length.
 805  *
 806  *      Returns standard device identification data associated
 807  *      with non-EVPD INQUIRY command output.
 808  *
 809  *      LOCKING:
 810  *      spin_lock_irqsave(host_set lock)
 811  */
 812
 813 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
 814                                unsigned int buflen)
 815 {
 816         u8 hdr[] = {
 817                 TYPE_DISK,
 818                 0,
 819                 0x5,    /* claim SPC-3 version compatibility */
 820                 2,
 821                 95 - 4
 822         };
 823
 824         /* set scsi removeable (RMB) bit per ata bit */
 825         if (ata_id_removeable(args->id))
 826                 hdr[1] |= (1 << 7);
 827
 828         VPRINTK("ENTER\n");
 829
 830         memcpy(rbuf, hdr, sizeof(hdr));
 831
 832         if (buflen > 35) {
 833                 memcpy(&rbuf[8], "ATA     ", 8);
 834                 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
 835                 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
 836                 if (rbuf[32] == 0 || rbuf[32] == ' ')
 837                         memcpy(&rbuf[32], "n/a ", 4);
 838         }
 839
 840         if (buflen > 63) {
 841                 const u8 versions[] = {
 842                         0x60,   /* SAM-3 (no version claimed) */
 843
 844                         0x03,
 845                         0x20,   /* SBC-2 (no version claimed) */
 846
 847                         0x02,
 848                         0x60    /* SPC-3 (no version claimed) */
 849                 };
 850
 851                 memcpy(rbuf + 59, versions, sizeof(versions));
 852         }
 853
 854         return 0;
 855 }
 856
 857 /**
 858  *      ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
 859  *      @args: device IDENTIFY data / SCSI command of interest.
 860  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 861  *      @buflen: Response buffer length.
 862  *
 863  *      Returns list of inquiry EVPD pages available.
 864  *
 865  *      LOCKING:
 866  *      spin_lock_irqsave(host_set lock)
 867  */
 868
 869 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
 870                               unsigned int buflen)
 871 {
 872         const u8 pages[] = {
 873                 0x00,   /* page 0x00, this page */
 874                 0x80,   /* page 0x80, unit serial no page */
 875                 0x83    /* page 0x83, device ident page */
 876         };
 877         rbuf[3] = sizeof(pages);        /* number of supported EVPD pages */
 878
 879         if (buflen > 6)
 880                 memcpy(rbuf + 4, pages, sizeof(pages));
 881
 882         return 0;
 883 }
 884
 885 /**
 886  *      ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
 887  *      @args: device IDENTIFY data / SCSI command of interest.
 888  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 889  *      @buflen: Response buffer length.
 890  *
 891  *      Returns ATA device serial number.
 892  *
 893  *      LOCKING:
 894  *      spin_lock_irqsave(host_set lock)
 895  */
 896
 897 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
 898                               unsigned int buflen)
 899 {
 900         const u8 hdr[] = {
 901                 0,
 902                 0x80,                   /* this page code */
 903                 0,
 904                 ATA_SERNO_LEN,          /* page len */
 905         };
 906         memcpy(rbuf, hdr, sizeof(hdr));
 907
 908         if (buflen > (ATA_SERNO_LEN + 4 - 1))
 909                 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
 910                                   ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
 911
 912         return 0;
 913 }
 914
 915 static const char *inq_83_str = "Linux ATA-SCSI simulator";
 916
 917 /**
 918  *      ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
 919  *      @args: device IDENTIFY data / SCSI command of interest.
 920  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 921  *      @buflen: Response buffer length.
 922  *
 923  *      Returns device identification.  Currently hardcoded to
 924  *      return "Linux ATA-SCSI simulator".
 925  *
 926  *      LOCKING:
 927  *      spin_lock_irqsave(host_set lock)
 928  */
 929
 930 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
 931                               unsigned int buflen)
 932 {
 933         rbuf[1] = 0x83;                 /* this page code */
 934         rbuf[3] = 4 + strlen(inq_83_str);       /* page len */
 935
 936         /* our one and only identification descriptor (vendor-specific) */
 937         if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
 938                 rbuf[4 + 0] = 2;        /* code set: ASCII */
 939                 rbuf[4 + 3] = strlen(inq_83_str);
 940                 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
 941         }
 942
 943         return 0;
 944 }
 945
 946 /**
 947  *      ata_scsiop_noop -
 948  *      @args: device IDENTIFY data / SCSI command of interest.
 949  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 950  *      @buflen: Response buffer length.
 951  *
 952  *      No operation.  Simply returns success to caller, to indicate
 953  *      that the caller should successfully complete this SCSI command.
 954  *
 955  *      LOCKING:
 956  *      spin_lock_irqsave(host_set lock)
 957  */
 958
 959 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
 960                             unsigned int buflen)
 961 {
 962         VPRINTK("ENTER\n");
 963         return 0;
 964 }
 965
 966 /**
 967  *      ata_msense_push - Push data onto MODE SENSE data output buffer
 968  *      @ptr_io: (input/output) Location to store more output data
 969  *      @last: End of output data buffer
 970  *      @buf: Pointer to BLOB being added to output buffer
 971  *      @buflen: Length of BLOB
 972  *
 973  *      Store MODE SENSE data on an output buffer.
 974  *
 975  *      LOCKING:
 976  *      None.
 977  */
 978
 979 static void ata_msense_push(u8 **ptr_io, const u8 *last,
 980                             const u8 *buf, unsigned int buflen)
 981 {
 982         u8 *ptr = *ptr_io;
 983
 984         if ((ptr + buflen - 1) > last)
 985                 return;
 986
 987         memcpy(ptr, buf, buflen);
 988
 989         ptr += buflen;
 990
 991         *ptr_io = ptr;
 992 }
 993
 994 /**
 995  *      ata_msense_caching - Simulate MODE SENSE caching info page
 996  *      @id: device IDENTIFY data
 997  *      @ptr_io: (input/output) Location to store more output data
 998  *      @last: End of output data buffer
 999  *
1000  *      Generate a caching info page, which conditionally indicates
1001  *      write caching to the SCSI layer, depending on device
1002  *      capabilities.
1003  *
1004  *      LOCKING:
1005  *      None.
1006  */
1007
1008 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1009                                        const u8 *last)
1010 {
1011         u8 page[] = {
1012                 0x8,                            /* page code */
1013                 0x12,                           /* page length */
1014                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 10 zeroes */
1015                 0, 0, 0, 0, 0, 0, 0, 0          /* 8 zeroes */
1016         };
1017
1018         if (ata_id_wcache_enabled(id))
1019                 page[2] |= (1 << 2);    /* write cache enable */
1020         if (!ata_id_rahead_enabled(id))
1021                 page[12] |= (1 << 5);   /* disable read ahead */
1022
1023         ata_msense_push(ptr_io, last, page, sizeof(page));
1024         return sizeof(page);
1025 }
1026
1027 /**
1028  *      ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1029  *      @dev: Device associated with this MODE SENSE command
1030  *      @ptr_io: (input/output) Location to store more output data
1031  *      @last: End of output data buffer
1032  *
1033  *      Generate a generic MODE SENSE control mode page.
1034  *
1035  *      LOCKING:
1036  *      None.
1037  */
1038
1039 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1040 {
1041         const u8 page[] = {0xa, 0xa, 2, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1042
1043         ata_msense_push(ptr_io, last, page, sizeof(page));
1044         return sizeof(page);
1045 }
1046
1047 /**
1048  *      ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1049  *      @dev: Device associated with this MODE SENSE command
1050  *      @ptr_io: (input/output) Location to store more output data
1051  *      @last: End of output data buffer
1052  *
1053  *      Generate a generic MODE SENSE r/w error recovery page.
1054  *
1055  *      LOCKING:
1056  *      None.
1057  */
1058
1059 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1060 {
1061         const u8 page[] = {
1062                 0x1,                      /* page code */
1063                 0xa,                      /* page length */
1064                 (1 << 7) | (1 << 6),      /* note auto r/w reallocation */
1065                 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1066         };
1067
1068         ata_msense_push(ptr_io, last, page, sizeof(page));
1069         return sizeof(page);
1070 }
1071
1072 /**
1073  *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1074  *      @args: device IDENTIFY data / SCSI command of interest.
1075  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1076  *      @buflen: Response buffer length.
1077  *
1078  *      Simulate MODE SENSE commands.
1079  *
1080  *      LOCKING:
1081  *      spin_lock_irqsave(host_set lock)
1082  */
1083
1084 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1085                                   unsigned int buflen)
1086 {
1087         u8 *scsicmd = args->cmd->cmnd, *p, *last;
1088         unsigned int page_control, six_byte, output_len;
1089
1090         VPRINTK("ENTER\n");
1091
1092         six_byte = (scsicmd[0] == MODE_SENSE);
1093
1094         /* we only support saved and current values (which we treat
1095          * in the same manner)
1096          */
1097         page_control = scsicmd[2] >> 6;
1098         if ((page_control != 0) && (page_control != 3))
1099                 return 1;
1100
1101         if (six_byte)
1102                 output_len = 4;
1103         else
1104                 output_len = 8;
1105
1106         p = rbuf + output_len;
1107         last = rbuf + buflen - 1;
1108
1109         switch(scsicmd[2] & 0x3f) {
1110         case 0x01:              /* r/w error recovery */
1111                 output_len += ata_msense_rw_recovery(&p, last);
1112                 break;
1113
1114         case 0x08:              /* caching */
1115                 output_len += ata_msense_caching(args->id, &p, last);
1116                 break;
1117
1118         case 0x0a: {            /* control mode */
1119                 output_len += ata_msense_ctl_mode(&p, last);
1120                 break;
1121                 }
1122
1123         case 0x3f:              /* all pages */
1124                 output_len += ata_msense_rw_recovery(&p, last);
1125                 output_len += ata_msense_caching(args->id, &p, last);
1126                 output_len += ata_msense_ctl_mode(&p, last);
1127                 break;
1128
1129         default:                /* invalid page code */
1130                 return 1;
1131         }
1132
1133         if (six_byte) {
1134                 output_len--;
1135                 rbuf[0] = output_len;
1136         } else {
1137                 output_len -= 2;
1138                 rbuf[0] = output_len >> 8;
1139                 rbuf[1] = output_len;
1140         }
1141
1142         return 0;
1143 }
1144
1145 /**
1146  *      ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1147  *      @args: device IDENTIFY data / SCSI command of interest.
1148  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1149  *      @buflen: Response buffer length.
1150  *
1151  *      Simulate READ CAPACITY commands.
1152  *
1153  *      LOCKING:
1154  *      spin_lock_irqsave(host_set lock)
1155  */
1156
1157 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1158                                 unsigned int buflen)
1159 {
1160         u64 n_sectors;
1161         u32 tmp;
1162
1163         VPRINTK("ENTER\n");
1164
1165         if (ata_id_has_lba48(args->id))
1166                 n_sectors = ata_id_u64(args->id, 100);
1167         else
1168                 n_sectors = ata_id_u32(args->id, 60);
1169         n_sectors--;            /* ATA TotalUserSectors - 1 */
1170
1171         tmp = n_sectors;        /* note: truncates, if lba48 */
1172         if (args->cmd->cmnd[0] == READ_CAPACITY) {
1173                 /* sector count, 32-bit */
1174                 rbuf[0] = tmp >> (8 * 3);
1175                 rbuf[1] = tmp >> (8 * 2);
1176                 rbuf[2] = tmp >> (8 * 1);
1177                 rbuf[3] = tmp;
1178
1179                 /* sector size */
1180                 tmp = ATA_SECT_SIZE;
1181                 rbuf[6] = tmp >> 8;
1182                 rbuf[7] = tmp;
1183
1184         } else {
1185                 /* sector count, 64-bit */
1186                 rbuf[2] = n_sectors >> (8 * 7);
1187                 rbuf[3] = n_sectors >> (8 * 6);
1188                 rbuf[4] = n_sectors >> (8 * 5);
1189                 rbuf[5] = n_sectors >> (8 * 4);
1190                 rbuf[6] = tmp >> (8 * 3);
1191                 rbuf[7] = tmp >> (8 * 2);
1192                 rbuf[8] = tmp >> (8 * 1);
1193                 rbuf[9] = tmp;
1194
1195                 /* sector size */
1196                 tmp = ATA_SECT_SIZE;
1197                 rbuf[12] = tmp >> 8;
1198                 rbuf[13] = tmp;
1199         }
1200
1201         return 0;
1202 }
1203
1204 /**
1205  *      ata_scsiop_report_luns - Simulate REPORT LUNS command
1206  *      @args: device IDENTIFY data / SCSI command of interest.
1207  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1208  *      @buflen: Response buffer length.
1209  *
1210  *      Simulate REPORT LUNS command.
1211  *
1212  *      LOCKING:
1213  *      spin_lock_irqsave(host_set lock)
1214  */
1215
1216 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1217                                    unsigned int buflen)
1218 {
1219         VPRINTK("ENTER\n");
1220         rbuf[3] = 8;    /* just one lun, LUN 0, size 8 bytes */
1221
1222         return 0;
1223 }
1224
1225 /**
1226  *      ata_scsi_badcmd - End a SCSI request with an error
1227  *      @cmd: SCSI request to be handled
1228  *      @done: SCSI command completion function
1229  *      @asc: SCSI-defined additional sense code
1230  *      @ascq: SCSI-defined additional sense code qualifier
1231  *
1232  *      Helper function that completes a SCSI command with
1233  *      %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1234  *      and the specified additional sense codes.
1235  *
1236  *      LOCKING:
1237  *      spin_lock_irqsave(host_set lock)
1238  */
1239
1240 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1241 {
1242         DPRINTK("ENTER\n");
1243         cmd->result = SAM_STAT_CHECK_CONDITION;
1244
1245         cmd->sense_buffer[0] = 0x70;
1246         cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1247         cmd->sense_buffer[7] = 14 - 8;  /* addnl. sense len. FIXME: correct? */
1248         cmd->sense_buffer[12] = asc;
1249         cmd->sense_buffer[13] = ascq;
1250
1251         done(cmd);
1252 }
1253
1254 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1255 {
1256         struct scsi_cmnd *cmd = qc->scsicmd;
1257
1258         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1259                 DPRINTK("request check condition\n");
1260
1261                 cmd->result = SAM_STAT_CHECK_CONDITION;
1262
1263                 qc->scsidone(cmd);
1264
1265                 return 1;
1266         } else {
1267                 u8 *scsicmd = cmd->cmnd;
1268
1269                 if (scsicmd[0] == INQUIRY) {
1270                         u8 *buf = NULL;
1271                         unsigned int buflen;
1272
1273                         buflen = ata_scsi_rbuf_get(cmd, &buf);
1274                         buf[2] = 0x5;
1275                         buf[3] = (buf[3] & 0xf0) | 2;
1276                         ata_scsi_rbuf_put(cmd, buf);
1277                 }
1278                 cmd->result = SAM_STAT_GOOD;
1279         }
1280
1281         qc->scsidone(cmd);
1282
1283         return 0;
1284 }
1285 /**
1286  *      atapi_xlat - Initialize PACKET taskfile
1287  *      @qc: command structure to be initialized
1288  *      @scsicmd: SCSI CDB associated with this PACKET command
1289  *
1290  *      LOCKING:
1291  *      spin_lock_irqsave(host_set lock)
1292  *
1293  *      RETURNS:
1294  *      Zero on success, non-zero on failure.
1295  */
1296
1297 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1298 {
1299         struct scsi_cmnd *cmd = qc->scsicmd;
1300         struct ata_device *dev = qc->dev;
1301         int using_pio = (dev->flags & ATA_DFLAG_PIO);
1302         int nodata = (cmd->sc_data_direction == SCSI_DATA_NONE);
1303
1304         if (!using_pio)
1305                 /* Check whether ATAPI DMA is safe */
1306                 if (ata_check_atapi_dma(qc))
1307                         using_pio = 1;
1308
1309         memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1310
1311         qc->complete_fn = atapi_qc_complete;
1312
1313         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1314         if (cmd->sc_data_direction == SCSI_DATA_WRITE) {
1315                 qc->tf.flags |= ATA_TFLAG_WRITE;
1316                 DPRINTK("direction: write\n");
1317         }
1318
1319         qc->tf.command = ATA_CMD_PACKET;
1320
1321         /* no data, or PIO data xfer */
1322         if (using_pio || nodata) {
1323                 if (nodata)
1324                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1325                 else
1326                         qc->tf.protocol = ATA_PROT_ATAPI;
1327                 qc->tf.lbam = (8 * 1024) & 0xff;
1328                 qc->tf.lbah = (8 * 1024) >> 8;
1329         }
1330
1331         /* DMA data xfer */
1332         else {
1333                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1334                 qc->tf.feature |= ATAPI_PKT_DMA;
1335
1336 #ifdef ATAPI_ENABLE_DMADIR
1337                 /* some SATA bridges need us to indicate data xfer direction */
1338                 if (cmd->sc_data_direction != SCSI_DATA_WRITE)
1339                         qc->tf.feature |= ATAPI_DMADIR;
1340 #endif
1341         }
1342
1343         qc->nbytes = cmd->bufflen;
1344
1345         return 0;
1346 }
1347
1348 /**
1349  *      ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1350  *      @ap: ATA port to which the device is attached
1351  *      @scsidev: SCSI device from which we derive the ATA device
1352  *
1353  *      Given various information provided in struct scsi_cmnd,
1354  *      map that onto an ATA bus, and using that mapping
1355  *      determine which ata_device is associated with the
1356  *      SCSI command to be sent.
1357  *
1358  *      LOCKING:
1359  *      spin_lock_irqsave(host_set lock)
1360  *
1361  *      RETURNS:
1362  *      Associated ATA device, or %NULL if not found.
1363  */
1364
1365 static struct ata_device *
1366 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1367 {
1368         struct ata_device *dev;
1369
1370         /* skip commands not addressed to targets we simulate */
1371         if (likely(scsidev->id < ATA_MAX_DEVICES))
1372                 dev = &ap->device[scsidev->id];
1373         else
1374                 return NULL;
1375
1376         if (unlikely((scsidev->channel != 0) ||
1377                      (scsidev->lun != 0)))
1378                 return NULL;
1379
1380         if (unlikely(!ata_dev_present(dev)))
1381                 return NULL;
1382
1383 #ifndef ATA_ENABLE_ATAPI
1384         if (unlikely(dev->class == ATA_DEV_ATAPI))
1385                 return NULL;
1386 #endif
1387
1388         return dev;
1389 }
1390
1391 /**
1392  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
1393  *      @dev: ATA device
1394  *      @cmd: SCSI command opcode to consider
1395  *
1396  *      Look up the SCSI command given, and determine whether the
1397  *      SCSI command is to be translated or simulated.
1398  *
1399  *      RETURNS:
1400  *      Pointer to translation function if possible, %NULL if not.
1401  */
1402
1403 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1404 {
1405         switch (cmd) {
1406         case READ_6:
1407         case READ_10:
1408         case READ_16:
1409
1410         case WRITE_6:
1411         case WRITE_10:
1412         case WRITE_16:
1413                 return ata_scsi_rw_xlat;
1414
1415         case SYNCHRONIZE_CACHE:
1416                 if (ata_try_flush_cache(dev))
1417                         return ata_scsi_flush_xlat;
1418                 break;
1419
1420         case VERIFY:
1421         case VERIFY_16:
1422                 return ata_scsi_verify_xlat;
1423         }
1424
1425         return NULL;
1426 }
1427
1428 /**
1429  *      ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1430  *      @ap: ATA port to which the command was being sent
1431  *      @cmd: SCSI command to dump
1432  *
1433  *      Prints the contents of a SCSI command via printk().
1434  */
1435
1436 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1437                                      struct scsi_cmnd *cmd)
1438 {
1439 #ifdef ATA_DEBUG
1440         struct scsi_device *scsidev = cmd->device;
1441         u8 *scsicmd = cmd->cmnd;
1442
1443         DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1444                 ap->id,
1445                 scsidev->channel, scsidev->id, scsidev->lun,
1446                 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1447                 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1448                 scsicmd[8]);
1449 #endif
1450 }
1451
1452 /**
1453  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1454  *      @cmd: SCSI command to be sent
1455  *      @done: Completion function, called when command is complete
1456  *
1457  *      In some cases, this function translates SCSI commands into
1458  *      ATA taskfiles, and queues the taskfiles to be sent to
1459  *      hardware.  In other cases, this function simulates a
1460  *      SCSI device by evaluating and responding to certain
1461  *      SCSI commands.  This creates the overall effect of
1462  *      ATA and ATAPI devices appearing as SCSI devices.
1463  *
1464  *      LOCKING:
1465  *      Releases scsi-layer-held lock, and obtains host_set lock.
1466  *
1467  *      RETURNS:
1468  *      Zero.
1469  */
1470
1471 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1472 {
1473         struct ata_port *ap;
1474         struct ata_device *dev;
1475         struct scsi_device *scsidev = cmd->device;
1476
1477         ap = (struct ata_port *) &scsidev->host->hostdata[0];
1478
1479         ata_scsi_dump_cdb(ap, cmd);
1480
1481         dev = ata_scsi_find_dev(ap, scsidev);
1482         if (unlikely(!dev)) {
1483                 cmd->result = (DID_BAD_TARGET << 16);
1484                 done(cmd);
1485                 goto out_unlock;
1486         }
1487
1488         if (dev->class == ATA_DEV_ATA) {
1489                 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1490                                                               cmd->cmnd[0]);
1491
1492                 if (xlat_func)
1493                         ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1494                 else
1495                         ata_scsi_simulate(dev->id, cmd, done);
1496         } else
1497                 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1498
1499 out_unlock:
1500         return 0;
1501 }
1502
1503 /**
1504  *      ata_scsi_simulate - simulate SCSI command on ATA device
1505  *      @id: current IDENTIFY data for target device.
1506  *      @cmd: SCSI command being sent to device.
1507  *      @done: SCSI command completion function.
1508  *
1509  *      Interprets and directly executes a select list of SCSI commands
1510  *      that can be handled internally.
1511  *
1512  *      LOCKING:
1513  *      spin_lock_irqsave(host_set lock)
1514  */
1515
1516 void ata_scsi_simulate(u16 *id,
1517                       struct scsi_cmnd *cmd,
1518                       void (*done)(struct scsi_cmnd *))
1519 {
1520         struct ata_scsi_args args;
1521         u8 *scsicmd = cmd->cmnd;
1522
1523         args.id = id;
1524         args.cmd = cmd;
1525         args.done = done;
1526
1527         switch(scsicmd[0]) {
1528                 /* no-op's, complete with success */
1529                 case SYNCHRONIZE_CACHE:
1530                 case REZERO_UNIT:
1531                 case SEEK_6:
1532                 case SEEK_10:
1533                 case TEST_UNIT_READY:
1534                 case FORMAT_UNIT:               /* FIXME: correct? */
1535                 case SEND_DIAGNOSTIC:           /* FIXME: correct? */
1536                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1537                         break;
1538
1539                 case INQUIRY:
1540                         if (scsicmd[1] & 2)                /* is CmdDt set?  */
1541                                 ata_bad_cdb(cmd, done);
1542                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
1543                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1544                         else if (scsicmd[2] == 0x00)
1545                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1546                         else if (scsicmd[2] == 0x80)
1547                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1548                         else if (scsicmd[2] == 0x83)
1549                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1550                         else
1551                                 ata_bad_cdb(cmd, done);
1552                         break;
1553
1554                 case MODE_SENSE:
1555                 case MODE_SENSE_10:
1556                         ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1557                         break;
1558
1559                 case MODE_SELECT:       /* unconditionally return */
1560                 case MODE_SELECT_10:    /* bad-field-in-cdb */
1561                         ata_bad_cdb(cmd, done);
1562                         break;
1563
1564                 case READ_CAPACITY:
1565                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1566                         break;
1567
1568                 case SERVICE_ACTION_IN:
1569                         if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1570                                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1571                         else
1572                                 ata_bad_cdb(cmd, done);
1573                         break;
1574
1575                 case REPORT_LUNS:
1576                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1577                         break;
1578
1579                 /* mandantory commands we haven't implemented yet */
1580                 case REQUEST_SENSE:
1581
1582                 /* all other commands */
1583                 default:
1584                         ata_bad_scsiop(cmd, done);
1585                         break;
1586         }
1587 }
1588