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