2 libata-scsi.c - helper library for ATA
4 Copyright 2003-2004 Red Hat, Inc. All rights reserved.
5 Copyright 2003-2004 Jeff Garzik
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
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.
25 #include <linux/kernel.h>
26 #include <linux/blkdev.h>
27 #include <linux/spinlock.h>
28 #include <scsi/scsi.h>
30 #include <scsi/scsi_host.h>
31 #include <linux/libata.h>
32 #include <asm/uaccess.h>
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);
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
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.
54 * Defined by the SCSI layer. We don't really care.
59 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
60 sector_t capacity, int geom[])
64 sector_div(capacity, 255*63);
70 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
73 struct ata_device *dev;
74 int val = -EINVAL, rc = -EINVAL;
76 ap = (struct ata_port *) &scsidev->host->hostdata[0];
80 dev = ata_scsi_find_dev(ap, scsidev);
87 case ATA_IOC_GET_IO32:
89 if (copy_to_user(arg, &val, 1))
93 case ATA_IOC_SET_IO32:
94 val = (unsigned long) arg;
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
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.
119 * If a command was available, fill in the SCSI-specific
120 * portions of the structure with information on the
124 * spin_lock_irqsave(host_set lock)
127 * Command allocated, or %NULL if none available.
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 *))
134 struct ata_queued_cmd *qc;
136 qc = ata_qc_new_init(ap, dev);
142 qc->sg = (struct scatterlist *) cmd->request_buffer;
143 qc->n_elem = cmd->use_sg;
149 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
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
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
167 * spin_lock_irqsave(host_set lock)
170 void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
172 struct scsi_cmnd *cmd = qc->scsicmd;
174 unsigned char *sb = cmd->sense_buffer;
175 /* Based on the 3ware driver translation table */
176 static unsigned char sense_table[][4] = {
178 {0xd1, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
180 {0xd0, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
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
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
192 {0x02, HARDWARE_ERROR, 0x00, 0x00}, // Track 0 not found Hardware error
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
198 {0x10, ABORTED_COMMAND, 0x14, 0x00}, // ID not found Recorded entity not found
200 {0x08, NOT_READY, 0x04, 0x00}, // Media change FIXME: faking offline
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
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
217 cmd->result = SAM_STAT_CHECK_CONDITION;
220 * Is this an error we can process/parse
223 if(drv_stat & ATA_ERR)
224 /* Read the err bits */
225 err = ata_chk_err(qc->ap);
227 /* Display the ATA level error info */
229 printk(KERN_WARNING "ata%u: status=0x%02x { ", qc->ap->id, drv_stat);
233 err = 0; /* Data is not valid in this case */
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 ");
248 printk(KERN_WARNING "ata%u: error=0x%02x { ", qc->ap->id, err);
249 if(err & 0x04) printk("DriveStatusError ");
257 if(err & 0x40) printk("UncorrectableError ");
258 if(err & 0x10) printk("SectorIdNotFound ");
259 if(err & 0x02) printk("TrackZeroNotFound ");
260 if(err & 0x01) printk("AddrMarkNotFound ");
263 /* Should we dump sector info here too ?? */
268 while(sense_table[i][0] != 0xFF)
270 /* Look for best matches first */
271 if((sense_table[i][0] & err) == sense_table[i][0])
274 sb[2] = sense_table[i][1];
276 sb[12] = sense_table[i][2];
277 sb[13] = sense_table[i][3];
282 /* No immediate match */
284 printk(KERN_DEBUG "ata%u: no sense translation for 0x%02x\n", qc->ap->id, err);
287 /* Fall back to interpreting status bits */
288 while(stat_table[i][0] != 0xFF)
290 if(stat_table[i][0] & drv_stat)
293 sb[2] = stat_table[i][1];
295 sb[12] = stat_table[i][2];
296 sb[13] = stat_table[i][3];
302 printk(KERN_ERR "ata%u: called with no error (%02X)!\n", qc->ap->id, drv_stat);
303 /* additional-sense-code[-qualifier] */
306 sb[2] = MEDIUM_ERROR;
308 if (cmd->sc_data_direction == SCSI_DATA_READ) {
309 sb[12] = 0x11; /* "unrecovered read error" */
312 sb[12] = 0x0C; /* "write error - */
313 sb[13] = 0x02; /* auto-reallocation failed" */
318 * ata_scsi_slave_config - Set SCSI device attributes
319 * @sdev: SCSI device to examine
321 * This is called before we actually start reading
322 * and writing to the device, to configure certain
323 * SCSI mid-layer behaviors.
326 * Defined by SCSI layer. We don't really care.
329 int ata_scsi_slave_config(struct scsi_device *sdev)
331 sdev->use_10_for_rw = 1;
332 sdev->use_10_for_ms = 1;
334 blk_queue_max_phys_segments(sdev->request_queue, LIBATA_MAX_PRD);
336 if (sdev->id < ATA_MAX_DEVICES) {
338 struct ata_device *dev;
340 ap = (struct ata_port *) &sdev->host->hostdata[0];
341 dev = &ap->device[sdev->id];
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.
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);
355 return 0; /* scsi layer doesn't check return value, sigh */
359 * ata_scsi_error - SCSI layer error handler callback
360 * @host: SCSI host on which error occurred
362 * Handles SCSI-layer-thrown error events.
365 * Inherited from SCSI layer (none, can sleep)
371 int ata_scsi_error(struct Scsi_Host *host)
377 ap = (struct ata_port *) &host->hostdata[0];
378 ap->ops->eng_timeout(ap);
380 /* TODO: this is per-command; when queueing is supported
381 * this code will either change or move to a more
391 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
392 * @qc: Storage for translated ATA taskfile
393 * @scsicmd: SCSI command to translate (ignored)
395 * Sets up an ATA taskfile to issue FLUSH CACHE or
399 * spin_lock_irqsave(host_set lock)
402 * Zero on success, non-zero on error.
405 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
407 struct ata_taskfile *tf = &qc->tf;
409 tf->flags |= ATA_TFLAG_DEVICE;
410 tf->protocol = ATA_PROT_NODATA;
412 if ((tf->flags & ATA_TFLAG_LBA48) &&
413 (ata_id_has_flush_ext(qc->dev->id)))
414 tf->command = ATA_CMD_FLUSH_EXT;
416 tf->command = ATA_CMD_FLUSH;
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
426 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
429 * spin_lock_irqsave(host_set lock)
432 * Zero on success, non-zero on error.
435 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
437 struct ata_taskfile *tf = &qc->tf;
438 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
439 u64 dev_sectors = qc->dev->n_sectors;
443 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
444 tf->protocol = ATA_PROT_NODATA;
445 tf->device |= ATA_LBA;
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]);
453 n_sect |= ((u32)scsicmd[7]) << 8;
454 n_sect |= ((u32)scsicmd[8]);
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]);
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]);
478 if (sect >= dev_sectors)
480 if ((sect + n_sect) > dev_sectors)
483 if (n_sect > (64 * 1024))
491 tf->command = ATA_CMD_VERIFY_EXT;
493 tf->hob_nsect = (n_sect >> 8) & 0xff;
495 tf->hob_lbah = (sect >> 40) & 0xff;
496 tf->hob_lbam = (sect >> 32) & 0xff;
497 tf->hob_lbal = (sect >> 24) & 0xff;
499 tf->command = ATA_CMD_VERIFY;
501 tf->device |= (sect >> 24) & 0xf;
504 tf->nsect = n_sect & 0xff;
506 tf->lbah = (sect >> 16) & 0xff;
507 tf->lbam = (sect >> 8) & 0xff;
508 tf->lbal = sect & 0xff;
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
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
523 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
524 * %WRITE_16 are currently supported.
527 * spin_lock_irqsave(host_set lock)
530 * Zero on success, non-zero on error.
533 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
535 struct ata_taskfile *tf = &qc->tf;
536 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
538 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
539 tf->protocol = qc->dev->xfer_protocol;
540 tf->device |= ATA_LBA;
542 if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
543 scsicmd[0] == READ_16) {
544 tf->command = qc->dev->read_cmd;
546 tf->command = qc->dev->write_cmd;
547 tf->flags |= ATA_TFLAG_WRITE;
550 if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
552 tf->hob_nsect = scsicmd[7];
553 tf->hob_lbal = scsicmd[2];
555 qc->nsect = ((unsigned int)scsicmd[7] << 8) |
558 /* if we don't support LBA48 addressing, the request
559 * -may- be too large. */
560 if ((scsicmd[2] & 0xf0) || scsicmd[7])
563 /* stores LBA27:24 in lower 4 bits of device reg */
564 tf->device |= scsicmd[2];
566 qc->nsect = scsicmd[8];
569 tf->nsect = scsicmd[8];
570 tf->lbal = scsicmd[5];
571 tf->lbam = scsicmd[4];
572 tf->lbah = scsicmd[3];
574 VPRINTK("ten-byte command\n");
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 */
584 VPRINTK("six-byte command\n");
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])
594 tf->hob_nsect = scsicmd[12];
595 tf->hob_lbal = scsicmd[6];
596 tf->hob_lbam = scsicmd[5];
597 tf->hob_lbah = scsicmd[4];
599 qc->nsect = ((unsigned int)scsicmd[12] << 8) |
602 /* once again, filter out impossible non-zero values */
603 if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
607 /* stores LBA27:24 in lower 4 bits of device reg */
608 tf->device |= scsicmd[6];
610 qc->nsect = scsicmd[13];
613 tf->nsect = scsicmd[13];
614 tf->lbal = scsicmd[9];
615 tf->lbam = scsicmd[8];
616 tf->lbah = scsicmd[7];
618 VPRINTK("sixteen-byte command\n");
622 DPRINTK("no-byte command\n");
626 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
628 struct scsi_cmnd *cmd = qc->scsicmd;
630 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
631 ata_to_sense_error(qc, drv_stat);
633 cmd->result = SAM_STAT_GOOD;
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
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.
652 * This function sets up an ata_queued_cmd structure for the
653 * SCSI command, and sends that ata_queued_cmd to the hardware.
656 * spin_lock_irqsave(host_set lock)
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)
664 struct ata_queued_cmd *qc;
665 u8 *scsicmd = cmd->cmnd;
669 qc = ata_scsi_qc_new(ap, dev, cmd, done);
673 /* data is present; dma-map it */
674 if (cmd->sc_data_direction == SCSI_DATA_READ ||
675 cmd->sc_data_direction == SCSI_DATA_WRITE) {
676 if (unlikely(cmd->request_bufflen < 1)) {
677 printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
683 ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
685 ata_sg_init_one(qc, cmd->request_buffer,
686 cmd->request_bufflen);
688 qc->dma_dir = cmd->sc_data_direction;
691 qc->complete_fn = ata_scsi_qc_complete;
693 if (xlat_func(qc, scsicmd))
696 /* select device, send command to hardware */
697 if (ata_qc_issue(qc))
705 ata_bad_cdb(cmd, done);
706 DPRINTK("EXIT - badcmd\n");
710 * ata_scsi_rbuf_get - Map response buffer.
711 * @cmd: SCSI command containing buffer to be mapped.
712 * @buf_out: Pointer to mapped area.
714 * Maps buffer contained within SCSI command @cmd.
717 * spin_lock_irqsave(host_set lock)
720 * Length of response buffer.
723 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
729 struct scatterlist *sg;
731 sg = (struct scatterlist *) cmd->request_buffer;
732 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
735 buf = cmd->request_buffer;
736 buflen = cmd->request_bufflen;
744 * ata_scsi_rbuf_put - Unmap response buffer.
745 * @cmd: SCSI command containing buffer to be unmapped.
746 * @buf: buffer to unmap
748 * Unmaps response buffer contained within @cmd.
751 * spin_lock_irqsave(host_set lock)
754 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
757 struct scatterlist *sg;
759 sg = (struct scatterlist *) cmd->request_buffer;
760 kunmap_atomic(buf - sg->offset, KM_USER0);
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
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.
776 * spin_lock_irqsave(host_set lock)
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))
784 unsigned int buflen, rc;
785 struct scsi_cmnd *cmd = args->cmd;
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);
793 ata_bad_cdb(cmd, args->done);
795 cmd->result = SAM_STAT_GOOD;
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.
806 * Returns standard device identification data associated
807 * with non-EVPD INQUIRY command output.
810 * spin_lock_irqsave(host_set lock)
813 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
819 0x5, /* claim SPC-3 version compatibility */
824 /* set scsi removeable (RMB) bit per ata bit */
825 if (ata_id_removeable(args->id))
830 memcpy(rbuf, hdr, sizeof(hdr));
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);
841 const u8 versions[] = {
842 0x60, /* SAM-3 (no version claimed) */
845 0x20, /* SBC-2 (no version claimed) */
848 0x60 /* SPC-3 (no version claimed) */
851 memcpy(rbuf + 59, versions, sizeof(versions));
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.
863 * Returns list of inquiry EVPD pages available.
866 * spin_lock_irqsave(host_set lock)
869 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
873 0x00, /* page 0x00, this page */
874 0x80, /* page 0x80, unit serial no page */
875 0x83 /* page 0x83, device ident page */
877 rbuf[3] = sizeof(pages); /* number of supported EVPD pages */
880 memcpy(rbuf + 4, pages, sizeof(pages));
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.
891 * Returns ATA device serial number.
894 * spin_lock_irqsave(host_set lock)
897 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
902 0x80, /* this page code */
904 ATA_SERNO_LEN, /* page len */
906 memcpy(rbuf, hdr, sizeof(hdr));
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);
915 static const char *inq_83_str = "Linux ATA-SCSI simulator";
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.
923 * Returns device identification. Currently hardcoded to
924 * return "Linux ATA-SCSI simulator".
927 * spin_lock_irqsave(host_set lock)
930 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
933 rbuf[1] = 0x83; /* this page code */
934 rbuf[3] = 4 + strlen(inq_83_str); /* page len */
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));
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.
952 * No operation. Simply returns success to caller, to indicate
953 * that the caller should successfully complete this SCSI command.
956 * spin_lock_irqsave(host_set lock)
959 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
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
973 * Store MODE SENSE data on an output buffer.
979 static void ata_msense_push(u8 **ptr_io, const u8 *last,
980 const u8 *buf, unsigned int buflen)
984 if ((ptr + buflen - 1) > last)
987 memcpy(ptr, buf, buflen);
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
1000 * Generate a caching info page, which conditionally indicates
1001 * write caching to the SCSI layer, depending on device
1008 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
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 */
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 */
1023 ata_msense_push(ptr_io, last, page, sizeof(page));
1024 return sizeof(page);
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
1033 * Generate a generic MODE SENSE control mode page.
1039 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1041 const u8 page[] = {0xa, 0xa, 2, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1043 ata_msense_push(ptr_io, last, page, sizeof(page));
1044 return sizeof(page);
1048 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1049 * @dev: Device associated with this MODE SENSE command
1050 * @ptr_io: (input/output) Location to store more output data
1051 * @last: End of output data buffer
1053 * Generate a generic MODE SENSE r/w error recovery page.
1059 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1062 0x1, /* page code */
1063 0xa, /* page length */
1064 (1 << 7) | (1 << 6), /* note auto r/w reallocation */
1065 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1068 ata_msense_push(ptr_io, last, page, sizeof(page));
1069 return sizeof(page);
1073 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1074 * @args: device IDENTIFY data / SCSI command of interest.
1075 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1076 * @buflen: Response buffer length.
1078 * Simulate MODE SENSE commands.
1081 * spin_lock_irqsave(host_set lock)
1084 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1085 unsigned int buflen)
1087 u8 *scsicmd = args->cmd->cmnd, *p, *last;
1088 unsigned int page_control, six_byte, output_len;
1092 six_byte = (scsicmd[0] == MODE_SENSE);
1094 /* we only support saved and current values (which we treat
1095 * in the same manner)
1097 page_control = scsicmd[2] >> 6;
1098 if ((page_control != 0) && (page_control != 3))
1106 p = rbuf + output_len;
1107 last = rbuf + buflen - 1;
1109 switch(scsicmd[2] & 0x3f) {
1110 case 0x01: /* r/w error recovery */
1111 output_len += ata_msense_rw_recovery(&p, last);
1114 case 0x08: /* caching */
1115 output_len += ata_msense_caching(args->id, &p, last);
1118 case 0x0a: { /* control mode */
1119 output_len += ata_msense_ctl_mode(&p, last);
1123 case 0x3f: /* all pages */
1124 output_len += ata_msense_rw_recovery(&p, last);
1125 output_len += ata_msense_caching(args->id, &p, last);
1126 output_len += ata_msense_ctl_mode(&p, last);
1129 default: /* invalid page code */
1135 rbuf[0] = output_len;
1138 rbuf[0] = output_len >> 8;
1139 rbuf[1] = output_len;
1146 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1147 * @args: device IDENTIFY data / SCSI command of interest.
1148 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1149 * @buflen: Response buffer length.
1151 * Simulate READ CAPACITY commands.
1154 * spin_lock_irqsave(host_set lock)
1157 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1158 unsigned int buflen)
1165 if (ata_id_has_lba48(args->id))
1166 n_sectors = ata_id_u64(args->id, 100);
1168 n_sectors = ata_id_u32(args->id, 60);
1169 n_sectors--; /* ATA TotalUserSectors - 1 */
1171 tmp = n_sectors; /* note: truncates, if lba48 */
1172 if (args->cmd->cmnd[0] == READ_CAPACITY) {
1173 /* sector count, 32-bit */
1174 rbuf[0] = tmp >> (8 * 3);
1175 rbuf[1] = tmp >> (8 * 2);
1176 rbuf[2] = tmp >> (8 * 1);
1180 tmp = ATA_SECT_SIZE;
1185 /* sector count, 64-bit */
1186 rbuf[2] = n_sectors >> (8 * 7);
1187 rbuf[3] = n_sectors >> (8 * 6);
1188 rbuf[4] = n_sectors >> (8 * 5);
1189 rbuf[5] = n_sectors >> (8 * 4);
1190 rbuf[6] = tmp >> (8 * 3);
1191 rbuf[7] = tmp >> (8 * 2);
1192 rbuf[8] = tmp >> (8 * 1);
1196 tmp = ATA_SECT_SIZE;
1197 rbuf[12] = tmp >> 8;
1205 * ata_scsiop_report_luns - Simulate REPORT LUNS command
1206 * @args: device IDENTIFY data / SCSI command of interest.
1207 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1208 * @buflen: Response buffer length.
1210 * Simulate REPORT LUNS command.
1213 * spin_lock_irqsave(host_set lock)
1216 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1217 unsigned int buflen)
1220 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
1226 * ata_scsi_badcmd - End a SCSI request with an error
1227 * @cmd: SCSI request to be handled
1228 * @done: SCSI command completion function
1229 * @asc: SCSI-defined additional sense code
1230 * @ascq: SCSI-defined additional sense code qualifier
1232 * Helper function that completes a SCSI command with
1233 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1234 * and the specified additional sense codes.
1237 * spin_lock_irqsave(host_set lock)
1240 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1243 cmd->result = SAM_STAT_CHECK_CONDITION;
1245 cmd->sense_buffer[0] = 0x70;
1246 cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1247 cmd->sense_buffer[7] = 14 - 8; /* addnl. sense len. FIXME: correct? */
1248 cmd->sense_buffer[12] = asc;
1249 cmd->sense_buffer[13] = ascq;
1254 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1256 struct scsi_cmnd *cmd = qc->scsicmd;
1258 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1259 DPRINTK("request check condition\n");
1261 cmd->result = SAM_STAT_CHECK_CONDITION;
1267 u8 *scsicmd = cmd->cmnd;
1269 if (scsicmd[0] == INQUIRY) {
1271 unsigned int buflen;
1273 buflen = ata_scsi_rbuf_get(cmd, &buf);
1275 buf[3] = (buf[3] & 0xf0) | 2;
1276 ata_scsi_rbuf_put(cmd, buf);
1278 cmd->result = SAM_STAT_GOOD;
1286 * atapi_xlat - Initialize PACKET taskfile
1287 * @qc: command structure to be initialized
1288 * @scsicmd: SCSI CDB associated with this PACKET command
1291 * spin_lock_irqsave(host_set lock)
1294 * Zero on success, non-zero on failure.
1297 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1299 struct scsi_cmnd *cmd = qc->scsicmd;
1300 struct ata_device *dev = qc->dev;
1301 int using_pio = (dev->flags & ATA_DFLAG_PIO);
1302 int nodata = (cmd->sc_data_direction == SCSI_DATA_NONE);
1305 /* Check whether ATAPI DMA is safe */
1306 if (ata_check_atapi_dma(qc))
1309 memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1311 qc->complete_fn = atapi_qc_complete;
1313 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1314 if (cmd->sc_data_direction == SCSI_DATA_WRITE) {
1315 qc->tf.flags |= ATA_TFLAG_WRITE;
1316 DPRINTK("direction: write\n");
1319 qc->tf.command = ATA_CMD_PACKET;
1321 /* no data, or PIO data xfer */
1322 if (using_pio || nodata) {
1324 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1326 qc->tf.protocol = ATA_PROT_ATAPI;
1327 qc->tf.lbam = (8 * 1024) & 0xff;
1328 qc->tf.lbah = (8 * 1024) >> 8;
1333 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1334 qc->tf.feature |= ATAPI_PKT_DMA;
1336 #ifdef ATAPI_ENABLE_DMADIR
1337 /* some SATA bridges need us to indicate data xfer direction */
1338 if (cmd->sc_data_direction != SCSI_DATA_WRITE)
1339 qc->tf.feature |= ATAPI_DMADIR;
1343 qc->nbytes = cmd->bufflen;
1349 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1350 * @ap: ATA port to which the device is attached
1351 * @scsidev: SCSI device from which we derive the ATA device
1353 * Given various information provided in struct scsi_cmnd,
1354 * map that onto an ATA bus, and using that mapping
1355 * determine which ata_device is associated with the
1356 * SCSI command to be sent.
1359 * spin_lock_irqsave(host_set lock)
1362 * Associated ATA device, or %NULL if not found.
1365 static struct ata_device *
1366 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1368 struct ata_device *dev;
1370 /* skip commands not addressed to targets we simulate */
1371 if (likely(scsidev->id < ATA_MAX_DEVICES))
1372 dev = &ap->device[scsidev->id];
1376 if (unlikely((scsidev->channel != 0) ||
1377 (scsidev->lun != 0)))
1380 if (unlikely(!ata_dev_present(dev)))
1383 #ifndef ATA_ENABLE_ATAPI
1384 if (unlikely(dev->class == ATA_DEV_ATAPI))
1392 * ata_get_xlat_func - check if SCSI to ATA translation is possible
1394 * @cmd: SCSI command opcode to consider
1396 * Look up the SCSI command given, and determine whether the
1397 * SCSI command is to be translated or simulated.
1400 * Pointer to translation function if possible, %NULL if not.
1403 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1413 return ata_scsi_rw_xlat;
1415 case SYNCHRONIZE_CACHE:
1416 if (ata_try_flush_cache(dev))
1417 return ata_scsi_flush_xlat;
1422 return ata_scsi_verify_xlat;
1429 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1430 * @ap: ATA port to which the command was being sent
1431 * @cmd: SCSI command to dump
1433 * Prints the contents of a SCSI command via printk().
1436 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1437 struct scsi_cmnd *cmd)
1440 struct scsi_device *scsidev = cmd->device;
1441 u8 *scsicmd = cmd->cmnd;
1443 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1445 scsidev->channel, scsidev->id, scsidev->lun,
1446 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1447 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1453 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1454 * @cmd: SCSI command to be sent
1455 * @done: Completion function, called when command is complete
1457 * In some cases, this function translates SCSI commands into
1458 * ATA taskfiles, and queues the taskfiles to be sent to
1459 * hardware. In other cases, this function simulates a
1460 * SCSI device by evaluating and responding to certain
1461 * SCSI commands. This creates the overall effect of
1462 * ATA and ATAPI devices appearing as SCSI devices.
1465 * Releases scsi-layer-held lock, and obtains host_set lock.
1471 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1473 struct ata_port *ap;
1474 struct ata_device *dev;
1475 struct scsi_device *scsidev = cmd->device;
1477 ap = (struct ata_port *) &scsidev->host->hostdata[0];
1479 ata_scsi_dump_cdb(ap, cmd);
1481 dev = ata_scsi_find_dev(ap, scsidev);
1482 if (unlikely(!dev)) {
1483 cmd->result = (DID_BAD_TARGET << 16);
1488 if (dev->class == ATA_DEV_ATA) {
1489 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1493 ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1495 ata_scsi_simulate(dev->id, cmd, done);
1497 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1504 * ata_scsi_simulate - simulate SCSI command on ATA device
1505 * @id: current IDENTIFY data for target device.
1506 * @cmd: SCSI command being sent to device.
1507 * @done: SCSI command completion function.
1509 * Interprets and directly executes a select list of SCSI commands
1510 * that can be handled internally.
1513 * spin_lock_irqsave(host_set lock)
1516 void ata_scsi_simulate(u16 *id,
1517 struct scsi_cmnd *cmd,
1518 void (*done)(struct scsi_cmnd *))
1520 struct ata_scsi_args args;
1521 u8 *scsicmd = cmd->cmnd;
1527 switch(scsicmd[0]) {
1528 /* no-op's, complete with success */
1529 case SYNCHRONIZE_CACHE:
1533 case TEST_UNIT_READY:
1534 case FORMAT_UNIT: /* FIXME: correct? */
1535 case SEND_DIAGNOSTIC: /* FIXME: correct? */
1536 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1540 if (scsicmd[1] & 2) /* is CmdDt set? */
1541 ata_bad_cdb(cmd, done);
1542 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
1543 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1544 else if (scsicmd[2] == 0x00)
1545 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1546 else if (scsicmd[2] == 0x80)
1547 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1548 else if (scsicmd[2] == 0x83)
1549 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1551 ata_bad_cdb(cmd, done);
1556 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1559 case MODE_SELECT: /* unconditionally return */
1560 case MODE_SELECT_10: /* bad-field-in-cdb */
1561 ata_bad_cdb(cmd, done);
1565 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1568 case SERVICE_ACTION_IN:
1569 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1570 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1572 ata_bad_cdb(cmd, done);
1576 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1579 /* mandantory commands we haven't implemented yet */
1582 /* all other commands */
1584 ata_bad_scsiop(cmd, done);