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 void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
38 struct scsi_cmnd *cmd,
39 void (*done)(struct scsi_cmnd *));
40 static struct ata_device *
41 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
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
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.
57 * Defined by the SCSI layer. We don't really care.
62 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
63 sector_t capacity, int geom[])
67 sector_div(capacity, 255*63);
73 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
76 struct ata_device *dev;
77 int val = -EINVAL, rc = -EINVAL;
79 ap = (struct ata_port *) &scsidev->host->hostdata[0];
83 dev = ata_scsi_find_dev(ap, scsidev);
90 case ATA_IOC_GET_IO32:
92 if (copy_to_user(arg, &val, 1))
96 case ATA_IOC_SET_IO32:
97 val = (unsigned long) arg;
112 * ata_scsi_qc_new - acquire new ata_queued_cmd reference
113 * @ap: ATA port to which the new command is attached
114 * @dev: ATA device to which the new command is attached
115 * @cmd: SCSI command that originated this ATA command
116 * @done: SCSI command completion function
118 * Obtain a reference to an unused ata_queued_cmd structure,
119 * which is the basic libata structure representing a single
120 * ATA command sent to the hardware.
122 * If a command was available, fill in the SCSI-specific
123 * portions of the structure with information on the
127 * spin_lock_irqsave(host_set lock)
130 * Command allocated, or %NULL if none available.
132 struct ata_queued_cmd *ata_scsi_qc_new(struct ata_port *ap,
133 struct ata_device *dev,
134 struct scsi_cmnd *cmd,
135 void (*done)(struct scsi_cmnd *))
137 struct ata_queued_cmd *qc;
139 qc = ata_qc_new_init(ap, dev);
145 qc->sg = (struct scatterlist *) cmd->request_buffer;
146 qc->n_elem = cmd->use_sg;
152 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
160 * ata_to_sense_error - convert ATA error to SCSI error
161 * @qc: Command that we are erroring out
163 * Converts an ATA error into a SCSI error. While we are at it
164 * we decode and dump the ATA error for the user so that they
165 * have some idea what really happened at the non make-believe
169 * spin_lock_irqsave(host_set lock)
172 void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
174 struct scsi_cmnd *cmd = qc->scsicmd;
176 unsigned char *sb = cmd->sense_buffer;
177 /* Based on the 3ware driver translation table */
178 static unsigned char sense_table[][4] = {
180 {0xd1, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
182 {0xd0, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
184 {0x61, HARDWARE_ERROR, 0x00, 0x00}, // Device fault Hardware error
185 /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
186 {0x84, ABORTED_COMMAND, 0x47, 0x00}, // Data CRC error SCSI parity error
187 /* MC|ID|ABRT|TRK0|MARK */
188 {0x37, NOT_READY, 0x04, 0x00}, // Unit offline Not ready
190 {0x09, NOT_READY, 0x04, 0x00}, // Unrecovered disk error Not ready
191 /* Bad address mark */
192 {0x01, MEDIUM_ERROR, 0x13, 0x00}, // Address mark not found Address mark not found for data field
194 {0x02, HARDWARE_ERROR, 0x00, 0x00}, // Track 0 not found Hardware error
196 {0x04, ABORTED_COMMAND, 0x00, 0x00}, // Aborted command Aborted command
197 /* Media change request */
198 {0x08, NOT_READY, 0x04, 0x00}, // Media change request FIXME: faking offline
200 {0x10, ABORTED_COMMAND, 0x14, 0x00}, // ID not found Recorded entity not found
202 {0x08, NOT_READY, 0x04, 0x00}, // Media change FIXME: faking offline
204 {0x40, MEDIUM_ERROR, 0x11, 0x04}, // Uncorrectable ECC error Unrecovered read error
205 /* BBD - block marked bad */
206 {0x80, MEDIUM_ERROR, 0x11, 0x04}, // Block marked bad Medium error, unrecovered read error
207 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
209 static unsigned char stat_table[][4] = {
210 /* Must be first because BUSY means no other bits valid */
211 {0x80, ABORTED_COMMAND, 0x47, 0x00}, // Busy, fake parity for now
212 {0x20, HARDWARE_ERROR, 0x00, 0x00}, // Device fault
213 {0x08, ABORTED_COMMAND, 0x47, 0x00}, // Timed out in xfer, fake parity for now
214 {0x04, RECOVERED_ERROR, 0x11, 0x00}, // Recovered ECC error Medium error, recovered
215 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
219 cmd->result = SAM_STAT_CHECK_CONDITION;
222 * Is this an error we can process/parse
225 if(drv_stat & ATA_ERR)
226 /* Read the err bits */
227 err = ata_chk_err(qc->ap);
229 /* Display the ATA level error info */
231 printk(KERN_WARNING "ata%u: status=0x%02x { ", qc->ap->id, drv_stat);
235 err = 0; /* Data is not valid in this case */
238 if(drv_stat & 0x40) printk("DriveReady ");
239 if(drv_stat & 0x20) printk("DeviceFault ");
240 if(drv_stat & 0x10) printk("SeekComplete ");
241 if(drv_stat & 0x08) printk("DataRequest ");
242 if(drv_stat & 0x04) printk("CorrectedError ");
243 if(drv_stat & 0x02) printk("Index ");
244 if(drv_stat & 0x01) printk("Error ");
250 printk(KERN_WARNING "ata%u: error=0x%02x { ", qc->ap->id, err);
251 if(err & 0x04) printk("DriveStatusError ");
259 if(err & 0x40) printk("UncorrectableError ");
260 if(err & 0x10) printk("SectorIdNotFound ");
261 if(err & 0x02) printk("TrackZeroNotFound ");
262 if(err & 0x01) printk("AddrMarkNotFound ");
265 /* Should we dump sector info here too ?? */
270 while(sense_table[i][0] != 0xFF)
272 /* Look for best matches first */
273 if((sense_table[i][0] & err) == sense_table[i][0])
276 sb[2] = sense_table[i][1];
278 sb[12] = sense_table[i][2];
279 sb[13] = sense_table[i][3];
284 /* No immediate match */
286 printk(KERN_DEBUG "ata%u: no sense translation for 0x%02x\n", qc->ap->id, err);
288 /* Fall back to interpreting status bits */
289 while(stat_table[i][0] != 0xFF)
291 if(stat_table[i][0] & drv_stat)
294 sb[2] = stat_table[i][1];
296 sb[12] = stat_table[i][2];
297 sb[13] = stat_table[i][3];
303 printk(KERN_ERR "ata%u: called with no error (%02X)!\n", qc->ap->id, drv_stat);
304 /* additional-sense-code[-qualifier] */
307 sb[2] = MEDIUM_ERROR;
309 if (cmd->sc_data_direction == SCSI_DATA_READ) {
310 sb[12] = 0x11; /* "unrecovered read error" */
313 sb[12] = 0x0C; /* "write error - */
314 sb[13] = 0x02; /* auto-reallocation failed" */
319 * ata_scsi_slave_config - Set SCSI device attributes
320 * @sdev: SCSI device to examine
322 * This is called before we actually start reading
323 * and writing to the device, to configure certain
324 * SCSI mid-layer behaviors.
327 * Defined by SCSI layer. We don't really care.
330 int ata_scsi_slave_config(struct scsi_device *sdev)
332 sdev->use_10_for_rw = 1;
333 sdev->use_10_for_ms = 1;
335 blk_queue_max_phys_segments(sdev->request_queue, LIBATA_MAX_PRD);
337 if (sdev->id < ATA_MAX_DEVICES) {
339 struct ata_device *dev;
341 ap = (struct ata_port *) &sdev->host->hostdata[0];
342 dev = &ap->device[sdev->id];
344 /* TODO: 1024 is an arbitrary number, not the
345 * hardware maximum. This should be increased to
346 * 65534 when Jens Axboe's patch for dynamically
347 * determining max_sectors is merged.
349 if ((dev->flags & ATA_DFLAG_LBA48) &&
350 ((dev->flags & ATA_DFLAG_LOCK_SECTORS) == 0)) {
351 sdev->host->max_sectors = 2048;
352 blk_queue_max_sectors(sdev->request_queue, 2048);
356 return 0; /* scsi layer doesn't check return value, sigh */
360 * ata_scsi_error - SCSI layer error handler callback
361 * @host: SCSI host on which error occurred
363 * Handles SCSI-layer-thrown error events.
366 * Inherited from SCSI layer (none, can sleep)
372 int ata_scsi_error(struct Scsi_Host *host)
378 ap = (struct ata_port *) &host->hostdata[0];
379 ap->ops->eng_timeout(ap);
381 /* TODO: this is per-command; when queueing is supported
382 * this code will either change or move to a more
392 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
393 * @qc: Storage for translated ATA taskfile
394 * @scsicmd: SCSI command to translate (ignored)
396 * Sets up an ATA taskfile to issue FLUSH CACHE or
400 * spin_lock_irqsave(host_set lock)
403 * Zero on success, non-zero on error.
406 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
408 struct ata_taskfile *tf = &qc->tf;
410 tf->flags |= ATA_TFLAG_DEVICE;
411 tf->protocol = ATA_PROT_NODATA;
413 if ((tf->flags & ATA_TFLAG_LBA48) &&
414 (ata_id_has_flush_ext(qc->dev)))
415 tf->command = ATA_CMD_FLUSH_EXT;
417 tf->command = ATA_CMD_FLUSH;
423 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
424 * @qc: Storage for translated ATA taskfile
425 * @scsicmd: SCSI command to translate
427 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
430 * spin_lock_irqsave(host_set lock)
433 * Zero on success, non-zero on error.
436 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
438 struct ata_taskfile *tf = &qc->tf;
439 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
440 u64 dev_sectors = qc->dev->n_sectors;
444 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
445 tf->protocol = ATA_PROT_NODATA;
446 tf->device |= ATA_LBA;
448 if (scsicmd[0] == VERIFY) {
449 sect |= ((u64)scsicmd[2]) << 24;
450 sect |= ((u64)scsicmd[3]) << 16;
451 sect |= ((u64)scsicmd[4]) << 8;
452 sect |= ((u64)scsicmd[5]);
454 n_sect |= ((u32)scsicmd[7]) << 8;
455 n_sect |= ((u32)scsicmd[8]);
458 else if (scsicmd[0] == VERIFY_16) {
459 sect |= ((u64)scsicmd[2]) << 56;
460 sect |= ((u64)scsicmd[3]) << 48;
461 sect |= ((u64)scsicmd[4]) << 40;
462 sect |= ((u64)scsicmd[5]) << 32;
463 sect |= ((u64)scsicmd[6]) << 24;
464 sect |= ((u64)scsicmd[7]) << 16;
465 sect |= ((u64)scsicmd[8]) << 8;
466 sect |= ((u64)scsicmd[9]);
468 n_sect |= ((u32)scsicmd[10]) << 24;
469 n_sect |= ((u32)scsicmd[11]) << 16;
470 n_sect |= ((u32)scsicmd[12]) << 8;
471 n_sect |= ((u32)scsicmd[13]);
479 if (sect >= dev_sectors)
481 if ((sect + n_sect) > dev_sectors)
484 if (n_sect > (64 * 1024))
492 tf->hob_nsect = (n_sect >> 8) & 0xff;
494 tf->hob_lbah = (sect >> 40) & 0xff;
495 tf->hob_lbam = (sect >> 32) & 0xff;
496 tf->hob_lbal = (sect >> 24) & 0xff;
498 tf->device |= (sect >> 24) & 0xf;
500 tf->nsect = n_sect & 0xff;
502 tf->hob_lbah = (sect >> 16) & 0xff;
503 tf->hob_lbam = (sect >> 8) & 0xff;
504 tf->hob_lbal = sect & 0xff;
510 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
511 * @qc: Storage for translated ATA taskfile
512 * @scsicmd: SCSI command to translate
514 * Converts any of six SCSI read/write commands into the
515 * ATA counterpart, including starting sector (LBA),
516 * sector count, and taking into account the device's LBA48
519 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
520 * %WRITE_16 are currently supported.
523 * spin_lock_irqsave(host_set lock)
526 * Zero on success, non-zero on error.
529 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
531 struct ata_taskfile *tf = &qc->tf;
532 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
534 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
535 tf->protocol = qc->dev->xfer_protocol;
536 tf->device |= ATA_LBA;
538 if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
539 scsicmd[0] == READ_16) {
540 tf->command = qc->dev->read_cmd;
542 tf->command = qc->dev->write_cmd;
543 tf->flags |= ATA_TFLAG_WRITE;
546 if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
548 tf->hob_nsect = scsicmd[7];
549 tf->hob_lbal = scsicmd[2];
551 qc->nsect = ((unsigned int)scsicmd[7] << 8) |
554 /* if we don't support LBA48 addressing, the request
555 * -may- be too large. */
556 if ((scsicmd[2] & 0xf0) || scsicmd[7])
559 /* stores LBA27:24 in lower 4 bits of device reg */
560 tf->device |= scsicmd[2];
562 qc->nsect = scsicmd[8];
565 tf->nsect = scsicmd[8];
566 tf->lbal = scsicmd[5];
567 tf->lbam = scsicmd[4];
568 tf->lbah = scsicmd[3];
570 VPRINTK("ten-byte command\n");
574 if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
575 qc->nsect = tf->nsect = scsicmd[4];
576 tf->lbal = scsicmd[3];
577 tf->lbam = scsicmd[2];
578 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
580 VPRINTK("six-byte command\n");
584 if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
585 /* rule out impossible LBAs and sector counts */
586 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
590 tf->hob_nsect = scsicmd[12];
591 tf->hob_lbal = scsicmd[6];
592 tf->hob_lbam = scsicmd[5];
593 tf->hob_lbah = scsicmd[4];
595 qc->nsect = ((unsigned int)scsicmd[12] << 8) |
598 /* once again, filter out impossible non-zero values */
599 if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
603 /* stores LBA27:24 in lower 4 bits of device reg */
604 tf->device |= scsicmd[2];
606 qc->nsect = scsicmd[13];
609 tf->nsect = scsicmd[13];
610 tf->lbal = scsicmd[9];
611 tf->lbam = scsicmd[8];
612 tf->lbah = scsicmd[7];
614 VPRINTK("sixteen-byte command\n");
618 DPRINTK("no-byte command\n");
622 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
624 struct scsi_cmnd *cmd = qc->scsicmd;
626 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
627 ata_to_sense_error(qc, drv_stat);
629 cmd->result = SAM_STAT_GOOD;
637 * ata_scsi_translate - Translate then issue SCSI command to ATA device
638 * @ap: ATA port to which the command is addressed
639 * @dev: ATA device to which the command is addressed
640 * @cmd: SCSI command to execute
641 * @done: SCSI command completion function
642 * @xlat_func: Actor which translates @cmd to an ATA taskfile
644 * Our ->queuecommand() function has decided that the SCSI
645 * command issued can be directly translated into an ATA
646 * command, rather than handled internally.
648 * This function sets up an ata_queued_cmd structure for the
649 * SCSI command, and sends that ata_queued_cmd to the hardware.
652 * spin_lock_irqsave(host_set lock)
655 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
656 struct scsi_cmnd *cmd,
657 void (*done)(struct scsi_cmnd *),
658 ata_xlat_func_t xlat_func)
660 struct ata_queued_cmd *qc;
661 u8 *scsicmd = cmd->cmnd;
665 qc = ata_scsi_qc_new(ap, dev, cmd, done);
669 /* data is present; dma-map it */
670 if (cmd->sc_data_direction == SCSI_DATA_READ ||
671 cmd->sc_data_direction == SCSI_DATA_WRITE) {
672 if (unlikely(cmd->request_bufflen < 1)) {
673 printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
679 ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
681 ata_sg_init_one(qc, cmd->request_buffer,
682 cmd->request_bufflen);
684 qc->pci_dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
687 qc->complete_fn = ata_scsi_qc_complete;
689 if (xlat_func(qc, scsicmd))
692 /* select device, send command to hardware */
693 if (ata_qc_issue(qc))
700 ata_bad_cdb(cmd, done);
701 DPRINTK("EXIT - badcmd\n");
705 * ata_scsi_rbuf_get - Map response buffer.
706 * @cmd: SCSI command containing buffer to be mapped.
707 * @buf_out: Pointer to mapped area.
709 * Maps buffer contained within SCSI command @cmd.
712 * spin_lock_irqsave(host_set lock)
715 * Length of response buffer.
718 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
724 struct scatterlist *sg;
726 sg = (struct scatterlist *) cmd->request_buffer;
727 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
730 buf = cmd->request_buffer;
731 buflen = cmd->request_bufflen;
734 memset(buf, 0, buflen);
740 * ata_scsi_rbuf_put - Unmap response buffer.
741 * @cmd: SCSI command containing buffer to be unmapped.
743 * Unmaps response buffer contained within @cmd.
746 * spin_lock_irqsave(host_set lock)
749 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd)
752 struct scatterlist *sg;
754 sg = (struct scatterlist *) cmd->request_buffer;
755 kunmap_atomic(sg->page, KM_USER0);
760 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
761 * @args: Port / device / SCSI command of interest.
762 * @actor: Callback hook for desired SCSI command simulator
764 * Takes care of the hard work of simulating a SCSI command...
765 * Mapping the response buffer, calling the command's handler,
766 * and handling the handler's return value. This return value
767 * indicates whether the handler wishes the SCSI command to be
768 * completed successfully, or not.
771 * spin_lock_irqsave(host_set lock)
774 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
775 unsigned int (*actor) (struct ata_scsi_args *args,
776 u8 *rbuf, unsigned int buflen))
779 unsigned int buflen, rc;
780 struct scsi_cmnd *cmd = args->cmd;
782 buflen = ata_scsi_rbuf_get(cmd, &rbuf);
783 rc = actor(args, rbuf, buflen);
784 ata_scsi_rbuf_put(cmd);
787 ata_bad_cdb(cmd, args->done);
789 cmd->result = SAM_STAT_GOOD;
795 * ata_scsiop_inq_std - Simulate INQUIRY command
796 * @args: Port / device / SCSI command of interest.
797 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
798 * @buflen: Response buffer length.
800 * Returns standard device identification data associated
801 * with non-EVPD INQUIRY command output.
804 * spin_lock_irqsave(host_set lock)
807 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
810 struct ata_device *dev = args->dev;
815 0x5, /* claim SPC-3 version compatibility */
820 /* set scsi removeable (RMB) bit per ata bit */
821 if (ata_id_removeable(dev))
826 memcpy(rbuf, hdr, sizeof(hdr));
829 memcpy(&rbuf[8], "ATA ", 8);
830 ata_dev_id_string(dev, &rbuf[16], ATA_ID_PROD_OFS, 16);
831 ata_dev_id_string(dev, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
832 if (rbuf[32] == 0 || rbuf[32] == ' ')
833 memcpy(&rbuf[32], "n/a ", 4);
837 const u8 versions[] = {
838 0x60, /* SAM-3 (no version claimed) */
841 0x20, /* SBC-2 (no version claimed) */
844 0x60 /* SPC-3 (no version claimed) */
847 memcpy(rbuf + 59, versions, sizeof(versions));
854 * ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
855 * @args: Port / device / SCSI command of interest.
856 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
857 * @buflen: Response buffer length.
859 * Returns list of inquiry EVPD pages available.
862 * spin_lock_irqsave(host_set lock)
865 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
869 0x00, /* page 0x00, this page */
870 0x80, /* page 0x80, unit serial no page */
871 0x83 /* page 0x83, device ident page */
873 rbuf[3] = sizeof(pages); /* number of supported EVPD pages */
876 memcpy(rbuf + 4, pages, sizeof(pages));
882 * ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
883 * @args: Port / device / SCSI command of interest.
884 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
885 * @buflen: Response buffer length.
887 * Returns ATA device serial number.
890 * spin_lock_irqsave(host_set lock)
893 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
898 0x80, /* this page code */
900 ATA_SERNO_LEN, /* page len */
902 memcpy(rbuf, hdr, sizeof(hdr));
904 if (buflen > (ATA_SERNO_LEN + 4))
905 ata_dev_id_string(args->dev, (unsigned char *) &rbuf[4],
906 ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
911 static const char *inq_83_str = "Linux ATA-SCSI simulator";
914 * ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
915 * @args: Port / device / SCSI command of interest.
916 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
917 * @buflen: Response buffer length.
919 * Returns device identification. Currently hardcoded to
920 * return "Linux ATA-SCSI simulator".
923 * spin_lock_irqsave(host_set lock)
926 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
929 rbuf[1] = 0x83; /* this page code */
930 rbuf[3] = 4 + strlen(inq_83_str); /* page len */
932 /* our one and only identification descriptor (vendor-specific) */
933 if (buflen > (strlen(inq_83_str) + 4 + 4)) {
934 rbuf[4 + 0] = 2; /* code set: ASCII */
935 rbuf[4 + 3] = strlen(inq_83_str);
936 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
944 * @args: Port / device / SCSI command of interest.
945 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
946 * @buflen: Response buffer length.
948 * No operation. Simply returns success to caller, to indicate
949 * that the caller should successfully complete this SCSI command.
952 * spin_lock_irqsave(host_set lock)
955 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
963 * ata_msense_push - Push data onto MODE SENSE data output buffer
964 * @ptr_io: (input/output) Location to store more output data
965 * @last: End of output data buffer
966 * @buf: Pointer to BLOB being added to output buffer
967 * @buflen: Length of BLOB
969 * Store MODE SENSE data on an output buffer.
975 static void ata_msense_push(u8 **ptr_io, const u8 *last,
976 const u8 *buf, unsigned int buflen)
980 if ((ptr + buflen - 1) > last)
983 memcpy(ptr, buf, buflen);
991 * ata_msense_caching - Simulate MODE SENSE caching info page
992 * @dev: Device associated with this MODE SENSE command
993 * @ptr_io: (input/output) Location to store more output data
994 * @last: End of output data buffer
996 * Generate a caching info page, which conditionally indicates
997 * write caching to the SCSI layer, depending on device
1004 static unsigned int ata_msense_caching(struct ata_device *dev, u8 **ptr_io,
1008 0x8, /* page code */
1009 0x12, /* page length */
1010 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 zeroes */
1011 0, 0, 0, 0, 0, 0, 0, 0 /* 8 zeroes */
1014 if (ata_id_wcache_enabled(dev))
1015 page[2] |= (1 << 2); /* write cache enable */
1016 if (!ata_id_rahead_enabled(dev))
1017 page[12] |= (1 << 5); /* disable read ahead */
1019 ata_msense_push(ptr_io, last, page, sizeof(page));
1020 return sizeof(page);
1024 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1025 * @dev: Device associated with this MODE SENSE command
1026 * @ptr_io: (input/output) Location to store more output data
1027 * @last: End of output data buffer
1029 * Generate a generic MODE SENSE control mode page.
1035 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1037 const u8 page[] = {0xa, 0xa, 2, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1039 ata_msense_push(ptr_io, last, page, sizeof(page));
1040 return sizeof(page);
1044 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1045 * @dev: Device associated with this MODE SENSE command
1046 * @ptr_io: (input/output) Location to store more output data
1047 * @last: End of output data buffer
1049 * Generate a generic MODE SENSE r/w error recovery page.
1055 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1058 0x1, /* page code */
1059 0xa, /* page length */
1060 (1 << 7) | (1 << 6), /* note auto r/w reallocation */
1061 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1064 ata_msense_push(ptr_io, last, page, sizeof(page));
1065 return sizeof(page);
1069 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1070 * @args: Port / device / SCSI command of interest.
1071 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1072 * @buflen: Response buffer length.
1074 * Simulate MODE SENSE commands.
1077 * spin_lock_irqsave(host_set lock)
1080 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1081 unsigned int buflen)
1083 u8 *scsicmd = args->cmd->cmnd, *p, *last;
1084 struct ata_device *dev = args->dev;
1085 unsigned int page_control, six_byte, output_len;
1089 six_byte = (scsicmd[0] == MODE_SENSE);
1091 /* we only support saved and current values (which we treat
1092 * in the same manner)
1094 page_control = scsicmd[2] >> 6;
1095 if ((page_control != 0) && (page_control != 3))
1103 p = rbuf + output_len;
1104 last = rbuf + buflen - 1;
1106 switch(scsicmd[2] & 0x3f) {
1107 case 0x01: /* r/w error recovery */
1108 output_len += ata_msense_rw_recovery(&p, last);
1111 case 0x08: /* caching */
1112 output_len += ata_msense_caching(dev, &p, last);
1115 case 0x0a: { /* control mode */
1116 output_len += ata_msense_ctl_mode(&p, last);
1120 case 0x3f: /* all pages */
1121 output_len += ata_msense_rw_recovery(&p, last);
1122 output_len += ata_msense_caching(dev, &p, last);
1123 output_len += ata_msense_ctl_mode(&p, last);
1126 default: /* invalid page code */
1132 rbuf[0] = output_len;
1135 rbuf[0] = output_len >> 8;
1136 rbuf[1] = output_len;
1143 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1144 * @args: Port / device / SCSI command of interest.
1145 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1146 * @buflen: Response buffer length.
1148 * Simulate READ CAPACITY commands.
1151 * spin_lock_irqsave(host_set lock)
1154 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1155 unsigned int buflen)
1157 u64 n_sectors = args->dev->n_sectors;
1162 n_sectors--; /* ATA TotalUserSectors - 1 */
1164 tmp = n_sectors; /* note: truncates, if lba48 */
1165 if (args->cmd->cmnd[0] == READ_CAPACITY) {
1166 /* sector count, 32-bit */
1167 rbuf[0] = tmp >> (8 * 3);
1168 rbuf[1] = tmp >> (8 * 2);
1169 rbuf[2] = tmp >> (8 * 1);
1173 tmp = ATA_SECT_SIZE;
1178 /* sector count, 64-bit */
1179 rbuf[2] = n_sectors >> (8 * 7);
1180 rbuf[3] = n_sectors >> (8 * 6);
1181 rbuf[4] = n_sectors >> (8 * 5);
1182 rbuf[5] = n_sectors >> (8 * 4);
1183 rbuf[6] = tmp >> (8 * 3);
1184 rbuf[7] = tmp >> (8 * 2);
1185 rbuf[8] = tmp >> (8 * 1);
1189 tmp = ATA_SECT_SIZE;
1190 rbuf[12] = tmp >> 8;
1198 * ata_scsiop_report_luns - Simulate REPORT LUNS command
1199 * @args: Port / device / SCSI command of interest.
1200 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1201 * @buflen: Response buffer length.
1203 * Simulate REPORT LUNS command.
1206 * spin_lock_irqsave(host_set lock)
1209 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1210 unsigned int buflen)
1213 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
1219 * ata_scsi_badcmd - End a SCSI request with an error
1220 * @cmd: SCSI request to be handled
1221 * @done: SCSI command completion function
1222 * @asc: SCSI-defined additional sense code
1223 * @ascq: SCSI-defined additional sense code qualifier
1225 * Helper function that completes a SCSI command with
1226 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1227 * and the specified additional sense codes.
1230 * spin_lock_irqsave(host_set lock)
1233 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1236 cmd->result = SAM_STAT_CHECK_CONDITION;
1238 cmd->sense_buffer[0] = 0x70;
1239 cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1240 cmd->sense_buffer[7] = 14 - 8; /* addnl. sense len. FIXME: correct? */
1241 cmd->sense_buffer[12] = asc;
1242 cmd->sense_buffer[13] = ascq;
1247 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1249 struct scsi_cmnd *cmd = qc->scsicmd;
1251 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
1252 cmd->result = SAM_STAT_CHECK_CONDITION;
1254 u8 *scsicmd = cmd->cmnd;
1256 if (scsicmd[0] == INQUIRY) {
1258 unsigned int buflen;
1260 buflen = ata_scsi_rbuf_get(cmd, &buf);
1262 buf[3] = (buf[3] & 0xf0) | 2;
1263 ata_scsi_rbuf_put(cmd);
1265 cmd->result = SAM_STAT_GOOD;
1273 * atapi_xlat - Initialize PACKET taskfile
1274 * @qc: command structure to be initialized
1275 * @scsicmd: SCSI CDB associated with this PACKET command
1278 * spin_lock_irqsave(host_set lock)
1281 * Zero on success, non-zero on failure.
1284 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1286 struct scsi_cmnd *cmd = qc->scsicmd;
1287 struct ata_device *dev = qc->dev;
1288 int using_pio = (dev->flags & ATA_DFLAG_PIO);
1289 int nodata = (cmd->sc_data_direction == SCSI_DATA_NONE);
1291 memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1293 qc->complete_fn = atapi_qc_complete;
1295 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1296 if (cmd->sc_data_direction == SCSI_DATA_WRITE) {
1297 qc->tf.flags |= ATA_TFLAG_WRITE;
1298 DPRINTK("direction: write\n");
1301 qc->tf.command = ATA_CMD_PACKET;
1303 /* no data, or PIO data xfer */
1304 if (using_pio || nodata) {
1306 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1308 qc->tf.protocol = ATA_PROT_ATAPI;
1309 qc->tf.lbam = (8 * 1024) & 0xff;
1310 qc->tf.lbah = (8 * 1024) >> 8;
1315 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1316 qc->tf.feature |= ATAPI_PKT_DMA;
1318 #ifdef ATAPI_ENABLE_DMADIR
1319 /* some SATA bridges need us to indicate data xfer direction */
1320 if (cmd->sc_data_direction != SCSI_DATA_WRITE)
1321 qc->tf.feature |= ATAPI_DMADIR;
1329 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1330 * @ap: ATA port to which the device is attached
1331 * @cmd: SCSI command to be sent to the device
1333 * Given various information provided in struct scsi_cmnd,
1334 * map that onto an ATA bus, and using that mapping
1335 * determine which ata_device is associated with the
1336 * SCSI command to be sent.
1339 * spin_lock_irqsave(host_set lock)
1342 * Associated ATA device, or %NULL if not found.
1345 static struct ata_device *
1346 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1348 struct ata_device *dev;
1350 /* skip commands not addressed to targets we simulate */
1351 if (likely(scsidev->id < ATA_MAX_DEVICES))
1352 dev = &ap->device[scsidev->id];
1356 if (unlikely((scsidev->channel != 0) ||
1357 (scsidev->lun != 0)))
1360 if (unlikely(!ata_dev_present(dev)))
1363 #ifndef ATA_ENABLE_ATAPI
1364 if (unlikely(dev->class == ATA_DEV_ATAPI))
1372 * ata_get_xlat_func - check if SCSI to ATA translation is possible
1374 * @cmd: SCSI command opcode to consider
1376 * Look up the SCSI command given, and determine whether the
1377 * SCSI command is to be translated or simulated.
1380 * Pointer to translation function if possible, %NULL if not.
1383 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1393 return ata_scsi_rw_xlat;
1395 case SYNCHRONIZE_CACHE:
1396 if (ata_try_flush_cache(dev))
1397 return ata_scsi_flush_xlat;
1402 return ata_scsi_verify_xlat;
1409 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1410 * @ap: ATA port to which the command was being sent
1411 * @cmd: SCSI command to dump
1413 * Prints the contents of a SCSI command via printk().
1416 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1417 struct scsi_cmnd *cmd)
1420 struct scsi_device *scsidev = cmd->device;
1421 u8 *scsicmd = cmd->cmnd;
1423 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1425 scsidev->channel, scsidev->id, scsidev->lun,
1426 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1427 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1433 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1434 * @cmd: SCSI command to be sent
1435 * @done: Completion function, called when command is complete
1437 * In some cases, this function translates SCSI commands into
1438 * ATA taskfiles, and queues the taskfiles to be sent to
1439 * hardware. In other cases, this function simulates a
1440 * SCSI device by evaluating and responding to certain
1441 * SCSI commands. This creates the overall effect of
1442 * ATA and ATAPI devices appearing as SCSI devices.
1445 * Releases scsi-layer-held lock, and obtains host_set lock.
1451 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1453 struct ata_port *ap;
1454 struct ata_device *dev;
1455 struct scsi_device *scsidev = cmd->device;
1457 ap = (struct ata_port *) &scsidev->host->hostdata[0];
1459 ata_scsi_dump_cdb(ap, cmd);
1461 dev = ata_scsi_find_dev(ap, scsidev);
1462 if (unlikely(!dev)) {
1463 cmd->result = (DID_BAD_TARGET << 16);
1468 if (dev->class == ATA_DEV_ATA) {
1469 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1473 ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1475 ata_scsi_simulate(ap, dev, cmd, done);
1477 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1484 * ata_scsi_simulate - simulate SCSI command on ATA device
1485 * @ap: Port to which ATA device is attached.
1486 * @dev: Target device for CDB.
1487 * @cmd: SCSI command being sent to device.
1488 * @done: SCSI command completion function.
1490 * Interprets and directly executes a select list of SCSI commands
1491 * that can be handled internally.
1494 * spin_lock_irqsave(host_set lock)
1497 static void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
1498 struct scsi_cmnd *cmd,
1499 void (*done)(struct scsi_cmnd *))
1501 struct ata_scsi_args args;
1502 u8 *scsicmd = cmd->cmnd;
1509 switch(scsicmd[0]) {
1510 /* no-op's, complete with success */
1511 case SYNCHRONIZE_CACHE:
1515 case TEST_UNIT_READY:
1516 case FORMAT_UNIT: /* FIXME: correct? */
1517 case SEND_DIAGNOSTIC: /* FIXME: correct? */
1518 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1522 if (scsicmd[1] & 2) /* is CmdDt set? */
1523 ata_bad_cdb(cmd, done);
1524 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
1525 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1526 else if (scsicmd[2] == 0x00)
1527 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1528 else if (scsicmd[2] == 0x80)
1529 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1530 else if (scsicmd[2] == 0x83)
1531 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1533 ata_bad_cdb(cmd, done);
1538 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1541 case MODE_SELECT: /* unconditionally return */
1542 case MODE_SELECT_10: /* bad-field-in-cdb */
1543 ata_bad_cdb(cmd, done);
1547 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1550 case SERVICE_ACTION_IN:
1551 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1552 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1554 ata_bad_cdb(cmd, done);
1558 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1561 /* mandantory commands we haven't implemented yet */
1564 /* all other commands */
1566 ata_bad_scsiop(cmd, done);