err.no 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 <linux/hdreg.h>
  33 #include <asm/uaccess.h>
  34
  35 #include "libata.h"
  36
  37 #define SECTOR_SIZE     512
  38
  39 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, u8 *scsicmd);
  40 static struct ata_device *
  41 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
  42
  43
  44 /**
  45  *      ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
  46  *      @sdev: SCSI device for which BIOS geometry is to be determined
  47  *      @bdev: block device associated with @sdev
  48  *      @capacity: capacity of SCSI device
  49  *      @geom: location to which geometry will be output
  50  *
  51  *      Generic bios head/sector/cylinder calculator
  52  *      used by sd. Most BIOSes nowadays expect a XXX/255/16  (CHS)
  53  *      mapping. Some situations may arise where the disk is not
  54  *      bootable if this is not used.
  55  *
  56  *      LOCKING:
  57  *      Defined by the SCSI layer.  We don't really care.
  58  *
  59  *      RETURNS:
  60  *      Zero.
  61  */
  62 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
  63                        sector_t capacity, int geom[])
  64 {
  65         geom[0] = 255;
  66         geom[1] = 63;
  67         sector_div(capacity, 255*63);
  68         geom[2] = capacity;
  69
  70         return 0;
  71 }
  72
  73 /**
  74  *      ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
  75  *      @dev: Device to whom we are issuing command
  76  *      @arg: User provided data for issuing command
  77  *
  78  *      LOCKING:
  79  *      Defined by the SCSI layer.  We don't really care.
  80  *
  81  *      RETURNS:
  82  *      Zero on success, negative errno on error.
  83  */
  84
  85 int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
  86 {
  87         int rc = 0;
  88         u8 scsi_cmd[MAX_COMMAND_SIZE];
  89         u8 args[4], *argbuf = NULL;
  90         int argsize = 0;
  91         struct scsi_request *sreq;
  92
  93         if (NULL == (void *)arg)
  94                 return -EINVAL;
  95
  96         if (copy_from_user(args, arg, sizeof(args)))
  97                 return -EFAULT;
  98
  99         sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
 100         if (!sreq)
 101                 return -EINTR;
 102
 103         memset(scsi_cmd, 0, sizeof(scsi_cmd));
 104
 105         if (args[3]) {
 106                 argsize = SECTOR_SIZE * args[3];
 107                 argbuf = kmalloc(argsize, GFP_KERNEL);
 108                 if (argbuf == NULL)
 109                         return -ENOMEM;
 110
 111                 scsi_cmd[1]  = (4 << 1); /* PIO Data-in */
 112                 scsi_cmd[2]  = 0x0e;     /* no off.line or cc, read from dev,
 113                                             block count in sector count field */
 114                 sreq->sr_data_direction = DMA_FROM_DEVICE;
 115         } else {
 116                 scsi_cmd[1]  = (3 << 1); /* Non-data */
 117                 /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
 118                 sreq->sr_data_direction = DMA_NONE;
 119         }
 120
 121         scsi_cmd[0] = ATA_16;
 122
 123         scsi_cmd[4] = args[2];
 124         if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
 125                 scsi_cmd[6]  = args[3];
 126                 scsi_cmd[8]  = args[1];
 127                 scsi_cmd[10] = 0x4f;
 128                 scsi_cmd[12] = 0xc2;
 129         } else {
 130                 scsi_cmd[6]  = args[1];
 131         }
 132         scsi_cmd[14] = args[0];
 133
 134         /* Good values for timeout and retries?  Values below
 135            from scsi_ioctl_send_command() for default case... */
 136         scsi_wait_req(sreq, scsi_cmd, argbuf, argsize, (10*HZ), 5);
 137
 138         if (sreq->sr_result) {
 139                 rc = -EIO;
 140                 goto error;
 141         }
 142
 143         /* Need code to retrieve data from check condition? */
 144
 145         if ((argbuf)
 146          && copy_to_user((void *)(arg + sizeof(args)), argbuf, argsize))
 147                 rc = -EFAULT;
 148 error:
 149         scsi_release_request(sreq);
 150
 151         if (argbuf)
 152                 kfree(argbuf);
 153
 154         return rc;
 155 }
 156
 157 /**
 158  *      ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
 159  *      @dev: Device to whom we are issuing command
 160  *      @arg: User provided data for issuing command
 161  *
 162  *      LOCKING:
 163  *      Defined by the SCSI layer.  We don't really care.
 164  *
 165  *      RETURNS:
 166  *      Zero on success, negative errno on error.
 167  */
 168 int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
 169 {
 170         int rc = 0;
 171         u8 scsi_cmd[MAX_COMMAND_SIZE];
 172         u8 args[7];
 173         struct scsi_request *sreq;
 174
 175         if (NULL == (void *)arg)
 176                 return -EINVAL;
 177
 178         if (copy_from_user(args, arg, sizeof(args)))
 179                 return -EFAULT;
 180
 181         memset(scsi_cmd, 0, sizeof(scsi_cmd));
 182         scsi_cmd[0]  = ATA_16;
 183         scsi_cmd[1]  = (3 << 1); /* Non-data */
 184         /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
 185         scsi_cmd[4]  = args[1];
 186         scsi_cmd[6]  = args[2];
 187         scsi_cmd[8]  = args[3];
 188         scsi_cmd[10] = args[4];
 189         scsi_cmd[12] = args[5];
 190         scsi_cmd[14] = args[0];
 191
 192         sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
 193         if (!sreq) {
 194                 rc = -EINTR;
 195                 goto error;
 196         }
 197
 198         sreq->sr_data_direction = DMA_NONE;
 199         /* Good values for timeout and retries?  Values below
 200            from scsi_ioctl_send_command() for default case... */
 201         scsi_wait_req(sreq, scsi_cmd, NULL, 0, (10*HZ), 5);
 202
 203         if (sreq->sr_result) {
 204                 rc = -EIO;
 205                 goto error;
 206         }
 207
 208         /* Need code to retrieve data from check condition? */
 209
 210 error:
 211         scsi_release_request(sreq);
 212         return rc;
 213 }
 214
 215 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
 216 {
 217         struct ata_port *ap;
 218         struct ata_device *dev;
 219         int val = -EINVAL, rc = -EINVAL;
 220
 221         ap = (struct ata_port *) &scsidev->host->hostdata[0];
 222         if (!ap)
 223                 goto out;
 224
 225         dev = ata_scsi_find_dev(ap, scsidev);
 226         if (!dev) {
 227                 rc = -ENODEV;
 228                 goto out;
 229         }
 230
 231         switch (cmd) {
 232         case ATA_IOC_GET_IO32:
 233                 val = 0;
 234                 if (copy_to_user(arg, &val, 1))
 235                         return -EFAULT;
 236                 return 0;
 237
 238         case ATA_IOC_SET_IO32:
 239                 val = (unsigned long) arg;
 240                 if (val != 0)
 241                         return -EINVAL;
 242                 return 0;
 243
 244         case HDIO_DRIVE_CMD:
 245                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 246                         return -EACCES;
 247                 return ata_cmd_ioctl(scsidev, arg);
 248
 249         case HDIO_DRIVE_TASK:
 250                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 251                         return -EACCES;
 252                 return ata_task_ioctl(scsidev, arg);
 253
 254         default:
 255                 rc = -ENOTTY;
 256                 break;
 257         }
 258
 259 out:
 260         return rc;
 261 }
 262
 263 /**
 264  *      ata_scsi_qc_new - acquire new ata_queued_cmd reference
 265  *      @ap: ATA port to which the new command is attached
 266  *      @dev: ATA device to which the new command is attached
 267  *      @cmd: SCSI command that originated this ATA command
 268  *      @done: SCSI command completion function
 269  *
 270  *      Obtain a reference to an unused ata_queued_cmd structure,
 271  *      which is the basic libata structure representing a single
 272  *      ATA command sent to the hardware.
 273  *
 274  *      If a command was available, fill in the SCSI-specific
 275  *      portions of the structure with information on the
 276  *      current command.
 277  *
 278  *      LOCKING:
 279  *      spin_lock_irqsave(host_set lock)
 280  *
 281  *      RETURNS:
 282  *      Command allocated, or %NULL if none available.
 283  */
 284 struct ata_queued_cmd *ata_scsi_qc_new(struct ata_port *ap,
 285                                        struct ata_device *dev,
 286                                        struct scsi_cmnd *cmd,
 287                                        void (*done)(struct scsi_cmnd *))
 288 {
 289         struct ata_queued_cmd *qc;
 290
 291         qc = ata_qc_new_init(ap, dev);
 292         if (qc) {
 293                 qc->scsicmd = cmd;
 294                 qc->scsidone = done;
 295
 296                 if (cmd->use_sg) {
 297                         qc->sg = (struct scatterlist *) cmd->request_buffer;
 298                         qc->n_elem = cmd->use_sg;
 299                 } else {
 300                         qc->sg = &qc->sgent;
 301                         qc->n_elem = 1;
 302                 }
 303         } else {
 304                 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
 305                 done(cmd);
 306         }
 307
 308         return qc;
 309 }
 310
 311 /**
 312  *      ata_dump_status - user friendly display of error info
 313  *      @id: id of the port in question
 314  *      @tf: ptr to filled out taskfile
 315  *
 316  *      Decode and dump the ATA error/status registers for the user so
 317  *      that they have some idea what really happened at the non
 318  *      make-believe layer.
 319  *
 320  *      LOCKING:
 321  *      inherited from caller
 322  */
 323 void ata_dump_status(unsigned id, struct ata_taskfile *tf)
 324 {
 325         u8 stat = tf->command, err = tf->feature;
 326
 327         printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
 328         if (stat & ATA_BUSY) {
 329                 printk("Busy }\n");     /* Data is not valid in this case */
 330         } else {
 331                 if (stat & 0x40)        printk("DriveReady ");
 332                 if (stat & 0x20)        printk("DeviceFault ");
 333                 if (stat & 0x10)        printk("SeekComplete ");
 334                 if (stat & 0x08)        printk("DataRequest ");
 335                 if (stat & 0x04)        printk("CorrectedError ");
 336                 if (stat & 0x02)        printk("Index ");
 337                 if (stat & 0x01)        printk("Error ");
 338                 printk("}\n");
 339
 340                 if (err) {
 341                         printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
 342                         if (err & 0x04)         printk("DriveStatusError ");
 343                         if (err & 0x80) {
 344                                 if (err & 0x04) printk("BadCRC ");
 345                                 else            printk("Sector ");
 346                         }
 347                         if (err & 0x40)         printk("UncorrectableError ");
 348                         if (err & 0x10)         printk("SectorIdNotFound ");
 349                         if (err & 0x02)         printk("TrackZeroNotFound ");
 350                         if (err & 0x01)         printk("AddrMarkNotFound ");
 351                         printk("}\n");
 352                 }
 353         }
 354 }
 355
 356 /**
 357  *      ata_to_sense_error - convert ATA error to SCSI error
 358  *      @drv_stat: value contained in ATA status register
 359  *      @drv_err: value contained in ATA error register
 360  *      @sk: the sense key we'll fill out
 361  *      @asc: the additional sense code we'll fill out
 362  *      @ascq: the additional sense code qualifier we'll fill out
 363  *
 364  *      Converts an ATA error into a SCSI error.  Fill out pointers to
 365  *      SK, ASC, and ASCQ bytes for later use in fixed or descriptor
 366  *      format sense blocks.
 367  *
 368  *      LOCKING:
 369  *      spin_lock_irqsave(host_set lock)
 370  */
 371 void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
 372                         u8 *ascq)
 373 {
 374         int i;
 375         /* Based on the 3ware driver translation table */
 376         static unsigned char sense_table[][4] = {
 377                 /* BBD|ECC|ID|MAR */
 378                 {0xd1,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
 379                 /* BBD|ECC|ID */
 380                 {0xd0,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
 381                 /* ECC|MC|MARK */
 382                 {0x61,          HARDWARE_ERROR, 0x00, 0x00},    // Device fault                 Hardware error
 383                 /* ICRC|ABRT */         /* NB: ICRC & !ABRT is BBD */
 384                 {0x84,          ABORTED_COMMAND, 0x47, 0x00},   // Data CRC error               SCSI parity error
 385                 /* MC|ID|ABRT|TRK0|MARK */
 386                 {0x37,          NOT_READY, 0x04, 0x00},         // Unit offline                 Not ready
 387                 /* MCR|MARK */
 388                 {0x09,          NOT_READY, 0x04, 0x00},         // Unrecovered disk error       Not ready
 389                 /*  Bad address mark */
 390                 {0x01,          MEDIUM_ERROR, 0x13, 0x00},      // Address mark not found       Address mark not found for data field
 391                 /* TRK0 */
 392                 {0x02,          HARDWARE_ERROR, 0x00, 0x00},    // Track 0 not found              Hardware error
 393                 /* Abort & !ICRC */
 394                 {0x04,          ABORTED_COMMAND, 0x00, 0x00},   // Aborted command              Aborted command
 395                 /* Media change request */
 396                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change request   FIXME: faking offline
 397                 /* SRV */
 398                 {0x10,          ABORTED_COMMAND, 0x14, 0x00},   // ID not found                 Recorded entity not found
 399                 /* Media change */
 400                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change           FIXME: faking offline
 401                 /* ECC */
 402                 {0x40,          MEDIUM_ERROR, 0x11, 0x04},      // Uncorrectable ECC error      Unrecovered read error
 403                 /* BBD - block marked bad */
 404                 {0x80,          MEDIUM_ERROR, 0x11, 0x04},      // Block marked bad               Medium error, unrecovered read error
 405                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
 406         };
 407         static unsigned char stat_table[][4] = {
 408                 /* Must be first because BUSY means no other bits valid */
 409                 {0x80,          ABORTED_COMMAND, 0x47, 0x00},   // Busy, fake parity for now
 410                 {0x20,          HARDWARE_ERROR,  0x00, 0x00},   // Device fault
 411                 {0x08,          ABORTED_COMMAND, 0x47, 0x00},   // Timed out in xfer, fake parity for now
 412                 {0x04,          RECOVERED_ERROR, 0x11, 0x00},   // Recovered ECC error    Medium error, recovered
 413                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
 414         };
 415
 416         /*
 417          *      Is this an error we can process/parse
 418          */
 419         if (drv_stat & ATA_BUSY) {
 420                 drv_err = 0;    /* Ignore the err bits, they're invalid */
 421         }
 422
 423         if (drv_err) {
 424                 /* Look for drv_err */
 425                 for (i = 0; sense_table[i][0] != 0xFF; i++) {
 426                         /* Look for best matches first */
 427                         if ((sense_table[i][0] & drv_err) ==
 428                             sense_table[i][0]) {
 429                                 *sk = sense_table[i][1];
 430                                 *asc = sense_table[i][2];
 431                                 *ascq = sense_table[i][3];
 432                                 goto translate_done;
 433                         }
 434                 }
 435                 /* No immediate match */
 436                 printk(KERN_WARNING "ata%u: no sense translation for "
 437                        "error 0x%02x\n", id, drv_err);
 438         }
 439
 440         /* Fall back to interpreting status bits */
 441         for (i = 0; stat_table[i][0] != 0xFF; i++) {
 442                 if (stat_table[i][0] & drv_stat) {
 443                         *sk = stat_table[i][1];
 444                         *asc = stat_table[i][2];
 445                         *ascq = stat_table[i][3];
 446                         goto translate_done;
 447                 }
 448         }
 449         /* No error?  Undecoded? */
 450         printk(KERN_WARNING "ata%u: no sense translation for status: 0x%02x\n",
 451                id, drv_stat);
 452
 453         /* For our last chance pick, use medium read error because
 454          * it's much more common than an ATA drive telling you a write
 455          * has failed.
 456          */
 457         *sk = MEDIUM_ERROR;
 458         *asc = 0x11; /* "unrecovered read error" */
 459         *ascq = 0x04; /*  "auto-reallocation failed" */
 460
 461  translate_done:
 462         printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x to "
 463                "SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n", id, drv_stat, drv_err,
 464                *sk, *asc, *ascq);
 465         return;
 466 }
 467
 468 /*
 469  *      ata_gen_ata_desc_sense - Generate check condition sense block.
 470  *      @qc: Command that completed.
 471  *
 472  *      This function is specific to the ATA descriptor format sense
 473  *      block specified for the ATA pass through commands.  Regardless
 474  *      of whether the command errored or not, return a sense
 475  *      block. Copy all controller registers into the sense
 476  *      block. Clear sense key, ASC & ASCQ if there is no error.
 477  *
 478  *      LOCKING:
 479  *      spin_lock_irqsave(host_set lock)
 480  */
 481 void ata_gen_ata_desc_sense(struct ata_queued_cmd *qc)
 482 {
 483         struct scsi_cmnd *cmd = qc->scsicmd;
 484         struct ata_taskfile *tf = &qc->tf;
 485         unsigned char *sb = cmd->sense_buffer;
 486         unsigned char *desc = sb + 8;
 487
 488         memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
 489
 490         cmd->result = SAM_STAT_CHECK_CONDITION;
 491
 492         /*
 493          * Read the controller registers.
 494          */
 495         assert(NULL != qc->ap->ops->tf_read);
 496         qc->ap->ops->tf_read(qc->ap, tf);
 497
 498         /*
 499          * Use ata_to_sense_error() to map status register bits
 500          * onto sense key, asc & ascq.
 501          */
 502         if (unlikely(tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ))) {
 503                 ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
 504                                    &sb[1], &sb[2], &sb[3]);
 505                 sb[1] &= 0x0f;
 506         }
 507
 508         /*
 509          * Sense data is current and format is descriptor.
 510          */
 511         sb[0] = 0x72;
 512
 513         desc[0] = 0x09;
 514
 515         /*
 516          * Set length of additional sense data.
 517          * Since we only populate descriptor 0, the total
 518          * length is the same (fixed) length as descriptor 0.
 519          */
 520         desc[1] = sb[7] = 14;
 521
 522         /*
 523          * Copy registers into sense buffer.
 524          */
 525         desc[2] = 0x00;
 526         desc[3] = tf->feature;  /* == error reg */
 527         desc[5] = tf->nsect;
 528         desc[7] = tf->lbal;
 529         desc[9] = tf->lbam;
 530         desc[11] = tf->lbah;
 531         desc[12] = tf->device;
 532         desc[13] = tf->command; /* == status reg */
 533
 534         /*
 535          * Fill in Extend bit, and the high order bytes
 536          * if applicable.
 537          */
 538         if (tf->flags & ATA_TFLAG_LBA48) {
 539                 desc[2] |= 0x01;
 540                 desc[4] = tf->hob_nsect;
 541                 desc[6] = tf->hob_lbal;
 542                 desc[8] = tf->hob_lbam;
 543                 desc[10] = tf->hob_lbah;
 544         }
 545 }
 546
 547 /**
 548  *      ata_gen_fixed_sense - generate a SCSI fixed sense block
 549  *      @qc: Command that we are erroring out
 550  *
 551  *      Leverage ata_to_sense_error() to give us the codes.  Fit our
 552  *      LBA in here if there's room.
 553  *
 554  *      LOCKING:
 555  *      inherited from caller
 556  */
 557 void ata_gen_fixed_sense(struct ata_queued_cmd *qc)
 558 {
 559         struct scsi_cmnd *cmd = qc->scsicmd;
 560         struct ata_taskfile *tf = &qc->tf;
 561         unsigned char *sb = cmd->sense_buffer;
 562
 563         memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
 564
 565         cmd->result = SAM_STAT_CHECK_CONDITION;
 566
 567         /*
 568          * Read the controller registers.
 569          */
 570         assert(NULL != qc->ap->ops->tf_read);
 571         qc->ap->ops->tf_read(qc->ap, tf);
 572
 573         /*
 574          * Use ata_to_sense_error() to map status register bits
 575          * onto sense key, asc & ascq.
 576          */
 577         if (unlikely(tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ))) {
 578                 ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
 579                                    &sb[2], &sb[12], &sb[13]);
 580                 sb[2] &= 0x0f;
 581         }
 582
 583         sb[0] = 0x70;
 584         sb[7] = 0x0a;
 585
 586 #if 0 /* when C/H/S support is merged */
 587         if (tf->flags & ATA_TFLAG_LBA && !(tf->flags & ATA_TFLAG_LBA48)) {
 588 #endif
 589         if (!(tf->flags & ATA_TFLAG_LBA48)) {
 590                 /* A small (28b) LBA will fit in the 32b info field */
 591                 sb[0] |= 0x80;          /* set valid bit */
 592                 sb[3] = tf->device & 0x0f;
 593                 sb[4] = tf->lbah;
 594                 sb[5] = tf->lbam;
 595                 sb[6] = tf->lbal;
 596         }
 597 }
 598
 599 /**
 600  *      ata_scsi_slave_config - Set SCSI device attributes
 601  *      @sdev: SCSI device to examine
 602  *
 603  *      This is called before we actually start reading
 604  *      and writing to the device, to configure certain
 605  *      SCSI mid-layer behaviors.
 606  *
 607  *      LOCKING:
 608  *      Defined by SCSI layer.  We don't really care.
 609  */
 610
 611 int ata_scsi_slave_config(struct scsi_device *sdev)
 612 {
 613         sdev->use_10_for_rw = 1;
 614         sdev->use_10_for_ms = 1;
 615
 616         blk_queue_max_phys_segments(sdev->request_queue, LIBATA_MAX_PRD);
 617
 618         if (sdev->id < ATA_MAX_DEVICES) {
 619                 struct ata_port *ap;
 620                 struct ata_device *dev;
 621
 622                 ap = (struct ata_port *) &sdev->host->hostdata[0];
 623                 dev = &ap->device[sdev->id];
 624
 625                 /* TODO: 1024 is an arbitrary number, not the
 626                  * hardware maximum.  This should be increased to
 627                  * 65534 when Jens Axboe's patch for dynamically
 628                  * determining max_sectors is merged.
 629                  */
 630                 if ((dev->flags & ATA_DFLAG_LBA48) &&
 631                     ((dev->flags & ATA_DFLAG_LOCK_SECTORS) == 0)) {
 632                         /*
 633                          * do not overwrite sdev->host->max_sectors, since
 634                          * other drives on this host may not support LBA48
 635                          */
 636                         blk_queue_max_sectors(sdev->request_queue, 2048);
 637                 }
 638         }
 639
 640         return 0;       /* scsi layer doesn't check return value, sigh */
 641 }
 642
 643 /**
 644  *      ata_scsi_error - SCSI layer error handler callback
 645  *      @host: SCSI host on which error occurred
 646  *
 647  *      Handles SCSI-layer-thrown error events.
 648  *
 649  *      LOCKING:
 650  *      Inherited from SCSI layer (none, can sleep)
 651  *
 652  *      RETURNS:
 653  *      Zero.
 654  */
 655
 656 int ata_scsi_error(struct Scsi_Host *host)
 657 {
 658         struct ata_port *ap;
 659
 660         DPRINTK("ENTER\n");
 661
 662         ap = (struct ata_port *) &host->hostdata[0];
 663         ap->ops->eng_timeout(ap);
 664
 665         /* TODO: this is per-command; when queueing is supported
 666          * this code will either change or move to a more
 667          * appropriate place
 668          */
 669         host->host_failed--;
 670
 671         DPRINTK("EXIT\n");
 672         return 0;
 673 }
 674
 675 /**
 676  *      ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
 677  *      @qc: Storage for translated ATA taskfile
 678  *      @scsicmd: SCSI command to translate (ignored)
 679  *
 680  *      Sets up an ATA taskfile to issue FLUSH CACHE or
 681  *      FLUSH CACHE EXT.
 682  *
 683  *      LOCKING:
 684  *      spin_lock_irqsave(host_set lock)
 685  *
 686  *      RETURNS:
 687  *      Zero on success, non-zero on error.
 688  */
 689
 690 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 691 {
 692         struct ata_taskfile *tf = &qc->tf;
 693
 694         tf->flags |= ATA_TFLAG_DEVICE;
 695         tf->protocol = ATA_PROT_NODATA;
 696
 697         if ((tf->flags & ATA_TFLAG_LBA48) &&
 698             (ata_id_has_flush_ext(qc->dev->id)))
 699                 tf->command = ATA_CMD_FLUSH_EXT;
 700         else
 701                 tf->command = ATA_CMD_FLUSH;
 702
 703         return 0;
 704 }
 705
 706 /**
 707  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
 708  *      @qc: Storage for translated ATA taskfile
 709  *      @scsicmd: SCSI command to translate
 710  *
 711  *      Converts SCSI VERIFY command to an ATA READ VERIFY command.
 712  *
 713  *      LOCKING:
 714  *      spin_lock_irqsave(host_set lock)
 715  *
 716  *      RETURNS:
 717  *      Zero on success, non-zero on error.
 718  */
 719
 720 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 721 {
 722         struct ata_taskfile *tf = &qc->tf;
 723         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
 724         u64 dev_sectors = qc->dev->n_sectors;
 725         u64 sect = 0;
 726         u32 n_sect = 0;
 727
 728         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 729         tf->protocol = ATA_PROT_NODATA;
 730         tf->device |= ATA_LBA;
 731
 732         if (scsicmd[0] == VERIFY) {
 733                 sect |= ((u64)scsicmd[2]) << 24;
 734                 sect |= ((u64)scsicmd[3]) << 16;
 735                 sect |= ((u64)scsicmd[4]) << 8;
 736                 sect |= ((u64)scsicmd[5]);
 737
 738                 n_sect |= ((u32)scsicmd[7]) << 8;
 739                 n_sect |= ((u32)scsicmd[8]);
 740         }
 741
 742         else if (scsicmd[0] == VERIFY_16) {
 743                 sect |= ((u64)scsicmd[2]) << 56;
 744                 sect |= ((u64)scsicmd[3]) << 48;
 745                 sect |= ((u64)scsicmd[4]) << 40;
 746                 sect |= ((u64)scsicmd[5]) << 32;
 747                 sect |= ((u64)scsicmd[6]) << 24;
 748                 sect |= ((u64)scsicmd[7]) << 16;
 749                 sect |= ((u64)scsicmd[8]) << 8;
 750                 sect |= ((u64)scsicmd[9]);
 751
 752                 n_sect |= ((u32)scsicmd[10]) << 24;
 753                 n_sect |= ((u32)scsicmd[11]) << 16;
 754                 n_sect |= ((u32)scsicmd[12]) << 8;
 755                 n_sect |= ((u32)scsicmd[13]);
 756         }
 757
 758         else
 759                 return 1;
 760
 761         if (!n_sect)
 762                 return 1;
 763         if (sect >= dev_sectors)
 764                 return 1;
 765         if ((sect + n_sect) > dev_sectors)
 766                 return 1;
 767         if (lba48) {
 768                 if (n_sect > (64 * 1024))
 769                         return 1;
 770         } else {
 771                 if (n_sect > 256)
 772                         return 1;
 773         }
 774
 775         if (lba48) {
 776                 tf->command = ATA_CMD_VERIFY_EXT;
 777
 778                 tf->hob_nsect = (n_sect >> 8) & 0xff;
 779
 780                 tf->hob_lbah = (sect >> 40) & 0xff;
 781                 tf->hob_lbam = (sect >> 32) & 0xff;
 782                 tf->hob_lbal = (sect >> 24) & 0xff;
 783         } else {
 784                 tf->command = ATA_CMD_VERIFY;
 785
 786                 tf->device |= (sect >> 24) & 0xf;
 787         }
 788
 789         tf->nsect = n_sect & 0xff;
 790
 791         tf->lbah = (sect >> 16) & 0xff;
 792         tf->lbam = (sect >> 8) & 0xff;
 793         tf->lbal = sect & 0xff;
 794
 795         return 0;
 796 }
 797
 798 /**
 799  *      ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
 800  *      @qc: Storage for translated ATA taskfile
 801  *      @scsicmd: SCSI command to translate
 802  *
 803  *      Converts any of six SCSI read/write commands into the
 804  *      ATA counterpart, including starting sector (LBA),
 805  *      sector count, and taking into account the device's LBA48
 806  *      support.
 807  *
 808  *      Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
 809  *      %WRITE_16 are currently supported.
 810  *
 811  *      LOCKING:
 812  *      spin_lock_irqsave(host_set lock)
 813  *
 814  *      RETURNS:
 815  *      Zero on success, non-zero on error.
 816  */
 817
 818 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 819 {
 820         struct ata_taskfile *tf = &qc->tf;
 821         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
 822
 823         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
 824         tf->protocol = qc->dev->xfer_protocol;
 825         tf->device |= ATA_LBA;
 826
 827         if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
 828             scsicmd[0] == READ_16) {
 829                 tf->command = qc->dev->read_cmd;
 830         } else {
 831                 tf->command = qc->dev->write_cmd;
 832                 tf->flags |= ATA_TFLAG_WRITE;
 833         }
 834
 835         if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
 836                 if (lba48) {
 837                         tf->hob_nsect = scsicmd[7];
 838                         tf->hob_lbal = scsicmd[2];
 839
 840                         qc->nsect = ((unsigned int)scsicmd[7] << 8) |
 841                                         scsicmd[8];
 842                 } else {
 843                         /* if we don't support LBA48 addressing, the request
 844                          * -may- be too large. */
 845                         if ((scsicmd[2] & 0xf0) || scsicmd[7])
 846                                 return 1;
 847
 848                         /* stores LBA27:24 in lower 4 bits of device reg */
 849                         tf->device |= scsicmd[2];
 850
 851                         qc->nsect = scsicmd[8];
 852                 }
 853
 854                 tf->nsect = scsicmd[8];
 855                 tf->lbal = scsicmd[5];
 856                 tf->lbam = scsicmd[4];
 857                 tf->lbah = scsicmd[3];
 858
 859                 VPRINTK("ten-byte command\n");
 860                 return 0;
 861         }
 862
 863         if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
 864                 qc->nsect = tf->nsect = scsicmd[4];
 865                 tf->lbal = scsicmd[3];
 866                 tf->lbam = scsicmd[2];
 867                 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
 868
 869                 VPRINTK("six-byte command\n");
 870                 return 0;
 871         }
 872
 873         if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
 874                 /* rule out impossible LBAs and sector counts */
 875                 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
 876                         return 1;
 877
 878                 if (lba48) {
 879                         tf->hob_nsect = scsicmd[12];
 880                         tf->hob_lbal = scsicmd[6];
 881                         tf->hob_lbam = scsicmd[5];
 882                         tf->hob_lbah = scsicmd[4];
 883
 884                         qc->nsect = ((unsigned int)scsicmd[12] << 8) |
 885                                         scsicmd[13];
 886                 } else {
 887                         /* once again, filter out impossible non-zero values */
 888                         if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
 889                             (scsicmd[6] & 0xf0))
 890                                 return 1;
 891
 892                         /* stores LBA27:24 in lower 4 bits of device reg */
 893                         tf->device |= scsicmd[6];
 894
 895                         qc->nsect = scsicmd[13];
 896                 }
 897
 898                 tf->nsect = scsicmd[13];
 899                 tf->lbal = scsicmd[9];
 900                 tf->lbam = scsicmd[8];
 901                 tf->lbah = scsicmd[7];
 902
 903                 VPRINTK("sixteen-byte command\n");
 904                 return 0;
 905         }
 906
 907         DPRINTK("no-byte command\n");
 908         return 1;
 909 }
 910
 911 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
 912 {
 913         struct scsi_cmnd *cmd = qc->scsicmd;
 914         int need_sense = drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ);
 915
 916         /* For ATA pass thru (SAT) commands, generate a sense block if
 917          * user mandated it or if there's an error.  Note that if we
 918          * generate because the user forced us to, a check condition
 919          * is generated and the ATA register values are returned
 920          * whether the command completed successfully or not. If there
 921          * was no error, SK, ASC and ASCQ will all be zero.
 922          */
 923         if (((cmd->cmnd[0] == ATA_16) || (cmd->cmnd[0] == ATA_12)) &&
 924             ((cmd->cmnd[2] & 0x20) || need_sense)) {
 925                 ata_gen_ata_desc_sense(qc);
 926         } else {
 927                 if (!need_sense) {
 928                         cmd->result = SAM_STAT_GOOD;
 929                 } else {
 930                         /* TODO: decide which descriptor format to use
 931                          * for 48b LBA devices and call that here
 932                          * instead of the fixed desc, which is only
 933                          * good for smaller LBA (and maybe CHS?)
 934                          * devices.
 935                          */
 936                         ata_gen_fixed_sense(qc);
 937                 }
 938         }
 939
 940         if (need_sense) {
 941                 /* The ata_gen_..._sense routines fill in tf */
 942                 ata_dump_status(qc->ap->id, &qc->tf);
 943         }
 944
 945         qc->scsidone(cmd);
 946
 947         return 0;
 948 }
 949
 950 /**
 951  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
 952  *      @ap: ATA port to which the command is addressed
 953  *      @dev: ATA device to which the command is addressed
 954  *      @cmd: SCSI command to execute
 955  *      @done: SCSI command completion function
 956  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
 957  *
 958  *      Our ->queuecommand() function has decided that the SCSI
 959  *      command issued can be directly translated into an ATA
 960  *      command, rather than handled internally.
 961  *
 962  *      This function sets up an ata_queued_cmd structure for the
 963  *      SCSI command, and sends that ata_queued_cmd to the hardware.
 964  *
 965  *      LOCKING:
 966  *      spin_lock_irqsave(host_set lock)
 967  */
 968
 969 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
 970                               struct scsi_cmnd *cmd,
 971                               void (*done)(struct scsi_cmnd *),
 972                               ata_xlat_func_t xlat_func)
 973 {
 974         struct ata_queued_cmd *qc;
 975         u8 *scsicmd = cmd->cmnd;
 976
 977         VPRINTK("ENTER\n");
 978
 979         qc = ata_scsi_qc_new(ap, dev, cmd, done);
 980         if (!qc)
 981                 return;
 982
 983         /* data is present; dma-map it */
 984         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
 985             cmd->sc_data_direction == DMA_TO_DEVICE) {
 986                 if (unlikely(cmd->request_bufflen < 1)) {
 987                         printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
 988                                ap->id, dev->devno);
 989                         goto err_out;
 990                 }
 991
 992                 if (cmd->use_sg)
 993                         ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
 994                 else
 995                         ata_sg_init_one(qc, cmd->request_buffer,
 996                                         cmd->request_bufflen);
 997
 998                 qc->dma_dir = cmd->sc_data_direction;
 999         }
