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 == DMA_FROM_DEVICE) {
 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                         /*
 351                          * do not overwrite sdev->host->max_sectors, since
 352                          * other drives on this host may not support LBA48
 353                          */
 354                         blk_queue_max_sectors(sdev->request_queue, 2048);
 355                 }
 356         }
 357
 358         return 0;       /* scsi layer doesn't check return value, sigh */
 359 }
 360
 361 /**
 362  *      ata_scsi_error - SCSI layer error handler callback
 363  *      @host: SCSI host on which error occurred
 364  *
 365  *      Handles SCSI-layer-thrown error events.
 366  *
 367  *      LOCKING:
 368  *      Inherited from SCSI layer (none, can sleep)
 369  *
 370  *      RETURNS:
 371  *      Zero.
 372  */
 373
 374 int ata_scsi_error(struct Scsi_Host *host)
 375 {
 376         struct ata_port *ap;
 377
 378         DPRINTK("ENTER\n");
 379
 380         ap = (struct ata_port *) &host->hostdata[0];
 381         ap->ops->eng_timeout(ap);
 382
 383         /* TODO: this is per-command; when queueing is supported
 384          * this code will either change or move to a more
 385          * appropriate place
 386          */
 387         host->host_failed--;
 388         INIT_LIST_HEAD(&host->eh_cmd_q);
 389
 390         DPRINTK("EXIT\n");
 391         return 0;
 392 }
 393
 394 /**
 395  *      ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
 396  *      @qc: Storage for translated ATA taskfile
 397  *      @scsicmd: SCSI command to translate (ignored)
 398  *
 399  *      Sets up an ATA taskfile to issue FLUSH CACHE or
 400  *      FLUSH CACHE EXT.
 401  *
 402  *      LOCKING:
 403  *      spin_lock_irqsave(host_set lock)
 404  *
 405  *      RETURNS:
 406  *      Zero on success, non-zero on error.
 407  */
 408
 409 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 410 {
 411         struct ata_taskfile *tf = &qc->tf;
 412
 413         tf->flags |= ATA_TFLAG_DEVICE;
 414         tf->protocol = ATA_PROT_NODATA;
 415
 416         if ((tf->flags & ATA_TFLAG_LBA48) &&
 417             (ata_id_has_flush_ext(qc->dev->id)))
 418                 tf->command = ATA_CMD_FLUSH_EXT;
 419         else
 420                 tf->command = ATA_CMD_FLUSH;
 421
 422         return 0;
 423 }
 424
 425 /**
 426  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
 427  *      @qc: Storage for translated ATA taskfile
 428  *      @scsicmd: SCSI command to translate
 429  *
 430  *      Converts SCSI VERIFY command to an ATA READ VERIFY command.
 431  *
 432  *      LOCKING:
 433  *      spin_lock_irqsave(host_set lock)
 434  *
 435  *      RETURNS:
 436  *      Zero on success, non-zero on error.
 437  */
 438
 439 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 440 {
 441         struct ata_taskfile *tf = &qc->tf;
 442         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
 443         u64 dev_sectors = qc->dev->n_sectors;
 444         u64 sect = 0;
 445         u32 n_sect = 0;
 446
 447         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 448         tf->protocol = ATA_PROT_NODATA;
 449         tf->device |= ATA_LBA;
 450
 451         if (scsicmd[0] == VERIFY) {
 452                 sect |= ((u64)scsicmd[2]) << 24;
 453                 sect |= ((u64)scsicmd[3]) << 16;
 454                 sect |= ((u64)scsicmd[4]) << 8;
 455                 sect |= ((u64)scsicmd[5]);
 456
 457                 n_sect |= ((u32)scsicmd[7]) << 8;
 458                 n_sect |= ((u32)scsicmd[8]);
 459         }
 460
 461         else if (scsicmd[0] == VERIFY_16) {
 462                 sect |= ((u64)scsicmd[2]) << 56;
 463                 sect |= ((u64)scsicmd[3]) << 48;
 464                 sect |= ((u64)scsicmd[4]) << 40;
 465                 sect |= ((u64)scsicmd[5]) << 32;
 466                 sect |= ((u64)scsicmd[6]) << 24;
 467                 sect |= ((u64)scsicmd[7]) << 16;
 468                 sect |= ((u64)scsicmd[8]) << 8;
 469                 sect |= ((u64)scsicmd[9]);
 470
 471                 n_sect |= ((u32)scsicmd[10]) << 24;
 472                 n_sect |= ((u32)scsicmd[11]) << 16;
 473                 n_sect |= ((u32)scsicmd[12]) << 8;
 474                 n_sect |= ((u32)scsicmd[13]);
 475         }
 476
 477         else
 478                 return 1;
 479
 480         if (!n_sect)
 481                 return 1;
 482         if (sect >= dev_sectors)
 483                 return 1;
 484         if ((sect + n_sect) > dev_sectors)
 485                 return 1;
 486         if (lba48) {
 487                 if (n_sect > (64 * 1024))
 488                         return 1;
 489         } else {
 490                 if (n_sect > 256)
 491                         return 1;
 492         }
 493
 494         if (lba48) {
 495                 tf->command = ATA_CMD_VERIFY_EXT;
 496
 497                 tf->hob_nsect = (n_sect >> 8) & 0xff;
 498
 499                 tf->hob_lbah = (sect >> 40) & 0xff;
 500                 tf->hob_lbam = (sect >> 32) & 0xff;
 501                 tf->hob_lbal = (sect >> 24) & 0xff;
 502         } else {
 503                 tf->command = ATA_CMD_VERIFY;
 504
 505                 tf->device |= (sect >> 24) & 0xf;
 506         }
 507
 508         tf->nsect = n_sect & 0xff;
 509
 510         tf->lbah = (sect >> 16) & 0xff;
 511         tf->lbam = (sect >> 8) & 0xff;
 512         tf->lbal = sect & 0xff;
 513
 514         return 0;
 515 }
 516
 517 /**
 518  *      ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
 519  *      @qc: Storage for translated ATA taskfile
 520  *      @scsicmd: SCSI command to translate
 521  *
 522  *      Converts any of six SCSI read/write commands into the
 523  *      ATA counterpart, including starting sector (LBA),
 524  *      sector count, and taking into account the device's LBA48
 525  *      support.
 526  *
 527  *      Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
 528  *      %WRITE_16 are currently supported.
 529  *
 530  *      LOCKING:
 531  *      spin_lock_irqsave(host_set lock)
 532  *
 533  *      RETURNS:
 534  *      Zero on success, non-zero on error.
 535  */
 536
 537 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 538 {
 539         struct ata_taskfile *tf = &qc->tf;
 540         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
 541
 542         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 543         tf->protocol = qc->dev->xfer_protocol;
 544         tf->device |= ATA_LBA;
 545
 546         if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
 547             scsicmd[0] == READ_16) {
 548                 tf->command = qc->dev->read_cmd;
 549         } else {
 550                 tf->command = qc->dev->write_cmd;
 551                 tf->flags |= ATA_TFLAG_WRITE;
 552         }
 553
 554         if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
 555                 if (lba48) {
 556                         tf->hob_nsect = scsicmd[7];
 557                         tf->hob_lbal = scsicmd[2];
 558
 559                         qc->nsect = ((unsigned int)scsicmd[7] << 8) |
 560                                         scsicmd[8];
 561                 } else {
 562                         /* if we don't support LBA48 addressing, the request
 563                          * -may- be too large. */
 564                         if ((scsicmd[2] & 0xf0) || scsicmd[7])
 565                                 return 1;
 566
 567                         /* stores LBA27:24 in lower 4 bits of device reg */
 568                         tf->device |= scsicmd[2];
 569
 570                         qc->nsect = scsicmd[8];
 571                 }
 572
 573                 tf->nsect = scsicmd[8];
 574                 tf->lbal = scsicmd[5];
 575                 tf->lbam = scsicmd[4];
 576                 tf->lbah = scsicmd[3];
 577
 578                 VPRINTK("ten-byte command\n");
 579                 return 0;
 580         }
 581
 582         if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
 583                 qc->nsect = tf->nsect = scsicmd[4];
 584                 tf->lbal = scsicmd[3];
 585                 tf->lbam = scsicmd[2];
 586                 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
 587
 588                 VPRINTK("six-byte command\n");
 589                 return 0;
 590         }
 591
 592         if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
 593                 /* rule out impossible LBAs and sector counts */
 594                 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
 595                         return 1;
 596
 597                 if (lba48) {
 598                         tf->hob_nsect = scsicmd[12];
 599                         tf->hob_lbal = scsicmd[6];
 600                         tf->hob_lbam = scsicmd[5];
 601                         tf->hob_lbah = scsicmd[4];
 602
 603                         qc->nsect = ((unsigned int)scsicmd[12] << 8) |
 604                                         scsicmd[13];
 605                 } else {
 606                         /* once again, filter out impossible non-zero values */
 607                         if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
 608                             (scsicmd[6] & 0xf0))
 609                                 return 1;
 610
 611                         /* stores LBA27:24 in lower 4 bits of device reg */
 612                         tf->device |= scsicmd[6];
 613
 614                         qc->nsect = scsicmd[13];
 615                 }
 616
 617                 tf->nsect = scsicmd[13];
 618                 tf->lbal = scsicmd[9];
 619                 tf->lbam = scsicmd[8];
 620                 tf->lbah = scsicmd[7];
 621
 622                 VPRINTK("sixteen-byte command\n");
 623                 return 0;
 624         }
 625
 626         DPRINTK("no-byte command\n");
 627         return 1;
 628 }
 629
 630 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
 631 {
 632         struct scsi_cmnd *cmd = qc->scsicmd;
 633
 634         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
 635                 ata_to_sense_error(qc, drv_stat);
 636         else
 637                 cmd->result = SAM_STAT_GOOD;
 638
 639         qc->scsidone(cmd);
 640
 641         return 0;
 642 }
 643
 644 /**
 645  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
 646  *      @ap: ATA port to which the command is addressed
 647  *      @dev: ATA device to which the command is addressed
 648  *      @cmd: SCSI command to execute
 649  *      @done: SCSI command completion function
 650  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
 651  *
 652  *      Our ->queuecommand() function has decided that the SCSI
 653  *      command issued can be directly translated into an ATA
 654  *      command, rather than handled internally.
 655  *
 656  *      This function sets up an ata_queued_cmd structure for the
 657  *      SCSI command, and sends that ata_queued_cmd to the hardware.
 658  *
 659  *      LOCKING:
 660  *      spin_lock_irqsave(host_set lock)
 661  */
 662
 663 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
 664                               struct scsi_cmnd *cmd,
 665                               void (*done)(struct scsi_cmnd *),
 666                               ata_xlat_func_t xlat_func)
 667 {
 668         struct ata_queued_cmd *qc;
 669         u8 *scsicmd = cmd->cmnd;
 670
 671         VPRINTK("ENTER\n");
 672
 673         qc = ata_scsi_qc_new(ap, dev, cmd, done);
 674         if (!qc)
 675                 return;
 676
 677         /* data is present; dma-map it */
 678         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
 679             cmd->sc_data_direction == DMA_TO_DEVICE) {
 680                 if (unlikely(cmd->request_bufflen < 1)) {
 681                         printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
 682                                ap->id, dev->devno);
 683                         goto err_out;
 684                 }
 685
 686                 if (cmd->use_sg)
 687                         ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
 688                 else
 689                         ata_sg_init_one(qc, cmd->request_buffer,
 690                                         cmd->request_bufflen);
 691
 692                 qc->dma_dir = cmd->sc_data_direction;
 693         }
 694
 695         qc->complete_fn = ata_scsi_qc_complete;
 696
 697         if (xlat_func(qc, scsicmd))
 698                 goto err_out;
 699
 700         /* select device, send command to hardware */
 701         if (ata_qc_issue(qc))
 702                 goto err_out;
 703
 704         VPRINTK("EXIT\n");
 705         return;
 706
 707 err_out:
 708         ata_qc_free(qc);
 709         ata_bad_cdb(cmd, done);
 710         DPRINTK("EXIT - badcmd\n");
 711 }
 712
 713 /**
 714  *      ata_scsi_rbuf_get - Map response buffer.
 715  *      @cmd: SCSI command containing buffer to be mapped.
 716  *      @buf_out: Pointer to mapped area.
 717  *
 718  *      Maps buffer contained within SCSI command @cmd.
 719  *
 720  *      LOCKING:
 721  *      spin_lock_irqsave(host_set lock)
 722  *
 723  *      RETURNS:
 724  *      Length of response buffer.
 725  */
 726
 727 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
 728 {
 729         u8 *buf;
 730         unsigned int buflen;
 731
 732         if (cmd->use_sg) {
 733                 struct scatterlist *sg;
 734
 735                 sg = (struct scatterlist *) cmd->request_buffer;
 736                 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
 737                 buflen = sg->length;
 738         } else {
 739                 buf = cmd->request_buffer;
 740                 buflen = cmd->request_bufflen;
 741         }
 742
 743         *buf_out = buf;
 744         return buflen;
 745 }
 746
 747 /**
 748  *      ata_scsi_rbuf_put - Unmap response buffer.
 749  *      @cmd: SCSI command containing buffer to be unmapped.
 750  *      @buf: buffer to unmap
 751  *
 752  *      Unmaps response buffer contained within @cmd.
 753  *
 754  *      LOCKING:
 755  *      spin_lock_irqsave(host_set lock)
 756  */
 757
 758 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
 759 {
 760         if (cmd->use_sg) {
 761                 struct scatterlist *sg;
 762
 763                 sg = (struct scatterlist *) cmd->request_buffer;
 764                 kunmap_atomic(buf - sg->offset, KM_USER0);
 765         }
 766 }
 767
 768 /**
 769  *      ata_scsi_rbuf_fill - wrapper for SCSI command simulators
 770  *      @args: device IDENTIFY data / SCSI command of interest.
 771  *      @actor: Callback hook for desired SCSI command simulator
 772  *
 773  *      Takes care of the hard work of simulating a SCSI command...
 774  *      Mapping the response buffer, calling the command's handler,
 775  *      and handling the handler's return value.  This return value
 776  *      indicates whether the handler wishes the SCSI command to be
 777  *      completed successfully, or not.
 778  *
 779  *      LOCKING:
 780  *      spin_lock_irqsave(host_set lock)
 781  */
 782
 783 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
 784                         unsigned int (*actor) (struct ata_scsi_args *args,
 785                                            u8 *rbuf, unsigned int buflen))
 786 {
 787         u8 *rbuf;
 788         unsigned int buflen, rc;
 789         struct scsi_cmnd *cmd = args->cmd;
 790
 791         buflen = ata_scsi_rbuf_get(cmd, &rbuf);
 792         memset(rbuf, 0, buflen);
 793         rc = actor(args, rbuf, buflen);
 794         ata_scsi_rbuf_put(cmd, rbuf);
 795
 796         if (rc)
 797                 ata_bad_cdb(cmd, args->done);
 798         else {
 799                 cmd->result = SAM_STAT_GOOD;
 800                 args->done(cmd);
 801         }
 802 }
 803
 804 /**
 805  *      ata_scsiop_inq_std - Simulate INQUIRY command
 806  *      @args: device IDENTIFY data / SCSI command of interest.
 807  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 808  *      @buflen: Response buffer length.
 809  *
 810  *      Returns standard device identification data associated
 811  *      with non-EVPD INQUIRY command output.
 812  *
 813  *      LOCKING:
 814  *      spin_lock_irqsave(host_set lock)
 815  */
 816
 817 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
 818                                unsigned int buflen)
 819 {
 820         u8 hdr[] = {
 821                 TYPE_DISK,
 822                 0,
 823                 0x5,    /* claim SPC-3 version compatibility */
 824                 2,
 825                 95 - 4
 826         };
 827
 828         /* set scsi removeable (RMB) bit per ata bit */
 829         if (ata_id_removeable(args->id))
 830                 hdr[1] |= (1 << 7);
 831
 832         VPRINTK("ENTER\n");
 833
 834         memcpy(rbuf, hdr, sizeof(hdr));
 835
 836         if (buflen > 35) {
 837                 memcpy(&rbuf[8], "ATA     ", 8);
 838                 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
 839                 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
 840                 if (rbuf[32] == 0 || rbuf[32] == ' ')
 841                         memcpy(&rbuf[32], "n/a ", 4);
 842         }
 843
 844         if (buflen > 63) {
 845                 const u8 versions[] = {
 846                         0x60,   /* SAM-3 (no version claimed) */
 847
 848                         0x03,
 849                         0x20,   /* SBC-2 (no version claimed) */
 850
 851                         0x02,
 852                         0x60    /* SPC-3 (no version claimed) */
 853                 };
 854
 855                 memcpy(rbuf + 59, versions, sizeof(versions));
 856         }
 857
 858         return 0;
 859 }
 860
 861 /**
 862  *      ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
 863  *      @args: device IDENTIFY data / SCSI command of interest.
 864  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 865  *      @buflen: Response buffer length.
 866  *
 867  *      Returns list of inquiry EVPD pages available.
 868  *
 869  *      LOCKING:
 870  *      spin_lock_irqsave(host_set lock)
 871  */
 872
 873 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
 874                               unsigned int buflen)
 875 {
 876         const u8 pages[] = {
 877                 0x00,   /* page 0x00, this page */
 878                 0x80,   /* page 0x80, unit serial no page */
 879                 0x83    /* page 0x83, device ident page */
 880         };
 881         rbuf[3] = sizeof(pages);        /* number of supported EVPD pages */
 882
 883         if (buflen > 6)
 884                 memcpy(rbuf + 4, pages, sizeof(pages));
 885
 886         return 0;
 887 }
 888
 889 /**
 890  *      ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
 891  *      @args: device IDENTIFY data / SCSI command of interest.
 892  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 893  *      @buflen: Response buffer length.
 894  *
 895  *      Returns ATA device serial number.
 896  *
 897  *      LOCKING:
 898  *      spin_lock_irqsave(host_set lock)
 899  */
 900
 901 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
 902                               unsigned int buflen)
 903 {
 904         const u8 hdr[] = {
 905                 0,
 906                 0x80,                   /* this page code */
 907                 0,
 908                 ATA_SERNO_LEN,          /* page len */
 909         };
 910         memcpy(rbuf, hdr, sizeof(hdr));
 911
 912         if (buflen > (ATA_SERNO_LEN + 4 - 1))
 913                 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
 914                                   ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
 915
 916         return 0;
 917 }
 918
 919 static const char *inq_83_str = "Linux ATA-SCSI simulator";
 920
 921 /**
 922  *      ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
 923  *      @args: device IDENTIFY data / SCSI command of interest.
 924  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 925  *      @buflen: Response buffer length.
 926  *
 927  *      Returns device identification.  Currently hardcoded to
 928  *      return "Linux ATA-SCSI simulator".
 929  *
 930  *      LOCKING:
 931  *      spin_lock_irqsave(host_set lock)
 932  */
 933
 934 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
 935                               unsigned int buflen)
 936 {
 937         rbuf[1] = 0x83;                 /* this page code */
 938         rbuf[3] = 4 + strlen(inq_83_str);       /* page len */
 939
 940         /* our one and only identification descriptor (vendor-specific) */
 941         if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
 942                 rbuf[4 + 0] = 2;        /* code set: ASCII */
 943                 rbuf[4 + 3] = strlen(inq_83_str);
 944                 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
 945         }
 946
 947         return 0;
 948 }
 949
 950 /**
 951  *      ata_scsiop_noop - Command handler that simply returns success.
 952  *      @args: device IDENTIFY data / SCSI command of interest.
 953  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
 954  *      @buflen: Response buffer length.
 955  *
 956  *      No operation.  Simply returns success to caller, to indicate
 957  *      that the caller should successfully complete this SCSI command.
 958  *
 959  *      LOCKING:
 960  *      spin_lock_irqsave(host_set lock)
 961  */
 962
 963 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
 964                             unsigned int buflen)
 965 {
 966         VPRINTK("ENTER\n");
 967         return 0;
 968 }
 969
 970 /**
 971  *      ata_msense_push - Push data onto MODE SENSE data output buffer
 972  *      @ptr_io: (input/output) Location to store more output data
 973  *      @last: End of output data buffer
 974  *      @buf: Pointer to BLOB being added to output buffer
 975  *      @buflen: Length of BLOB
 976  *
 977  *      Store MODE SENSE data on an output buffer.
 978  *
 979  *      LOCKING:
 980  *      None.
 981  */
 982
 983 static void ata_msense_push(u8 **ptr_io, const u8 *last,
 984                             const u8 *buf, unsigned int buflen)
 985 {
 986         u8 *ptr = *ptr_io;
 987
 988         if ((ptr + buflen - 1) > last)
 989                 return;
 990
 991         memcpy(ptr, buf, buflen);
 992
 993         ptr += buflen;
 994
 995         *ptr_io = ptr;
 996 }
 997
 998 /**
 999  *      ata_msense_caching - Simulate MODE SENSE caching info page
1000  *      @id: device IDENTIFY data
1001  *      @ptr_io: (input/output) Location to store more output data
1002  *      @last: End of output data buffer
1003  *
1004  *      Generate a caching info page, which conditionally indicates
1005  *      write caching to the SCSI layer, depending on device
1006  *      capabilities.
1007  *
1008  *      LOCKING:
1009  *      None.
1010  */
1011
1012 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1013                                        const u8 *last)
1014 {
1015         u8 page[] = {
1016                 0x8,                            /* page code */
1017                 0x12,                           /* page length */
1018                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 10 zeroes */
1019                 0, 0, 0, 0, 0, 0, 0, 0          /* 8 zeroes */
1020         };
1021
1022         if (ata_id_wcache_enabled(id))
1023                 page[2] |= (1 << 2);    /* write cache enable */
1024         if (!ata_id_rahead_enabled(id))
1025                 page[12] |= (1 << 5);   /* disable read ahead */
1026
1027         ata_msense_push(ptr_io, last, page, sizeof(page));
1028         return sizeof(page);
1029 }
1030
1031 /**
1032  *      ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1033  *      @dev: Device associated with this MODE SENSE command
1034  *      @ptr_io: (input/output) Location to store more output data
1035  *      @last: End of output data buffer
1036  *
1037  *      Generate a generic MODE SENSE control mode page.
1038  *
1039  *      LOCKING:
1040  *      None.
1041  */
1042
1043 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1044 {
1045         const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1046
1047         /* byte 2: set the descriptor format sense data bit (bit 2)
1048          * since we need to support returning this format for SAT
1049          * commands and any SCSI commands against a 48b LBA device.
1050          */
1051
1052         ata_msense_push(ptr_io, last, page, sizeof(page));
1053         return sizeof(page);
1054 }
1055
1056 /**
1057  *      ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1058  *      @dev: Device associated with this MODE SENSE command
1059  *      @ptr_io: (input/output) Location to store more output data
1060  *      @last: End of output data buffer
1061  *
1062  *      Generate a generic MODE SENSE r/w error recovery page.
1063  *
1064  *      LOCKING:
1065  *      None.
1066  */
1067
1068 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1069 {
1070         const u8 page[] = {
1071                 0x1,                      /* page code */
1072                 0xa,                      /* page length */
1073                 (1 << 7) | (1 << 6),      /* note auto r/w reallocation */
1074                 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1075         };
1076
1077         ata_msense_push(ptr_io, last, page, sizeof(page));
1078         return sizeof(page);
1079 }
1080
1081 /**
1082  *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1083  *      @args: device IDENTIFY data / SCSI command of interest.
1084  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1085  *      @buflen: Response buffer length.
1086  *
1087  *      Simulate MODE SENSE commands.
1088  *
1089  *      LOCKING:
1090  *      spin_lock_irqsave(host_set lock)
1091  */
1092
1093 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1094                                   unsigned int buflen)
1095 {
1096         u8 *scsicmd = args->cmd->cmnd, *p, *last;
1097         unsigned int page_control, six_byte, output_len;
1098
1099         VPRINTK("ENTER\n");
1100
1101         six_byte = (scsicmd[0] == MODE_SENSE);
1102
1103         /* we only support saved and current values (which we treat
1104          * in the same manner)
1105          */
1106         page_control = scsicmd[2] >> 6;
1107         if ((page_control != 0) && (page_control != 3))
1108                 return 1;
1109
1110         if (six_byte)
1111                 output_len = 4;
1112         else
1113                 output_len = 8;
1114
1115         p = rbuf + output_len;
1116         last = rbuf + buflen - 1;
1117
1118         switch(scsicmd[2] & 0x3f) {
1119         case 0x01:              /* r/w error recovery */
1120                 output_len += ata_msense_rw_recovery(&p, last);
1121                 break;
1122
1123         case 0x08:              /* caching */
1124                 output_len += ata_msense_caching(args->id, &p, last);
1125                 break;
1126
1127         case 0x0a: {            /* control mode */
1128                 output_len += ata_msense_ctl_mode(&p, last);
1129                 break;
1130                 }
1131
1132         case 0x3f:              /* all pages */
1133                 output_len += ata_msense_rw_recovery(&p, last);
1134                 output_len += ata_msense_caching(args->id, &p, last);
1135                 output_len += ata_msense_ctl_mode(&p, last);
1136                 break;
1137
1138         default:                /* invalid page code */
1139                 return 1;
1140         }
1141
1142         if (six_byte) {
1143                 output_len--;
1144                 rbuf[0] = output_len;
1145         } else {
1146                 output_len -= 2;
1147                 rbuf[0] = output_len >> 8;
1148                 rbuf[1] = output_len;
1149         }
1150
1151         return 0;
1152 }
1153
1154 /**
1155  *      ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1156  *      @args: device IDENTIFY data / SCSI command of interest.
1157  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1158  *      @buflen: Response buffer length.
1159  *
1160  *      Simulate READ CAPACITY commands.
1161  *
1162  *      LOCKING:
1163  *      spin_lock_irqsave(host_set lock)
1164  */
1165
1166 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1167                                 unsigned int buflen)
1168 {
1169         u64 n_sectors;
1170         u32 tmp;
1171
1172         VPRINTK("ENTER\n");
1173
1174         if (ata_id_has_lba48(args->id))
1175                 n_sectors = ata_id_u64(args->id, 100);
1176         else
1177                 n_sectors = ata_id_u32(args->id, 60);
1178         n_sectors--;            /* ATA TotalUserSectors - 1 */
1179
1180         if (args->cmd->cmnd[0] == READ_CAPACITY) {
1181                 if( n_sectors >= 0xffffffffULL )
1182                         tmp = 0xffffffff ;  /* Return max count on overflow */
1183                 else
1184                         tmp = n_sectors ;
1185
1186                 /* sector count, 32-bit */
1187                 rbuf[0] = tmp >> (8 * 3);
1188                 rbuf[1] = tmp >> (8 * 2);
1189                 rbuf[2] = tmp >> (8 * 1);
1190                 rbuf[3] = tmp;
1191
1192                 /* sector size */
1193                 tmp = ATA_SECT_SIZE;
1194                 rbuf[6] = tmp >> 8;
1195                 rbuf[7] = tmp;
1196
1197         } else {
1198                 /* sector count, 64-bit */
1199                 tmp = n_sectors >> (8 * 4);
1200                 rbuf[2] = tmp >> (8 * 3);
1201                 rbuf[3] = tmp >> (8 * 2);
1202                 rbuf[4] = tmp >> (8 * 1);
1203                 rbuf[5] = tmp;
1204                 tmp = n_sectors;
1205                 rbuf[6] = tmp >> (8 * 3);
1206                 rbuf[7] = tmp >> (8 * 2);
1207                 rbuf[8] = tmp >> (8 * 1);
1208                 rbuf[9] = tmp;
1209
1210                 /* sector size */
1211                 tmp = ATA_SECT_SIZE;
1212                 rbuf[12] = tmp >> 8;
1213                 rbuf[13] = tmp;
1214         }
1215
1216         return 0;
1217 }
1218
1219 /**
1220  *      ata_scsiop_report_luns - Simulate REPORT LUNS command
1221  *      @args: device IDENTIFY data / SCSI command of interest.
1222  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1223  *      @buflen: Response buffer length.
1224  *
1225  *      Simulate REPORT LUNS command.
1226  *
1227  *      LOCKING:
1228  *      spin_lock_irqsave(host_set lock)
1229  */
1230
1231 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1232                                    unsigned int buflen)
1233 {
1234         VPRINTK("ENTER\n");
1235         rbuf[3] = 8;    /* just one lun, LUN 0, size 8 bytes */
1236
1237         return 0;
1238 }
1239
1240 /**
1241  *      ata_scsi_badcmd - End a SCSI request with an error
1242  *      @cmd: SCSI request to be handled
1243  *      @done: SCSI command completion function
1244  *      @asc: SCSI-defined additional sense code
1245  *      @ascq: SCSI-defined additional sense code qualifier
1246  *
1247  *      Helper function that completes a SCSI command with
1248  *      %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1249  *      and the specified additional sense codes.
1250  *
1251  *      LOCKING:
1252  *      spin_lock_irqsave(host_set lock)
1253  */
1254
1255 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1256 {
1257         DPRINTK("ENTER\n");
1258         cmd->result = SAM_STAT_CHECK_CONDITION;
1259
1260         cmd->sense_buffer[0] = 0x70;
1261         cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1262         cmd->sense_buffer[7] = 14 - 8;  /* addnl. sense len. FIXME: correct? */
1263         cmd->sense_buffer[12] = asc;
1264         cmd->sense_buffer[13] = ascq;
1265
1266         done(cmd);
1267 }
1268
1269 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1270 {
1271         struct scsi_cmnd *cmd = qc->scsicmd;
1272
1273         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1274                 DPRINTK("request check condition\n");
1275
1276                 cmd->result = SAM_STAT_CHECK_CONDITION;
1277
1278                 qc->scsidone(cmd);
1279
1280                 return 1;
1281         } else {
1282                 u8 *scsicmd = cmd->cmnd;
1283
1284                 if (scsicmd[0] == INQUIRY) {
1285                         u8 *buf = NULL;
1286                         unsigned int buflen;
1287
1288                         buflen = ata_scsi_rbuf_get(cmd, &buf);
1289                         buf[2] = 0x5;
1290                         buf[3] = (buf[3] & 0xf0) | 2;
1291                         ata_scsi_rbuf_put(cmd, buf);
1292                 }
1293                 cmd->result = SAM_STAT_GOOD;
1294         }
1295
1296         qc->scsidone(cmd);
1297
1298         return 0;
1299 }
1300 /**
1301  *      atapi_xlat - Initialize PACKET taskfile
1302  *      @qc: command structure to be initialized
1303  *      @scsicmd: SCSI CDB associated with this PACKET command
1304  *
1305  *      LOCKING:
1306  *      spin_lock_irqsave(host_set lock)
1307  *
1308  *      RETURNS:
1309  *      Zero on success, non-zero on failure.
1310  */
1311
1312 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1313 {
1314         struct scsi_cmnd *cmd = qc->scsicmd;
1315         struct ata_device *dev = qc->dev;
1316         int using_pio = (dev->flags & ATA_DFLAG_PIO);
1317         int nodata = (cmd->sc_data_direction == DMA_NONE);
1318
1319         if (!using_pio)
1320                 /* Check whether ATAPI DMA is safe */
1321                 if (ata_check_atapi_dma(qc))
1322                         using_pio = 1;
1323
1324         memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1325
1326         qc->complete_fn = atapi_qc_complete;
1327
1328         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1329         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1330                 qc->tf.flags |= ATA_TFLAG_WRITE;
1331                 DPRINTK("direction: write\n");
1332         }
1333
1334         qc->tf.command = ATA_CMD_PACKET;
1335
1336         /* no data, or PIO data xfer */
1337         if (using_pio || nodata) {
1338                 if (nodata)
1339                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1340                 else
1341                         qc->tf.protocol = ATA_PROT_ATAPI;
1342                 qc->tf.lbam = (8 * 1024) & 0xff;
1343                 qc->tf.lbah = (8 * 1024) >> 8;
1344         }
1345
1346         /* DMA data xfer */
1347         else {
1348                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1349                 qc->tf.feature |= ATAPI_PKT_DMA;
1350
1351 #ifdef ATAPI_ENABLE_DMADIR
1352                 /* some SATA bridges need us to indicate data xfer direction */
1353                 if (cmd->sc_data_direction != DMA_TO_DEVICE)
1354                         qc->tf.feature |= ATAPI_DMADIR;
1355 #endif
1356         }
1357
1358         qc->nbytes = cmd->bufflen;
1359
1360         return 0;
1361 }
1362
1363 /**
1364  *      ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1365  *      @ap: ATA port to which the device is attached
1366  *      @scsidev: SCSI device from which we derive the ATA device
1367  *
1368  *      Given various information provided in struct scsi_cmnd,
1369  *      map that onto an ATA bus, and using that mapping
1370  *      determine which ata_device is associated with the
1371  *      SCSI command to be sent.
1372  *
1373  *      LOCKING:
1374  *      spin_lock_irqsave(host_set lock)
1375  *
1376  *      RETURNS:
1377  *      Associated ATA device, or %NULL if not found.
1378  */
1379
1380 static struct ata_device *
1381 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1382 {
1383         struct ata_device *dev;
1384
1385         /* skip commands not addressed to targets we simulate */
1386         if (likely(scsidev->id < ATA_MAX_DEVICES))
1387                 dev = &ap->device[scsidev->id];
1388         else
1389                 return NULL;
1390
1391         if (unlikely((scsidev->channel != 0) ||
1392                      (scsidev->lun != 0)))
1393                 return NULL;
1394
1395         if (unlikely(!ata_dev_present(dev)))
1396                 return NULL;
1397
1398 #ifndef ATA_ENABLE_ATAPI
1399         if (unlikely(dev->class == ATA_DEV_ATAPI))
1400                 return NULL;
1401 #endif
1402
1403         return dev;
1404 }
1405
1406 /**
1407  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
1408  *      @dev: ATA device
1409  *      @cmd: SCSI command opcode to consider
1410  *
1411  *      Look up the SCSI command given, and determine whether the
1412  *      SCSI command is to be translated or simulated.
1413  *
1414  *      RETURNS:
1415  *      Pointer to translation function if possible, %NULL if not.
1416  */
1417
1418 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1419 {
1420         switch (cmd) {
1421         case READ_6:
1422         case READ_10:
1423         case READ_16:
1424
1425         case WRITE_6:
1426         case WRITE_10:
1427         case WRITE_16:
1428                 return ata_scsi_rw_xlat;
1429
1430         case SYNCHRONIZE_CACHE:
1431                 if (ata_try_flush_cache(dev))
1432                         return ata_scsi_flush_xlat;
1433                 break;
1434
1435         case VERIFY:
1436         case VERIFY_16:
1437                 return ata_scsi_verify_xlat;
1438         }
1439
1440         return NULL;
1441 }
1442
1443 /**
1444  *      ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1445  *      @ap: ATA port to which the command was being sent
1446  *      @cmd: SCSI command to dump
1447  *
1448  *      Prints the contents of a SCSI command via printk().
1449  */
1450
1451 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1452                                      struct scsi_cmnd *cmd)
1453 {
1454 #ifdef ATA_DEBUG
1455         struct scsi_device *scsidev = cmd->device;
1456         u8 *scsicmd = cmd->cmnd;
1457
1458         DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1459                 ap->id,
1460                 scsidev->channel, scsidev->id, scsidev->lun,
1461                 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1462                 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1463                 scsicmd[8]);
1464 #endif
1465 }
1466
1467 /**
1468  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1469  *      @cmd: SCSI command to be sent
1470  *      @done: Completion function, called when command is complete
1471  *
1472  *      In some cases, this function translates SCSI commands into
1473  *      ATA taskfiles, and queues the taskfiles to be sent to
1474  *      hardware.  In other cases, this function simulates a
1475  *      SCSI device by evaluating and responding to certain
1476  *      SCSI commands.  This creates the overall effect of
1477  *      ATA and ATAPI devices appearing as SCSI devices.
1478  *
1479  *      LOCKING:
1480  *      Releases scsi-layer-held lock, and obtains host_set lock.
1481  *
1482  *      RETURNS:
1483  *      Zero.
1484  */
1485
1486 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1487 {
1488         struct ata_port *ap;
1489         struct ata_device *dev;
1490         struct scsi_device *scsidev = cmd->device;
1491
1492         ap = (struct ata_port *) &scsidev->host->hostdata[0];
1493
1494         ata_scsi_dump_cdb(ap, cmd);
1495
1496         dev = ata_scsi_find_dev(ap, scsidev);
1497         if (unlikely(!dev)) {
1498                 cmd->result = (DID_BAD_TARGET << 16);
1499                 done(cmd);
1500                 goto out_unlock;
1501         }
1502
1503         if (dev->class == ATA_DEV_ATA) {
1504                 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1505                                                               cmd->cmnd[0]);
1506
1507                 if (xlat_func)
1508                         ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1509                 else
1510                         ata_scsi_simulate(dev->id, cmd, done);
1511         } else
1512                 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1513
1514 out_unlock:
1515         return 0;
1516 }
1517
1518 /**
1519  *      ata_scsi_simulate - simulate SCSI command on ATA device
1520  *      @id: current IDENTIFY data for target device.
1521  *      @cmd: SCSI command being sent to device.
1522  *      @done: SCSI command completion function.
1523  *
1524  *      Interprets and directly executes a select list of SCSI commands
1525  *      that can be handled internally.
1526  *
1527  *      LOCKING:
1528  *      spin_lock_irqsave(host_set lock)
1529  */
1530
1531 void ata_scsi_simulate(u16 *id,
1532                       struct scsi_cmnd *cmd,
1533                       void (*done)(struct scsi_cmnd *))
1534 {
1535         struct ata_scsi_args args;
1536         u8 *scsicmd = cmd->cmnd;
1537
1538         args.id = id;
1539         args.cmd = cmd;
1540         args.done = done;
1541
1542         switch(scsicmd[0]) {
1543                 /* no-op's, complete with success */
1544                 case SYNCHRONIZE_CACHE:
1545                 case REZERO_UNIT:
1546                 case SEEK_6:
1547                 case SEEK_10:
1548                 case TEST_UNIT_READY:
1549                 case FORMAT_UNIT:               /* FIXME: correct? */
1550                 case SEND_DIAGNOSTIC:           /* FIXME: correct? */
1551                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1552                         break;
1553
1554                 case INQUIRY:
1555                         if (scsicmd[1] & 2)                /* is CmdDt set?  */
1556                                 ata_bad_cdb(cmd, done);
1557                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
1558                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1559                         else if (scsicmd[2] == 0x00)
1560                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1561                         else if (scsicmd[2] == 0x80)
1562                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1563                         else if (scsicmd[2] == 0x83)
1564                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1565                         else
1566                                 ata_bad_cdb(cmd, done);
1567                         break;
1568
1569                 case MODE_SENSE:
1570                 case MODE_SENSE_10:
1571                         ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1572                         break;
1573
1574                 case MODE_SELECT:       /* unconditionally return */
1575                 case MODE_SELECT_10:    /* bad-field-in-cdb */
1576                         ata_bad_cdb(cmd, done);
1577                         break;
1578
1579                 case READ_CAPACITY:
1580                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1581                         break;
1582
1583                 case SERVICE_ACTION_IN:
1584                         if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1585                                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1586                         else
1587                                 ata_bad_cdb(cmd, done);
1588                         break;
1589
1590                 case REPORT_LUNS:
1591                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1592                         break;
1593
1594                 /* mandantory commands we haven't implemented yet */
1595                 case REQUEST_SENSE:
1596
1597                 /* all other commands */
1598                 default:
1599                         ata_bad_scsiop(cmd, done);
1600                         break;
1601         }
1602 }
1603