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 == DMA_FROM_DEVICE) {
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)) {
351 * do not overwrite sdev->host->max_sectors, since
352 * other drives on this host may not support LBA48
354 blk_queue_max_sectors(sdev->request_queue, 2048);
358 return 0; /* scsi layer doesn't check return value, sigh */
362 * ata_scsi_error - SCSI layer error handler callback
363 * @host: SCSI host on which error occurred
365 * Handles SCSI-layer-thrown error events.
368 * Inherited from SCSI layer (none, can sleep)
374 int ata_scsi_error(struct Scsi_Host *host)
380 ap = (struct ata_port *) &host->hostdata[0];
381 ap->ops->eng_timeout(ap);
383 /* TODO: this is per-command; when queueing is supported
384 * this code will either change or move to a more
388 INIT_LIST_HEAD(&host->eh_cmd_q);
395 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
396 * @qc: Storage for translated ATA taskfile
397 * @scsicmd: SCSI command to translate (ignored)
399 * Sets up an ATA taskfile to issue FLUSH CACHE or
403 * spin_lock_irqsave(host_set lock)
406 * Zero on success, non-zero on error.
409 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
411 struct ata_taskfile *tf = &qc->tf;
413 tf->flags |= ATA_TFLAG_DEVICE;
414 tf->protocol = ATA_PROT_NODATA;
416 if ((tf->flags & ATA_TFLAG_LBA48) &&
417 (ata_id_has_flush_ext(qc->dev->id)))
418 tf->command = ATA_CMD_FLUSH_EXT;
420 tf->command = ATA_CMD_FLUSH;
426 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
427 * @qc: Storage for translated ATA taskfile
428 * @scsicmd: SCSI command to translate
430 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
433 * spin_lock_irqsave(host_set lock)
436 * Zero on success, non-zero on error.
439 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
441 struct ata_taskfile *tf = &qc->tf;
442 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
443 u64 dev_sectors = qc->dev->n_sectors;
447 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
448 tf->protocol = ATA_PROT_NODATA;
449 tf->device |= ATA_LBA;
451 if (scsicmd[0] == VERIFY) {
452 sect |= ((u64)scsicmd[2]) << 24;
453 sect |= ((u64)scsicmd[3]) << 16;
454 sect |= ((u64)scsicmd[4]) << 8;
455 sect |= ((u64)scsicmd[5]);
457 n_sect |= ((u32)scsicmd[7]) << 8;
458 n_sect |= ((u32)scsicmd[8]);
461 else if (scsicmd[0] == VERIFY_16) {
462 sect |= ((u64)scsicmd[2]) << 56;
463 sect |= ((u64)scsicmd[3]) << 48;
464 sect |= ((u64)scsicmd[4]) << 40;
465 sect |= ((u64)scsicmd[5]) << 32;
466 sect |= ((u64)scsicmd[6]) << 24;
467 sect |= ((u64)scsicmd[7]) << 16;
468 sect |= ((u64)scsicmd[8]) << 8;
469 sect |= ((u64)scsicmd[9]);
471 n_sect |= ((u32)scsicmd[10]) << 24;
472 n_sect |= ((u32)scsicmd[11]) << 16;
473 n_sect |= ((u32)scsicmd[12]) << 8;
474 n_sect |= ((u32)scsicmd[13]);
482 if (sect >= dev_sectors)
484 if ((sect + n_sect) > dev_sectors)
487 if (n_sect > (64 * 1024))
495 tf->command = ATA_CMD_VERIFY_EXT;
497 tf->hob_nsect = (n_sect >> 8) & 0xff;
499 tf->hob_lbah = (sect >> 40) & 0xff;
500 tf->hob_lbam = (sect >> 32) & 0xff;
501 tf->hob_lbal = (sect >> 24) & 0xff;
503 tf->command = ATA_CMD_VERIFY;
505 tf->device |= (sect >> 24) & 0xf;
508 tf->nsect = n_sect & 0xff;
510 tf->lbah = (sect >> 16) & 0xff;
511 tf->lbam = (sect >> 8) & 0xff;
512 tf->lbal = sect & 0xff;
518 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
519 * @qc: Storage for translated ATA taskfile
520 * @scsicmd: SCSI command to translate
522 * Converts any of six SCSI read/write commands into the
523 * ATA counterpart, including starting sector (LBA),
524 * sector count, and taking into account the device's LBA48
527 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
528 * %WRITE_16 are currently supported.
531 * spin_lock_irqsave(host_set lock)
534 * Zero on success, non-zero on error.
537 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
539 struct ata_taskfile *tf = &qc->tf;
540 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
542 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
543 tf->protocol = qc->dev->xfer_protocol;
544 tf->device |= ATA_LBA;
546 if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
547 scsicmd[0] == READ_16) {
548 tf->command = qc->dev->read_cmd;
550 tf->command = qc->dev->write_cmd;
551 tf->flags |= ATA_TFLAG_WRITE;
554 if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
556 tf->hob_nsect = scsicmd[7];
557 tf->hob_lbal = scsicmd[2];
559 qc->nsect = ((unsigned int)scsicmd[7] << 8) |
562 /* if we don't support LBA48 addressing, the request
563 * -may- be too large. */
564 if ((scsicmd[2] & 0xf0) || scsicmd[7])
567 /* stores LBA27:24 in lower 4 bits of device reg */
568 tf->device |= scsicmd[2];
570 qc->nsect = scsicmd[8];
573 tf->nsect = scsicmd[8];
574 tf->lbal = scsicmd[5];
575 tf->lbam = scsicmd[4];
576 tf->lbah = scsicmd[3];
578 VPRINTK("ten-byte command\n");
582 if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
583 qc->nsect = tf->nsect = scsicmd[4];
584 tf->lbal = scsicmd[3];
585 tf->lbam = scsicmd[2];
586 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
588 VPRINTK("six-byte command\n");
592 if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
593 /* rule out impossible LBAs and sector counts */
594 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
598 tf->hob_nsect = scsicmd[12];
599 tf->hob_lbal = scsicmd[6];
600 tf->hob_lbam = scsicmd[5];
601 tf->hob_lbah = scsicmd[4];
603 qc->nsect = ((unsigned int)scsicmd[12] << 8) |
606 /* once again, filter out impossible non-zero values */
607 if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
611 /* stores LBA27:24 in lower 4 bits of device reg */
612 tf->device |= scsicmd[6];
614 qc->nsect = scsicmd[13];
617 tf->nsect = scsicmd[13];
618 tf->lbal = scsicmd[9];
619 tf->lbam = scsicmd[8];
620 tf->lbah = scsicmd[7];
622 VPRINTK("sixteen-byte command\n");
626 DPRINTK("no-byte command\n");
630 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
632 struct scsi_cmnd *cmd = qc->scsicmd;
634 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
635 ata_to_sense_error(qc, drv_stat);
637 cmd->result = SAM_STAT_GOOD;
645 * ata_scsi_translate - Translate then issue SCSI command to ATA device
646 * @ap: ATA port to which the command is addressed
647 * @dev: ATA device to which the command is addressed
648 * @cmd: SCSI command to execute
649 * @done: SCSI command completion function
650 * @xlat_func: Actor which translates @cmd to an ATA taskfile
652 * Our ->queuecommand() function has decided that the SCSI
653 * command issued can be directly translated into an ATA
654 * command, rather than handled internally.
656 * This function sets up an ata_queued_cmd structure for the
657 * SCSI command, and sends that ata_queued_cmd to the hardware.
660 * spin_lock_irqsave(host_set lock)
663 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
664 struct scsi_cmnd *cmd,
665 void (*done)(struct scsi_cmnd *),
666 ata_xlat_func_t xlat_func)
668 struct ata_queued_cmd *qc;
669 u8 *scsicmd = cmd->cmnd;
673 qc = ata_scsi_qc_new(ap, dev, cmd, done);
677 /* data is present; dma-map it */
678 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
679 cmd->sc_data_direction == DMA_TO_DEVICE) {
680 if (unlikely(cmd->request_bufflen < 1)) {
681 printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
687 ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
689 ata_sg_init_one(qc, cmd->request_buffer,
690 cmd->request_bufflen);
692 qc->dma_dir = cmd->sc_data_direction;
695 qc->complete_fn = ata_scsi_qc_complete;
697 if (xlat_func(qc, scsicmd))
700 /* select device, send command to hardware */
701 if (ata_qc_issue(qc))
709 ata_bad_cdb(cmd, done);
710 DPRINTK("EXIT - badcmd\n");
714 * ata_scsi_rbuf_get - Map response buffer.
715 * @cmd: SCSI command containing buffer to be mapped.
716 * @buf_out: Pointer to mapped area.
718 * Maps buffer contained within SCSI command @cmd.
721 * spin_lock_irqsave(host_set lock)
724 * Length of response buffer.
727 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
733 struct scatterlist *sg;
735 sg = (struct scatterlist *) cmd->request_buffer;
736 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
739 buf = cmd->request_buffer;
740 buflen = cmd->request_bufflen;
748 * ata_scsi_rbuf_put - Unmap response buffer.
749 * @cmd: SCSI command containing buffer to be unmapped.
750 * @buf: buffer to unmap
752 * Unmaps response buffer contained within @cmd.
755 * spin_lock_irqsave(host_set lock)
758 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
761 struct scatterlist *sg;
763 sg = (struct scatterlist *) cmd->request_buffer;
764 kunmap_atomic(buf - sg->offset, KM_USER0);
769 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
770 * @args: device IDENTIFY data / SCSI command of interest.
771 * @actor: Callback hook for desired SCSI command simulator
773 * Takes care of the hard work of simulating a SCSI command...
774 * Mapping the response buffer, calling the command's handler,
775 * and handling the handler's return value. This return value
776 * indicates whether the handler wishes the SCSI command to be
777 * completed successfully, or not.
780 * spin_lock_irqsave(host_set lock)
783 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
784 unsigned int (*actor) (struct ata_scsi_args *args,
785 u8 *rbuf, unsigned int buflen))
788 unsigned int buflen, rc;
789 struct scsi_cmnd *cmd = args->cmd;
791 buflen = ata_scsi_rbuf_get(cmd, &rbuf);
792 memset(rbuf, 0, buflen);
793 rc = actor(args, rbuf, buflen);
794 ata_scsi_rbuf_put(cmd, rbuf);
797 ata_bad_cdb(cmd, args->done);
799 cmd->result = SAM_STAT_GOOD;
805 * ata_scsiop_inq_std - Simulate INQUIRY command
806 * @args: device IDENTIFY data / SCSI command of interest.
807 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
808 * @buflen: Response buffer length.
810 * Returns standard device identification data associated
811 * with non-EVPD INQUIRY command output.
814 * spin_lock_irqsave(host_set lock)
817 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
823 0x5, /* claim SPC-3 version compatibility */
828 /* set scsi removeable (RMB) bit per ata bit */
829 if (ata_id_removeable(args->id))
834 memcpy(rbuf, hdr, sizeof(hdr));
837 memcpy(&rbuf[8], "ATA ", 8);
838 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
839 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
840 if (rbuf[32] == 0 || rbuf[32] == ' ')
841 memcpy(&rbuf[32], "n/a ", 4);
845 const u8 versions[] = {
846 0x60, /* SAM-3 (no version claimed) */
849 0x20, /* SBC-2 (no version claimed) */
852 0x60 /* SPC-3 (no version claimed) */
855 memcpy(rbuf + 59, versions, sizeof(versions));
862 * ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
863 * @args: device IDENTIFY data / SCSI command of interest.
864 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
865 * @buflen: Response buffer length.
867 * Returns list of inquiry EVPD pages available.
870 * spin_lock_irqsave(host_set lock)
873 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
877 0x00, /* page 0x00, this page */
878 0x80, /* page 0x80, unit serial no page */
879 0x83 /* page 0x83, device ident page */
881 rbuf[3] = sizeof(pages); /* number of supported EVPD pages */
884 memcpy(rbuf + 4, pages, sizeof(pages));
890 * ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
891 * @args: device IDENTIFY data / SCSI command of interest.
892 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
893 * @buflen: Response buffer length.
895 * Returns ATA device serial number.
898 * spin_lock_irqsave(host_set lock)
901 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
906 0x80, /* this page code */
908 ATA_SERNO_LEN, /* page len */
910 memcpy(rbuf, hdr, sizeof(hdr));
912 if (buflen > (ATA_SERNO_LEN + 4 - 1))
913 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
914 ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
919 static const char *inq_83_str = "Linux ATA-SCSI simulator";
922 * ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
923 * @args: device IDENTIFY data / SCSI command of interest.
924 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
925 * @buflen: Response buffer length.
927 * Returns device identification. Currently hardcoded to
928 * return "Linux ATA-SCSI simulator".
931 * spin_lock_irqsave(host_set lock)
934 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
937 rbuf[1] = 0x83; /* this page code */
938 rbuf[3] = 4 + strlen(inq_83_str); /* page len */
940 /* our one and only identification descriptor (vendor-specific) */
941 if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
942 rbuf[4 + 0] = 2; /* code set: ASCII */
943 rbuf[4 + 3] = strlen(inq_83_str);
944 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
951 * ata_scsiop_noop - Command handler that simply returns success.
952 * @args: device IDENTIFY data / SCSI command of interest.
953 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
954 * @buflen: Response buffer length.
956 * No operation. Simply returns success to caller, to indicate
957 * that the caller should successfully complete this SCSI command.
960 * spin_lock_irqsave(host_set lock)
963 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
971 * ata_msense_push - Push data onto MODE SENSE data output buffer
972 * @ptr_io: (input/output) Location to store more output data
973 * @last: End of output data buffer
974 * @buf: Pointer to BLOB being added to output buffer
975 * @buflen: Length of BLOB
977 * Store MODE SENSE data on an output buffer.
983 static void ata_msense_push(u8 **ptr_io, const u8 *last,
984 const u8 *buf, unsigned int buflen)
988 if ((ptr + buflen - 1) > last)
991 memcpy(ptr, buf, buflen);
999 * ata_msense_caching - Simulate MODE SENSE caching info page
1000 * @id: device IDENTIFY data
1001 * @ptr_io: (input/output) Location to store more output data
1002 * @last: End of output data buffer
1004 * Generate a caching info page, which conditionally indicates
1005 * write caching to the SCSI layer, depending on device
1012 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1016 0x8, /* page code */
1017 0x12, /* page length */
1018 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 zeroes */
1019 0, 0, 0, 0, 0, 0, 0, 0 /* 8 zeroes */
1022 if (ata_id_wcache_enabled(id))
1023 page[2] |= (1 << 2); /* write cache enable */
1024 if (!ata_id_rahead_enabled(id))
1025 page[12] |= (1 << 5); /* disable read ahead */
1027 ata_msense_push(ptr_io, last, page, sizeof(page));
1028 return sizeof(page);
1032 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1033 * @dev: Device associated with this MODE SENSE command
1034 * @ptr_io: (input/output) Location to store more output data
1035 * @last: End of output data buffer
1037 * Generate a generic MODE SENSE control mode page.
1043 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1045 const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1047 /* byte 2: set the descriptor format sense data bit (bit 2)
1048 * since we need to support returning this format for SAT
1049 * commands and any SCSI commands against a 48b LBA device.
1052 ata_msense_push(ptr_io, last, page, sizeof(page));
1053 return sizeof(page);
1057 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1058 * @dev: Device associated with this MODE SENSE command
1059 * @ptr_io: (input/output) Location to store more output data
1060 * @last: End of output data buffer
1062 * Generate a generic MODE SENSE r/w error recovery page.
1068 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1071 0x1, /* page code */
1072 0xa, /* page length */
1073 (1 << 7) | (1 << 6), /* note auto r/w reallocation */
1074 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1077 ata_msense_push(ptr_io, last, page, sizeof(page));
1078 return sizeof(page);
1082 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1083 * @args: device IDENTIFY data / SCSI command of interest.
1084 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1085 * @buflen: Response buffer length.
1087 * Simulate MODE SENSE commands.
1090 * spin_lock_irqsave(host_set lock)
1093 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1094 unsigned int buflen)
1096 u8 *scsicmd = args->cmd->cmnd, *p, *last;
1097 unsigned int page_control, six_byte, output_len;
1101 six_byte = (scsicmd[0] == MODE_SENSE);
1103 /* we only support saved and current values (which we treat
1104 * in the same manner)
1106 page_control = scsicmd[2] >> 6;
1107 if ((page_control != 0) && (page_control != 3))
1115 p = rbuf + output_len;
1116 last = rbuf + buflen - 1;
1118 switch(scsicmd[2] & 0x3f) {
1119 case 0x01: /* r/w error recovery */
1120 output_len += ata_msense_rw_recovery(&p, last);
1123 case 0x08: /* caching */
1124 output_len += ata_msense_caching(args->id, &p, last);
1127 case 0x0a: { /* control mode */
1128 output_len += ata_msense_ctl_mode(&p, last);
1132 case 0x3f: /* all pages */
1133 output_len += ata_msense_rw_recovery(&p, last);
1134 output_len += ata_msense_caching(args->id, &p, last);
1135 output_len += ata_msense_ctl_mode(&p, last);
1138 default: /* invalid page code */
1144 rbuf[0] = output_len;
1147 rbuf[0] = output_len >> 8;
1148 rbuf[1] = output_len;
1155 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1156 * @args: device IDENTIFY data / SCSI command of interest.
1157 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1158 * @buflen: Response buffer length.
1160 * Simulate READ CAPACITY commands.
1163 * spin_lock_irqsave(host_set lock)
1166 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1167 unsigned int buflen)
1174 if (ata_id_has_lba48(args->id))
1175 n_sectors = ata_id_u64(args->id, 100);
1177 n_sectors = ata_id_u32(args->id, 60);
1178 n_sectors--; /* ATA TotalUserSectors - 1 */
1180 if (args->cmd->cmnd[0] == READ_CAPACITY) {
1181 if( n_sectors >= 0xffffffffULL )
1182 tmp = 0xffffffff ; /* Return max count on overflow */
1186 /* sector count, 32-bit */
1187 rbuf[0] = tmp >> (8 * 3);
1188 rbuf[1] = tmp >> (8 * 2);
1189 rbuf[2] = tmp >> (8 * 1);
1193 tmp = ATA_SECT_SIZE;
1198 /* sector count, 64-bit */
1199 tmp = n_sectors >> (8 * 4);
1200 rbuf[2] = tmp >> (8 * 3);
1201 rbuf[3] = tmp >> (8 * 2);
1202 rbuf[4] = tmp >> (8 * 1);
1205 rbuf[6] = tmp >> (8 * 3);
1206 rbuf[7] = tmp >> (8 * 2);
1207 rbuf[8] = tmp >> (8 * 1);
1211 tmp = ATA_SECT_SIZE;
1212 rbuf[12] = tmp >> 8;
1220 * ata_scsiop_report_luns - Simulate REPORT LUNS command
1221 * @args: device IDENTIFY data / SCSI command of interest.
1222 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1223 * @buflen: Response buffer length.
1225 * Simulate REPORT LUNS command.
1228 * spin_lock_irqsave(host_set lock)
1231 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1232 unsigned int buflen)
1235 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
1241 * ata_scsi_badcmd - End a SCSI request with an error
1242 * @cmd: SCSI request to be handled
1243 * @done: SCSI command completion function
1244 * @asc: SCSI-defined additional sense code
1245 * @ascq: SCSI-defined additional sense code qualifier
1247 * Helper function that completes a SCSI command with
1248 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1249 * and the specified additional sense codes.
1252 * spin_lock_irqsave(host_set lock)
1255 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1258 cmd->result = SAM_STAT_CHECK_CONDITION;
1260 cmd->sense_buffer[0] = 0x70;
1261 cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1262 cmd->sense_buffer[7] = 14 - 8; /* addnl. sense len. FIXME: correct? */
1263 cmd->sense_buffer[12] = asc;
1264 cmd->sense_buffer[13] = ascq;
1269 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1271 struct scsi_cmnd *cmd = qc->scsicmd;
1273 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1274 DPRINTK("request check condition\n");
1276 cmd->result = SAM_STAT_CHECK_CONDITION;
1282 u8 *scsicmd = cmd->cmnd;
1284 if (scsicmd[0] == INQUIRY) {
1286 unsigned int buflen;
1288 buflen = ata_scsi_rbuf_get(cmd, &buf);
1290 buf[3] = (buf[3] & 0xf0) | 2;
1291 ata_scsi_rbuf_put(cmd, buf);
1293 cmd->result = SAM_STAT_GOOD;
1301 * atapi_xlat - Initialize PACKET taskfile
1302 * @qc: command structure to be initialized
1303 * @scsicmd: SCSI CDB associated with this PACKET command
1306 * spin_lock_irqsave(host_set lock)
1309 * Zero on success, non-zero on failure.
1312 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1314 struct scsi_cmnd *cmd = qc->scsicmd;
1315 struct ata_device *dev = qc->dev;
1316 int using_pio = (dev->flags & ATA_DFLAG_PIO);
1317 int nodata = (cmd->sc_data_direction == DMA_NONE);
1320 /* Check whether ATAPI DMA is safe */
1321 if (ata_check_atapi_dma(qc))
1324 memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1326 qc->complete_fn = atapi_qc_complete;
1328 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1329 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1330 qc->tf.flags |= ATA_TFLAG_WRITE;
1331 DPRINTK("direction: write\n");
1334 qc->tf.command = ATA_CMD_PACKET;
1336 /* no data, or PIO data xfer */
1337 if (using_pio || nodata) {
1339 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1341 qc->tf.protocol = ATA_PROT_ATAPI;
1342 qc->tf.lbam = (8 * 1024) & 0xff;
1343 qc->tf.lbah = (8 * 1024) >> 8;
1348 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1349 qc->tf.feature |= ATAPI_PKT_DMA;
1351 #ifdef ATAPI_ENABLE_DMADIR
1352 /* some SATA bridges need us to indicate data xfer direction */
1353 if (cmd->sc_data_direction != DMA_TO_DEVICE)
1354 qc->tf.feature |= ATAPI_DMADIR;
1358 qc->nbytes = cmd->bufflen;
1364 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1365 * @ap: ATA port to which the device is attached
1366 * @scsidev: SCSI device from which we derive the ATA device
1368 * Given various information provided in struct scsi_cmnd,
1369 * map that onto an ATA bus, and using that mapping
1370 * determine which ata_device is associated with the
1371 * SCSI command to be sent.
1374 * spin_lock_irqsave(host_set lock)
1377 * Associated ATA device, or %NULL if not found.
1380 static struct ata_device *
1381 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1383 struct ata_device *dev;
1385 /* skip commands not addressed to targets we simulate */
1386 if (likely(scsidev->id < ATA_MAX_DEVICES))
1387 dev = &ap->device[scsidev->id];
1391 if (unlikely((scsidev->channel != 0) ||
1392 (scsidev->lun != 0)))
1395 if (unlikely(!ata_dev_present(dev)))
1398 #ifndef ATA_ENABLE_ATAPI
1399 if (unlikely(dev->class == ATA_DEV_ATAPI))
1407 * ata_get_xlat_func - check if SCSI to ATA translation is possible
1409 * @cmd: SCSI command opcode to consider
1411 * Look up the SCSI command given, and determine whether the
1412 * SCSI command is to be translated or simulated.
1415 * Pointer to translation function if possible, %NULL if not.
1418 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1428 return ata_scsi_rw_xlat;
1430 case SYNCHRONIZE_CACHE:
1431 if (ata_try_flush_cache(dev))
1432 return ata_scsi_flush_xlat;
1437 return ata_scsi_verify_xlat;
1444 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1445 * @ap: ATA port to which the command was being sent
1446 * @cmd: SCSI command to dump
1448 * Prints the contents of a SCSI command via printk().
1451 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1452 struct scsi_cmnd *cmd)
1455 struct scsi_device *scsidev = cmd->device;
1456 u8 *scsicmd = cmd->cmnd;
1458 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1460 scsidev->channel, scsidev->id, scsidev->lun,
1461 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1462 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1468 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1469 * @cmd: SCSI command to be sent
1470 * @done: Completion function, called when command is complete
1472 * In some cases, this function translates SCSI commands into
1473 * ATA taskfiles, and queues the taskfiles to be sent to
1474 * hardware. In other cases, this function simulates a
1475 * SCSI device by evaluating and responding to certain
1476 * SCSI commands. This creates the overall effect of
1477 * ATA and ATAPI devices appearing as SCSI devices.
1480 * Releases scsi-layer-held lock, and obtains host_set lock.
1486 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1488 struct ata_port *ap;
1489 struct ata_device *dev;
1490 struct scsi_device *scsidev = cmd->device;
1492 ap = (struct ata_port *) &scsidev->host->hostdata[0];
1494 ata_scsi_dump_cdb(ap, cmd);
1496 dev = ata_scsi_find_dev(ap, scsidev);
1497 if (unlikely(!dev)) {
1498 cmd->result = (DID_BAD_TARGET << 16);
1503 if (dev->class == ATA_DEV_ATA) {
1504 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1508 ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1510 ata_scsi_simulate(dev->id, cmd, done);
1512 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1519 * ata_scsi_simulate - simulate SCSI command on ATA device
1520 * @id: current IDENTIFY data for target device.
1521 * @cmd: SCSI command being sent to device.
1522 * @done: SCSI command completion function.
1524 * Interprets and directly executes a select list of SCSI commands
1525 * that can be handled internally.
1528 * spin_lock_irqsave(host_set lock)
1531 void ata_scsi_simulate(u16 *id,
1532 struct scsi_cmnd *cmd,
1533 void (*done)(struct scsi_cmnd *))
1535 struct ata_scsi_args args;
1536 u8 *scsicmd = cmd->cmnd;
1542 switch(scsicmd[0]) {
1543 /* no-op's, complete with success */
1544 case SYNCHRONIZE_CACHE:
1548 case TEST_UNIT_READY:
1549 case FORMAT_UNIT: /* FIXME: correct? */
1550 case SEND_DIAGNOSTIC: /* FIXME: correct? */
1551 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1555 if (scsicmd[1] & 2) /* is CmdDt set? */
1556 ata_bad_cdb(cmd, done);
1557 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
1558 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1559 else if (scsicmd[2] == 0x00)
1560 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1561 else if (scsicmd[2] == 0x80)
1562 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1563 else if (scsicmd[2] == 0x83)
1564 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1566 ata_bad_cdb(cmd, done);
1571 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1574 case MODE_SELECT: /* unconditionally return */
1575 case MODE_SELECT_10: /* bad-field-in-cdb */
1576 ata_bad_cdb(cmd, done);
1580 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1583 case SERVICE_ACTION_IN:
1584 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1585 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1587 ata_bad_cdb(cmd, done);
1591 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1594 /* mandantory commands we haven't implemented yet */
1597 /* all other commands */
1599 ata_bad_scsiop(cmd, done);