1000
1001         qc->complete_fn = ata_scsi_qc_complete;
1002
1003         if (xlat_func(qc, scsicmd))
1004                 goto err_out;
1005         /* select device, send command to hardware */
1006         if (ata_qc_issue(qc))
1007                 goto err_out;
1008
1009         VPRINTK("EXIT\n");
1010         return;
1011
1012 err_out:
1013         ata_qc_free(qc);
1014         ata_bad_cdb(cmd, done);
1015         DPRINTK("EXIT - badcmd\n");
1016 }
1017
1018 /**
1019  *      ata_scsi_rbuf_get - Map response buffer.
1020  *      @cmd: SCSI command containing buffer to be mapped.
1021  *      @buf_out: Pointer to mapped area.
1022  *
1023  *      Maps buffer contained within SCSI command @cmd.
1024  *
1025  *      LOCKING:
1026  *      spin_lock_irqsave(host_set lock)
1027  *
1028  *      RETURNS:
1029  *      Length of response buffer.
1030  */
1031
1032 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
1033 {
1034         u8 *buf;
1035         unsigned int buflen;
1036
1037         if (cmd->use_sg) {
1038                 struct scatterlist *sg;
1039
1040                 sg = (struct scatterlist *) cmd->request_buffer;
1041                 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
1042                 buflen = sg->length;
1043         } else {
1044                 buf = cmd->request_buffer;
1045                 buflen = cmd->request_bufflen;
1046         }
1047
1048         *buf_out = buf;
1049         return buflen;
1050 }
1051
1052 /**
1053  *      ata_scsi_rbuf_put - Unmap response buffer.
1054  *      @cmd: SCSI command containing buffer to be unmapped.
1055  *      @buf: buffer to unmap
1056  *
1057  *      Unmaps response buffer contained within @cmd.
1058  *
1059  *      LOCKING:
1060  *      spin_lock_irqsave(host_set lock)
1061  */
1062
1063 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
1064 {
1065         if (cmd->use_sg) {
1066                 struct scatterlist *sg;
1067
1068                 sg = (struct scatterlist *) cmd->request_buffer;
1069                 kunmap_atomic(buf - sg->offset, KM_USER0);
1070         }
1071 }
1072
1073 /**
1074  *      ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1075  *      @args: device IDENTIFY data / SCSI command of interest.
1076  *      @actor: Callback hook for desired SCSI command simulator
1077  *
1078  *      Takes care of the hard work of simulating a SCSI command...
1079  *      Mapping the response buffer, calling the command's handler,
1080  *      and handling the handler's return value.  This return value
1081  *      indicates whether the handler wishes the SCSI command to be
1082  *      completed successfully, or not.
1083  *
1084  *      LOCKING:
1085  *      spin_lock_irqsave(host_set lock)
1086  */
1087
1088 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1089                         unsigned int (*actor) (struct ata_scsi_args *args,
1090                                            u8 *rbuf, unsigned int buflen))
1091 {
1092         u8 *rbuf;
1093         unsigned int buflen, rc;
1094         struct scsi_cmnd *cmd = args->cmd;
1095
1096         buflen = ata_scsi_rbuf_get(cmd, &rbuf);
1097         memset(rbuf, 0, buflen);
1098         rc = actor(args, rbuf, buflen);
1099         ata_scsi_rbuf_put(cmd, rbuf);
1100
1101         if (rc)
1102                 ata_bad_cdb(cmd, args->done);
1103         else {
1104                 cmd->result = SAM_STAT_GOOD;
1105                 args->done(cmd);
1106         }
1107 }
1108
1109 /**
1110  *      ata_scsiop_inq_std - Simulate INQUIRY command
1111  *      @args: device IDENTIFY data / SCSI command of interest.
1112  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1113  *      @buflen: Response buffer length.
1114  *
1115  *      Returns standard device identification data associated
1116  *      with non-EVPD INQUIRY command output.
1117  *
1118  *      LOCKING:
1119  *      spin_lock_irqsave(host_set lock)
1120  */
1121
1122 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
1123                                unsigned int buflen)
1124 {
1125         u8 hdr[] = {
1126                 TYPE_DISK,
1127                 0,
1128                 0x5,    /* claim SPC-3 version compatibility */
1129                 2,
1130                 95 - 4
1131         };
1132
1133         /* set scsi removeable (RMB) bit per ata bit */
1134         if (ata_id_removeable(args->id))
1135                 hdr[1] |= (1 << 7);
1136
1137         VPRINTK("ENTER\n");
1138
1139         memcpy(rbuf, hdr, sizeof(hdr));
1140
1141         if (buflen > 35) {
1142                 memcpy(&rbuf[8], "ATA     ", 8);
1143                 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
1144                 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
1145                 if (rbuf[32] == 0 || rbuf[32] == ' ')
1146                         memcpy(&rbuf[32], "n/a ", 4);
1147         }
1148
1149         if (buflen > 63) {
1150                 const u8 versions[] = {
1151                         0x60,   /* SAM-3 (no version claimed) */
1152
1153                         0x03,
1154                         0x20,   /* SBC-2 (no version claimed) */
1155
1156                         0x02,
1157                         0x60    /* SPC-3 (no version claimed) */
1158                 };
1159
1160                 memcpy(rbuf + 59, versions, sizeof(versions));
1161         }
1162
1163         return 0;
1164 }
1165
1166 /**
1167  *      ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
1168  *      @args: device IDENTIFY data / SCSI command of interest.
1169  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1170  *      @buflen: Response buffer length.
1171  *
1172  *      Returns list of inquiry EVPD pages available.
1173  *
1174  *      LOCKING:
1175  *      spin_lock_irqsave(host_set lock)
1176  */
1177
1178 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
1179                               unsigned int buflen)
1180 {
1181         const u8 pages[] = {
1182                 0x00,   /* page 0x00, this page */
1183                 0x80,   /* page 0x80, unit serial no page */
1184                 0x83    /* page 0x83, device ident page */
1185         };
1186         rbuf[3] = sizeof(pages);        /* number of supported EVPD pages */
1187
1188         if (buflen > 6)
1189                 memcpy(rbuf + 4, pages, sizeof(pages));
1190
1191         return 0;
1192 }
1193
1194 /**
1195  *      ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
1196  *      @args: device IDENTIFY data / SCSI command of interest.
1197  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1198  *      @buflen: Response buffer length.
1199  *
1200  *      Returns ATA device serial number.
1201  *
1202  *      LOCKING:
1203  *      spin_lock_irqsave(host_set lock)
1204  */
1205
1206 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
1207                               unsigned int buflen)
1208 {
1209         const u8 hdr[] = {
1210                 0,
1211                 0x80,                   /* this page code */
1212                 0,
1213                 ATA_SERNO_LEN,          /* page len */
1214         };
1215         memcpy(rbuf, hdr, sizeof(hdr));
1216
1217         if (buflen > (ATA_SERNO_LEN + 4 - 1))
1218                 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
1219                                   ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
1220
1221         return 0;
1222 }
1223
1224 static const char *inq_83_str = "Linux ATA-SCSI simulator";
1225
1226 /**
1227  *      ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
1228  *      @args: device IDENTIFY data / SCSI command of interest.
1229  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1230  *      @buflen: Response buffer length.
1231  *
1232  *      Returns device identification.  Currently hardcoded to
1233  *      return "Linux ATA-SCSI simulator".
1234  *
1235  *      LOCKING:
1236  *      spin_lock_irqsave(host_set lock)
1237  */
1238
1239 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1240                               unsigned int buflen)
1241 {
1242         rbuf[1] = 0x83;                 /* this page code */
1243         rbuf[3] = 4 + strlen(inq_83_str);       /* page len */
1244
1245         /* our one and only identification descriptor (vendor-specific) */
1246         if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
1247                 rbuf[4 + 0] = 2;        /* code set: ASCII */
1248                 rbuf[4 + 3] = strlen(inq_83_str);
1249                 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
1250         }
1251
1252         return 0;
1253 }
1254
1255 /**
1256  *      ata_scsiop_noop - Command handler that simply returns success.
1257  *      @args: device IDENTIFY data / SCSI command of interest.
1258  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1259  *      @buflen: Response buffer length.
1260  *
1261  *      No operation.  Simply returns success to caller, to indicate
1262  *      that the caller should successfully complete this SCSI command.
1263  *
1264  *      LOCKING:
1265  *      spin_lock_irqsave(host_set lock)
1266  */
1267
1268 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1269                             unsigned int buflen)
1270 {
1271         VPRINTK("ENTER\n");
1272         return 0;
1273 }
1274
1275 /**
1276  *      ata_msense_push - Push data onto MODE SENSE data output buffer
1277  *      @ptr_io: (input/output) Location to store more output data
1278  *      @last: End of output data buffer
1279  *      @buf: Pointer to BLOB being added to output buffer
1280  *      @buflen: Length of BLOB
1281  *
1282  *      Store MODE SENSE data on an output buffer.
1283  *
1284  *      LOCKING:
1285  *      None.
1286  */
1287
1288 static void ata_msense_push(u8 **ptr_io, const u8 *last,
1289                             const u8 *buf, unsigned int buflen)
1290 {
1291         u8 *ptr = *ptr_io;
1292
1293         if ((ptr + buflen - 1) > last)
1294                 return;
1295
1296         memcpy(ptr, buf, buflen);
1297
1298         ptr += buflen;
1299
1300         *ptr_io = ptr;
1301 }
1302
1303 /**
1304  *      ata_msense_caching - Simulate MODE SENSE caching info page
1305  *      @id: device IDENTIFY data
1306  *      @ptr_io: (input/output) Location to store more output data
1307  *      @last: End of output data buffer
1308  *
1309  *      Generate a caching info page, which conditionally indicates
1310  *      write caching to the SCSI layer, depending on device
1311  *      capabilities.
1312  *
1313  *      LOCKING:
1314  *      None.
1315  */
1316
1317 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1318                                        const u8 *last)
1319 {
1320         u8 page[] = {
1321                 0x8,                            /* page code */
1322                 0x12,                           /* page length */
1323                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 10 zeroes */
1324                 0, 0, 0, 0, 0, 0, 0, 0          /* 8 zeroes */
1325         };
1326
1327         if (ata_id_wcache_enabled(id))
1328                 page[2] |= (1 << 2);    /* write cache enable */
1329         if (!ata_id_rahead_enabled(id))
1330                 page[12] |= (1 << 5);   /* disable read ahead */
1331
1332         ata_msense_push(ptr_io, last, page, sizeof(page));
1333         return sizeof(page);
1334 }
1335
1336 /**
1337  *      ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1338  *      @dev: Device associated with this MODE SENSE command
1339  *      @ptr_io: (input/output) Location to store more output data
1340  *      @last: End of output data buffer
1341  *
1342  *      Generate a generic MODE SENSE control mode page.
1343  *
1344  *      LOCKING:
1345  *      None.
1346  */
1347
1348 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1349 {
1350         const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1351
1352         /* byte 2: set the descriptor format sense data bit (bit 2)
1353          * since we need to support returning this format for SAT
1354          * commands and any SCSI commands against a 48b LBA device.
1355          */
1356
1357         ata_msense_push(ptr_io, last, page, sizeof(page));
1358         return sizeof(page);
1359 }
1360
1361 /**
1362  *      ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1363  *      @dev: Device associated with this MODE SENSE command
1364  *      @ptr_io: (input/output) Location to store more output data
1365  *      @last: End of output data buffer
1366  *
1367  *      Generate a generic MODE SENSE r/w error recovery page.
1368  *
1369  *      LOCKING:
1370  *      None.
1371  */
1372
1373 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1374 {
1375         const u8 page[] = {
1376                 0x1,                      /* page code */
1377                 0xa,                      /* page length */
1378                 (1 << 7) | (1 << 6),      /* note auto r/w reallocation */
1379                 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1380         };
1381
1382         ata_msense_push(ptr_io, last, page, sizeof(page));
1383         return sizeof(page);
1384 }
1385
1386 /**
1387  *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1388  *      @args: device IDENTIFY data / SCSI command of interest.
1389  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1390  *      @buflen: Response buffer length.
1391  *
1392  *      Simulate MODE SENSE commands.
1393  *
1394  *      LOCKING:
1395  *      spin_lock_irqsave(host_set lock)
1396  */
1397
1398 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1399                                   unsigned int buflen)
1400 {
1401         u8 *scsicmd = args->cmd->cmnd, *p, *last;
1402         unsigned int page_control, six_byte, output_len;
1403
1404         VPRINTK("ENTER\n");
1405
1406         six_byte = (scsicmd[0] == MODE_SENSE);
1407
1408         /* we only support saved and current values (which we treat
1409          * in the same manner)
1410          */
1411         page_control = scsicmd[2] >> 6;
1412         if ((page_control != 0) && (page_control != 3))
1413                 return 1;
1414
1415         if (six_byte)
1416                 output_len = 4;
1417         else
1418                 output_len = 8;
1419
1420         p = rbuf + output_len;
1421         last = rbuf + buflen - 1;
1422
1423         switch(scsicmd[2] & 0x3f) {
1424         case 0x01:              /* r/w error recovery */
1425                 output_len += ata_msense_rw_recovery(&p, last);
1426                 break;
1427
1428         case 0x08:              /* caching */
1429                 output_len += ata_msense_caching(args->id, &p, last);
1430                 break;
1431
1432         case 0x0a: {            /* control mode */
1433                 output_len += ata_msense_ctl_mode(&p, last);
1434                 break;
1435                 }
1436
1437         case 0x3f:              /* all pages */
1438                 output_len += ata_msense_rw_recovery(&p, last);
1439                 output_len += ata_msense_caching(args->id, &p, last);
1440                 output_len += ata_msense_ctl_mode(&p, last);
1441                 break;
1442
1443         default:                /* invalid page code */
1444                 return 1;
1445         }
1446
1447         if (six_byte) {
1448                 output_len--;
1449                 rbuf[0] = output_len;
1450         } else {
1451                 output_len -= 2;
1452                 rbuf[0] = output_len >> 8;
1453                 rbuf[1] = output_len;
1454         }
1455
1456         return 0;
1457 }
1458
1459 /**
1460  *      ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1461  *      @args: device IDENTIFY data / SCSI command of interest.
1462  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1463  *      @buflen: Response buffer length.
1464  *
1465  *      Simulate READ CAPACITY commands.
1466  *
1467  *      LOCKING:
1468  *      spin_lock_irqsave(host_set lock)
1469  */
1470
1471 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1472                                 unsigned int buflen)
1473 {
1474         u64 n_sectors;
1475         u32 tmp;
1476
1477         VPRINTK("ENTER\n");
1478
1479         if (ata_id_has_lba48(args->id))
1480                 n_sectors = ata_id_u64(args->id, 100);
1481         else
1482                 n_sectors = ata_id_u32(args->id, 60);
1483         n_sectors--;            /* ATA TotalUserSectors - 1 */
1484
1485         if (args->cmd->cmnd[0] == READ_CAPACITY) {
1486                 if( n_sectors >= 0xffffffffULL )
1487                         tmp = 0xffffffff ;  /* Return max count on overflow */
1488                 else
1489                         tmp = n_sectors ;
1490
1491                 /* sector count, 32-bit */
1492                 rbuf[0] = tmp >> (8 * 3);
1493                 rbuf[1] = tmp >> (8 * 2);
1494                 rbuf[2] = tmp >> (8 * 1);
1495                 rbuf[3] = tmp;
1496
1497                 /* sector size */
1498                 tmp = ATA_SECT_SIZE;
1499                 rbuf[6] = tmp >> 8;
1500                 rbuf[7] = tmp;
1501
1502         } else {
1503                 /* sector count, 64-bit */
1504                 tmp = n_sectors >> (8 * 4);
1505                 rbuf[2] = tmp >> (8 * 3);
1506                 rbuf[3] = tmp >> (8 * 2);
1507                 rbuf[4] = tmp >> (8 * 1);
1508                 rbuf[5] = tmp;
1509                 tmp = n_sectors;
1510                 rbuf[6] = tmp >> (8 * 3);
1511                 rbuf[7] = tmp >> (8 * 2);
1512                 rbuf[8] = tmp >> (8 * 1);
1513                 rbuf[9] = tmp;
1514
1515                 /* sector size */
1516                 tmp = ATA_SECT_SIZE;
1517                 rbuf[12] = tmp >> 8;
1518                 rbuf[13] = tmp;
1519         }
1520
1521         return 0;
1522 }
1523
1524 /**
1525  *      ata_scsiop_report_luns - Simulate REPORT LUNS command
1526  *      @args: device IDENTIFY data / SCSI command of interest.
1527  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1528  *      @buflen: Response buffer length.
1529  *
1530  *      Simulate REPORT LUNS command.
1531  *
1532  *      LOCKING:
1533  *      spin_lock_irqsave(host_set lock)
1534  */
1535
1536 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1537                                    unsigned int buflen)
1538 {
1539         VPRINTK("ENTER\n");
1540         rbuf[3] = 8;    /* just one lun, LUN 0, size 8 bytes */
1541
1542         return 0;
1543 }
1544
1545 /**
1546  *      ata_scsi_badcmd - End a SCSI request with an error
1547  *      @cmd: SCSI request to be handled
1548  *      @done: SCSI command completion function
1549  *      @asc: SCSI-defined additional sense code
1550  *      @ascq: SCSI-defined additional sense code qualifier
1551  *
1552  *      Helper function that completes a SCSI command with
1553  *      %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1554  *      and the specified additional sense codes.
1555  *
1556  *      LOCKING:
1557  *      spin_lock_irqsave(host_set lock)
1558  */
1559
1560 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1561 {
1562         DPRINTK("ENTER\n");
1563         cmd->result = SAM_STAT_CHECK_CONDITION;
1564
1565         cmd->sense_buffer[0] = 0x70;
1566         cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1567         cmd->sense_buffer[7] = 14 - 8;  /* addnl. sense len. FIXME: correct? */
1568         cmd->sense_buffer[12] = asc;
1569         cmd->sense_buffer[13] = ascq;
1570
1571         done(cmd);
1572 }
1573
1574 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1575 {
1576         struct scsi_cmnd *cmd = qc->scsicmd;
1577
1578         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1579                 DPRINTK("request check condition\n");
1580
1581                 cmd->result = SAM_STAT_CHECK_CONDITION;
1582
1583                 qc->scsidone(cmd);
1584
1585                 return 1;
1586         } else {
1587                 u8 *scsicmd = cmd->cmnd;
1588
1589                 if (scsicmd[0] == INQUIRY) {
1590                         u8 *buf = NULL;
1591                         unsigned int buflen;
1592
1593                         buflen = ata_scsi_rbuf_get(cmd, &buf);
1594                         buf[2] = 0x5;
1595                         buf[3] = (buf[3] & 0xf0) | 2;
1596                         ata_scsi_rbuf_put(cmd, buf);
1597                 }
1598                 cmd->result = SAM_STAT_GOOD;
1599         }
1600
1601         qc->scsidone(cmd);
1602
1603         return 0;
1604 }
1605 /**
1606  *      atapi_xlat - Initialize PACKET taskfile
1607  *      @qc: command structure to be initialized
1608  *      @scsicmd: SCSI CDB associated with this PACKET command
1609  *
1610  *      LOCKING:
1611  *      spin_lock_irqsave(host_set lock)
1612  *
1613  *      RETURNS:
1614  *      Zero on success, non-zero on failure.
1615  */
1616
1617 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1618 {
1619         struct scsi_cmnd *cmd = qc->scsicmd;
1620         struct ata_device *dev = qc->dev;
1621         int using_pio = (dev->flags & ATA_DFLAG_PIO);
1622         int nodata = (cmd->sc_data_direction == DMA_NONE);
1623
1624         if (!using_pio)
1625                 /* Check whether ATAPI DMA is safe */
1626                 if (ata_check_atapi_dma(qc))
1627                         using_pio = 1;
1628
1629         memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1630
1631         qc->complete_fn = atapi_qc_complete;
1632
1633         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1634         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1635                 qc->tf.flags |= ATA_TFLAG_WRITE;
1636                 DPRINTK("direction: write\n");
1637         }
1638
1639         qc->tf.command = ATA_CMD_PACKET;
1640
1641         /* no data, or PIO data xfer */
1642         if (using_pio || nodata) {
1643                 if (nodata)
1644                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1645                 else
1646                         qc->tf.protocol = ATA_PROT_ATAPI;
1647                 qc->tf.lbam = (8 * 1024) & 0xff;
1648                 qc->tf.lbah = (8 * 1024) >> 8;
1649         }
1650
1651         /* DMA data xfer */
1652         else {
1653                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1654                 qc->tf.feature |= ATAPI_PKT_DMA;
1655
1656 #ifdef ATAPI_ENABLE_DMADIR
1657                 /* some SATA bridges need us to indicate data xfer direction */
1658                 if (cmd->sc_data_direction != DMA_TO_DEVICE)
1659                         qc->tf.feature |= ATAPI_DMADIR;
1660 #endif
1661         }
1662
1663         qc->nbytes = cmd->bufflen;
1664
1665         return 0;
1666 }
1667
1668 /**
1669  *      ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1670  *      @ap: ATA port to which the device is attached
1671  *      @scsidev: SCSI device from which we derive the ATA device
1672  *
1673  *      Given various information provided in struct scsi_cmnd,
1674  *      map that onto an ATA bus, and using that mapping
1675  *      determine which ata_device is associated with the
1676  *      SCSI command to be sent.
1677  *
1678  *      LOCKING:
1679  *      spin_lock_irqsave(host_set lock)
1680  *
1681  *      RETURNS:
1682  *      Associated ATA device, or %NULL if not found.
1683  */
1684
1685 static struct ata_device *
1686 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1687 {
1688         struct ata_device *dev;
1689
1690         /* skip commands not addressed to targets we simulate */
1691         if (likely(scsidev->id < ATA_MAX_DEVICES))
1692                 dev = &ap->device[scsidev->id];
1693         else
1694                 return NULL;
1695
1696         if (unlikely((scsidev->channel != 0) ||
1697                      (scsidev->lun != 0)))
1698                 return NULL;
1699
1700         if (unlikely(!ata_dev_present(dev)))
1701                 return NULL;
1702
1703 #ifndef ATA_ENABLE_ATAPI
1704         if (unlikely(dev->class == ATA_DEV_ATAPI))
1705                 return NULL;
1706 #endif
1707
1708         return dev;
1709 }
1710
1711 /*
1712  *      ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
1713  *      @byte1: Byte 1 from pass-thru CDB.
1714  *
1715  *      RETURNS:
1716  *      ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
1717  */
1718 static u8
1719 ata_scsi_map_proto(u8 byte1)
1720 {
1721         switch((byte1 & 0x1e) >> 1) {
1722                 case 3:         /* Non-data */
1723                         return ATA_PROT_NODATA;
1724
1725                 case 6:         /* DMA */
1726                         return ATA_PROT_DMA;
1727
1728                 case 4:         /* PIO Data-in */
1729                 case 5:         /* PIO Data-out */
1730                         if (byte1 & 0xe0) {
1731                                 return ATA_PROT_PIO_MULT;
1732                         }
1733                         return ATA_PROT_PIO;
1734
1735                 case 10:        /* Device Reset */
1736                 case 0:         /* Hard Reset */
1737                 case 1:         /* SRST */
1738                 case 2:         /* Bus Idle */
1739                 case 7:         /* Packet */
1740                 case 8:         /* DMA Queued */
1741                 case 9:         /* Device Diagnostic */
1742                 case 11:        /* UDMA Data-in */
1743                 case 12:        /* UDMA Data-Out */
1744                 case 13:        /* FPDMA */
1745                 default:        /* Reserved */
1746                         break;
1747         }
1748
1749         return ATA_PROT_UNKNOWN;
1750 }
1751
1752 /**
1753  *      ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
1754  *      @qc: command structure to be initialized
1755  *      @cmd: SCSI command to convert
1756  *
1757  *      Handles either 12 or 16-byte versions of the CDB.
1758  *
1759  *      RETURNS:
1760  *      Zero on success, non-zero on failure.
1761  */
1762 static unsigned int
1763 ata_scsi_pass_thru(struct ata_queued_cmd *qc, u8 *scsicmd)
1764 {
1765         struct ata_taskfile *tf = &(qc->tf);
1766         struct scsi_cmnd *cmd = qc->scsicmd;
1767
1768         if ((tf->protocol = ata_scsi_map_proto(scsicmd[1])) == ATA_PROT_UNKNOWN)
1769                 return 1;
1770
1771         /*
1772          * 12 and 16 byte CDBs use different offsets to
1773          * provide the various register values.
1774          */
1775         if (scsicmd[0] == ATA_16) {
1776                 /*
1777                  * 16-byte CDB - may contain extended commands.
1778                  *
1779                  * If that is the case, copy the upper byte register values.
1780                  */
1781                 if (scsicmd[1] & 0x01) {
1782                         tf->hob_feature = scsicmd[3];
1783                         tf->hob_nsect = scsicmd[5];
1784                         tf->hob_lbal = scsicmd[7];
1785                         tf->hob_lbam = scsicmd[9];
1786                         tf->hob_lbah = scsicmd[11];
1787                         tf->flags |= ATA_TFLAG_LBA48;
1788                 } else
1789                         tf->flags &= ~ATA_TFLAG_LBA48;
1790
1791                 /*
1792                  * Always copy low byte, device and command registers.
1793                  */
1794                 tf->feature = scsicmd[4];
1795                 tf->nsect = scsicmd[6];
1796                 tf->lbal = scsicmd[8];
1797                 tf->lbam = scsicmd[10];
1798                 tf->lbah = scsicmd[12];
1799                 tf->device = scsicmd[13];
1800                 tf->command = scsicmd[14];
1801         } else {
1802                 /*
1803                  * 12-byte CDB - incapable of extended commands.
1804                  */
1805                 tf->flags &= ~ATA_TFLAG_LBA48;
1806
1807                 tf->feature = scsicmd[3];
1808                 tf->nsect = scsicmd[4];
1809                 tf->lbal = scsicmd[5];
1810                 tf->lbam = scsicmd[6];
1811                 tf->lbah = scsicmd[7];
1812                 tf->device = scsicmd[8];
1813                 tf->command = scsicmd[9];
1814         }
1815
1816         /*
1817          * Filter SET_FEATURES - XFER MODE command -- otherwise,
1818          * SET_FEATURES - XFER MODE must be preceded/succeeded
1819          * by an update to hardware-specific registers for each
1820          * controller (i.e. the reason for ->set_piomode(),
1821          * ->set_dmamode(), and ->post_set_mode() hooks).
1822          */
1823         if ((tf->command == ATA_CMD_SET_FEATURES)
1824          && (tf->feature == SETFEATURES_XFER))
1825                 return 1;
1826
1827         /*
1828          * Set flags so that all registers will be written,
1829          * and pass on write indication (used for PIO/DMA
1830          * setup.)
1831          */
1832         tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
1833
1834         if (cmd->sc_data_direction == DMA_TO_DEVICE)
1835                 tf->flags |= ATA_TFLAG_WRITE;
1836
1837         /*
1838          * Set transfer length.
1839          *
1840          * TODO: find out if we need to do more here to
1841          *       cover scatter/gather case.
1842          */
1843         qc->nsect = cmd->bufflen / ATA_SECT_SIZE;
1844
1845         return 0;
1846 }
1847
1848 /**
1849  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
1850  *      @dev: ATA device
1851  *      @cmd: SCSI command opcode to consider
1852  *
1853  *      Look up the SCSI command given, and determine whether the
1854  *      SCSI command is to be translated or simulated.
1855  *
1856  *      RETURNS:
1857  *      Pointer to translation function if possible, %NULL if not.
1858  */
1859
1860 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1861 {
1862         switch (cmd) {
1863         case READ_6:
1864         case READ_10:
1865         case READ_16:
1866
1867         case WRITE_6:
1868         case WRITE_10:
1869         case WRITE_16:
1870                 return ata_scsi_rw_xlat;
1871
1872         case SYNCHRONIZE_CACHE:
1873                 if (ata_try_flush_cache(dev))
1874                         return ata_scsi_flush_xlat;
1875                 break;
1876
1877         case VERIFY:
1878         case VERIFY_16:
1879                 return ata_scsi_verify_xlat;
1880
1881         case ATA_12:
1882         case ATA_16:
1883                 return ata_scsi_pass_thru;
1884         }
1885
1886         return NULL;
1887 }
1888
1889 /**
1890  *      ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1891  *      @ap: ATA port to which the command was being sent
1892  *      @cmd: SCSI command to dump
1893  *
1894  *      Prints the contents of a SCSI command via printk().
1895  */
1896
1897 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1898                                      struct scsi_cmnd *cmd)
1899 {
1900 #ifdef ATA_DEBUG
1901         struct scsi_device *scsidev = cmd->device;
1902         u8 *scsicmd = cmd->cmnd;
1903
1904         DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1905                 ap->id,
1906                 scsidev->channel, scsidev->id, scsidev->lun,
1907                 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1908                 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1909                 scsicmd[8]);
1910 #endif
1911 }
1912
1913 /**
1914  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1915  *      @cmd: SCSI command to be sent
1916  *      @done: Completion function, called when command is complete
1917  *
1918  *      In some cases, this function translates SCSI commands into
1919  *      ATA taskfiles, and queues the taskfiles to be sent to
1920  *      hardware.  In other cases, this function simulates a
1921  *      SCSI device by evaluating and responding to certain
1922  *      SCSI commands.  This creates the overall effect of
1923  *      ATA and ATAPI devices appearing as SCSI devices.
1924  *
1925  *      LOCKING:
1926  *      Releases scsi-layer-held lock, and obtains host_set lock.
1927  *
1928  *      RETURNS:
1929  *      Zero.
1930  */
1931
1932 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1933 {
1934         struct ata_port *ap;
1935         struct ata_device *dev;
1936         struct scsi_device *scsidev = cmd->device;
1937
1938         ap = (struct ata_port *) &scsidev->host->hostdata[0];
1939
1940         ata_scsi_dump_cdb(ap, cmd);
1941
1942         dev = ata_scsi_find_dev(ap, scsidev);
1943         if (unlikely(!dev)) {
1944                 cmd->result = (DID_BAD_TARGET << 16);
1945                 done(cmd);
1946                 goto out_unlock;
1947         }
1948
1949         if (dev->class == ATA_DEV_ATA) {
1950                 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1951                                                               cmd->cmnd[0]);
1952
1953                 if (xlat_func)
1954                         ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1955                 else
1956                         ata_scsi_simulate(dev->id, cmd, done);
1957         } else
1958                 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1959
1960 out_unlock:
1961         return 0;
1962 }
1963
1964 /**
1965  *      ata_scsi_simulate - simulate SCSI command on ATA device
1966  *      @id: current IDENTIFY data for target device.
1967  *      @cmd: SCSI command being sent to device.
1968  *      @done: SCSI command completion function.
1969  *
1970  *      Interprets and directly executes a select list of SCSI commands
1971  *      that can be handled internally.
1972  *
1973  *      LOCKING:
1974  *      spin_lock_irqsave(host_set lock)
1975  */
1976
1977 void ata_scsi_simulate(u16 *id,
1978                       struct scsi_cmnd *cmd,
1979                       void (*done)(struct scsi_cmnd *))
1980 {
1981         struct ata_scsi_args args;
1982         u8 *scsicmd = cmd->cmnd;
1983
1984         args.id = id;
1985         args.cmd = cmd;
1986         args.done = done;
1987
1988         switch(scsicmd[0]) {
1989                 /* no-op's, complete with success */
1990                 case SYNCHRONIZE_CACHE:
1991                 case REZERO_UNIT:
1992                 case SEEK_6:
1993                 case SEEK_10:
1994                 case TEST_UNIT_READY:
1995                 case FORMAT_UNIT:               /* FIXME: correct? */
1996                 case SEND_DIAGNOSTIC:           /* FIXME: correct? */
1997                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1998                         break;
1999
2000                 case INQUIRY:
2001                         if (scsicmd[1] & 2)                /* is CmdDt set?  */
2002                                 ata_bad_cdb(cmd, done);
2003                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
2004                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
2005                         else if (scsicmd[2] == 0x00)
2006                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
2007                         else if (scsicmd[2] == 0x80)
2008                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
2009                         else if (scsicmd[2] == 0x83)
2010                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
2011                         else
2012                                 ata_bad_cdb(cmd, done);
2013                         break;
2014
2015                 case MODE_SENSE:
2016                 case MODE_SENSE_10:
2017                         ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
2018                         break;
2019
2020                 case MODE_SELECT:       /* unconditionally return */
2021                 case MODE_SELECT_10:    /* bad-field-in-cdb */
2022                         ata_bad_cdb(cmd, done);
2023                         break;
2024
2025                 case READ_CAPACITY:
2026                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2027                         break;
2028
2029                 case SERVICE_ACTION_IN:
2030                         if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
2031                                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2032                         else
2033                                 ata_bad_cdb(cmd, done);
2034                         break;
2035
2036                 case REPORT_LUNS:
2037                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
2038                         break;
2039
2040                 /* mandatory commands we haven't implemented yet */
2041                 case REQUEST_SENSE:
2042
2043                 /* all other commands */
2044                 default:
2045                         ata_bad_scsiop(cmd, done);
2046                         break;
2047         }
2048 }
2049