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