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 struct ata_device *dev = qc->dev;
443 unsigned int lba = tf->flags & ATA_TFLAG_LBA;
444 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
445 u64 dev_sectors = qc->dev->n_sectors;
449 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
450 tf->protocol = ATA_PROT_NODATA;
452 if (scsicmd[0] == VERIFY) {
453 block |= ((u64)scsicmd[2]) << 24;
454 block |= ((u64)scsicmd[3]) << 16;
455 block |= ((u64)scsicmd[4]) << 8;
456 block |= ((u64)scsicmd[5]);
458 n_block |= ((u32)scsicmd[7]) << 8;
459 n_block |= ((u32)scsicmd[8]);
462 else if (scsicmd[0] == VERIFY_16) {
463 block |= ((u64)scsicmd[2]) << 56;
464 block |= ((u64)scsicmd[3]) << 48;
465 block |= ((u64)scsicmd[4]) << 40;
466 block |= ((u64)scsicmd[5]) << 32;
467 block |= ((u64)scsicmd[6]) << 24;
468 block |= ((u64)scsicmd[7]) << 16;
469 block |= ((u64)scsicmd[8]) << 8;
470 block |= ((u64)scsicmd[9]);
472 n_block |= ((u32)scsicmd[10]) << 24;
473 n_block |= ((u32)scsicmd[11]) << 16;
474 n_block |= ((u32)scsicmd[12]) << 8;
475 n_block |= ((u32)scsicmd[13]);
483 if (block >= dev_sectors)
485 if ((block + n_block) > dev_sectors)
488 if (n_block > (64 * 1024))
497 tf->command = ATA_CMD_VERIFY_EXT;
499 tf->hob_nsect = (n_block >> 8) & 0xff;
501 tf->hob_lbah = (block >> 40) & 0xff;
502 tf->hob_lbam = (block >> 32) & 0xff;
503 tf->hob_lbal = (block >> 24) & 0xff;
505 tf->command = ATA_CMD_VERIFY;
507 tf->device |= (block >> 24) & 0xf;
510 tf->nsect = n_block & 0xff;
512 tf->lbah = (block >> 16) & 0xff;
513 tf->lbam = (block >> 8) & 0xff;
514 tf->lbal = block & 0xff;
516 tf->device |= ATA_LBA;
519 u32 sect, head, cyl, track;
521 /* Convert LBA to CHS */
522 track = (u32)block / dev->sectors;
523 cyl = track / dev->heads;
524 head = track % dev->heads;
525 sect = (u32)block % dev->sectors + 1;
527 DPRINTK("block[%u] track[%u] cyl[%u] head[%u] sect[%u] \n", (u32)block, track, cyl, head, sect);
529 /* Check whether the converted CHS can fit.
533 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
536 tf->command = ATA_CMD_VERIFY;
537 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
548 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
549 * @qc: Storage for translated ATA taskfile
550 * @scsicmd: SCSI command to translate
552 * Converts any of six SCSI read/write commands into the
553 * ATA counterpart, including starting sector (LBA),
554 * sector count, and taking into account the device's LBA48
557 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
558 * %WRITE_16 are currently supported.
561 * spin_lock_irqsave(host_set lock)
564 * Zero on success, non-zero on error.
567 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
569 struct ata_taskfile *tf = &qc->tf;
570 struct ata_device *dev = qc->dev;
571 unsigned int lba = tf->flags & ATA_TFLAG_LBA;
572 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
576 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
577 tf->protocol = qc->dev->xfer_protocol;
579 if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
580 scsicmd[0] == READ_16) {
581 tf->command = qc->dev->read_cmd;
583 tf->command = qc->dev->write_cmd;
584 tf->flags |= ATA_TFLAG_WRITE;
587 /* Calculate the SCSI LBA and transfer length. */
588 if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
589 block |= ((u64)scsicmd[2]) << 24;
590 block |= ((u64)scsicmd[3]) << 16;
591 block |= ((u64)scsicmd[4]) << 8;
592 block |= ((u64)scsicmd[5]);
594 n_block |= ((u32)scsicmd[7]) << 8;
595 n_block |= ((u32)scsicmd[8]);
597 VPRINTK("ten-byte command\n");
598 } else if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
599 block |= ((u64)scsicmd[2]) << 8;
600 block |= ((u64)scsicmd[3]);
601 n_block |= ((u32)scsicmd[4]);
603 VPRINTK("six-byte command\n");
604 } else if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
605 block |= ((u64)scsicmd[2]) << 56;
606 block |= ((u64)scsicmd[3]) << 48;
607 block |= ((u64)scsicmd[4]) << 40;
608 block |= ((u64)scsicmd[5]) << 32;
609 block |= ((u64)scsicmd[6]) << 24;
610 block |= ((u64)scsicmd[7]) << 16;
611 block |= ((u64)scsicmd[8]) << 8;
612 block |= ((u64)scsicmd[9]);
614 n_block |= ((u32)scsicmd[10]) << 24;
615 n_block |= ((u32)scsicmd[11]) << 16;
616 n_block |= ((u32)scsicmd[12]) << 8;
617 n_block |= ((u32)scsicmd[13]);
619 VPRINTK("sixteen-byte command\n");
621 DPRINTK("no-byte command\n");
625 /* Check and compose ATA command */
627 /* In ATA, sector count 0 means 256 or 65536 sectors, not 0 sectors. */
632 /* The request -may- be too large for LBA48. */
633 if ((block >> 48) || (n_block > 65536))
636 tf->hob_nsect = (n_block >> 8) & 0xff;
638 tf->hob_lbah = (block >> 40) & 0xff;
639 tf->hob_lbam = (block >> 32) & 0xff;
640 tf->hob_lbal = (block >> 24) & 0xff;
644 /* The request -may- be too large for LBA28. */
645 if ((block >> 28) || (n_block > 256))
648 tf->device |= (block >> 24) & 0xf;
652 tf->nsect = n_block & 0xff;
654 tf->lbah = (block >> 16) & 0xff;
655 tf->lbam = (block >> 8) & 0xff;
656 tf->lbal = block & 0xff;
658 tf->device |= ATA_LBA;
661 u32 sect, head, cyl, track;
663 /* The request -may- be too large for CHS addressing. */
664 if ((block >> 28) || (n_block > 256))
667 /* Convert LBA to CHS */
668 track = (u32)block / dev->sectors;
669 cyl = track / dev->heads;
670 head = track % dev->heads;
671 sect = (u32)block % dev->sectors + 1;
673 DPRINTK("block[%u] track[%u] cyl[%u] head[%u] sect[%u] \n",
674 (u32)block, track, cyl, head, sect);
676 /* Check whether the converted CHS can fit.
680 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
684 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
694 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
696 struct scsi_cmnd *cmd = qc->scsicmd;
698 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
699 ata_to_sense_error(qc, drv_stat);
701 cmd->result = SAM_STAT_GOOD;
709 * ata_scsi_translate - Translate then issue SCSI command to ATA device
710 * @ap: ATA port to which the command is addressed
711 * @dev: ATA device to which the command is addressed
712 * @cmd: SCSI command to execute
713 * @done: SCSI command completion function
714 * @xlat_func: Actor which translates @cmd to an ATA taskfile
716 * Our ->queuecommand() function has decided that the SCSI
717 * command issued can be directly translated into an ATA
718 * command, rather than handled internally.
720 * This function sets up an ata_queued_cmd structure for the
721 * SCSI command, and sends that ata_queued_cmd to the hardware.
724 * spin_lock_irqsave(host_set lock)
727 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
728 struct scsi_cmnd *cmd,
729 void (*done)(struct scsi_cmnd *),
730 ata_xlat_func_t xlat_func)
732 struct ata_queued_cmd *qc;
733 u8 *scsicmd = cmd->cmnd;
737 qc = ata_scsi_qc_new(ap, dev, cmd, done);
741 /* data is present; dma-map it */
742 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
743 cmd->sc_data_direction == DMA_TO_DEVICE) {
744 if (unlikely(cmd->request_bufflen < 1)) {
745 printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
751 ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
753 ata_sg_init_one(qc, cmd->request_buffer,
754 cmd->request_bufflen);
756 qc->dma_dir = cmd->sc_data_direction;
759 qc->complete_fn = ata_scsi_qc_complete;
761 if (xlat_func(qc, scsicmd))
764 /* select device, send command to hardware */
765 if (ata_qc_issue(qc))
773 ata_bad_cdb(cmd, done);
774 DPRINTK("EXIT - badcmd\n");
778 * ata_scsi_rbuf_get - Map response buffer.
779 * @cmd: SCSI command containing buffer to be mapped.
780 * @buf_out: Pointer to mapped area.
782 * Maps buffer contained within SCSI command @cmd.
785 * spin_lock_irqsave(host_set lock)
788 * Length of response buffer.
791 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
797 struct scatterlist *sg;
799 sg = (struct scatterlist *) cmd->request_buffer;
800 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
803 buf = cmd->request_buffer;
804 buflen = cmd->request_bufflen;
812 * ata_scsi_rbuf_put - Unmap response buffer.
813 * @cmd: SCSI command containing buffer to be unmapped.
814 * @buf: buffer to unmap
816 * Unmaps response buffer contained within @cmd.
819 * spin_lock_irqsave(host_set lock)
822 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
825 struct scatterlist *sg;
827 sg = (struct scatterlist *) cmd->request_buffer;
828 kunmap_atomic(buf - sg->offset, KM_USER0);
833 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
834 * @args: device IDENTIFY data / SCSI command of interest.
835 * @actor: Callback hook for desired SCSI command simulator
837 * Takes care of the hard work of simulating a SCSI command...
838 * Mapping the response buffer, calling the command's handler,
839 * and handling the handler's return value. This return value
840 * indicates whether the handler wishes the SCSI command to be
841 * completed successfully, or not.
844 * spin_lock_irqsave(host_set lock)
847 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
848 unsigned int (*actor) (struct ata_scsi_args *args,
849 u8 *rbuf, unsigned int buflen))
852 unsigned int buflen, rc;
853 struct scsi_cmnd *cmd = args->cmd;
855 buflen = ata_scsi_rbuf_get(cmd, &rbuf);
856 memset(rbuf, 0, buflen);
857 rc = actor(args, rbuf, buflen);
858 ata_scsi_rbuf_put(cmd, rbuf);
861 ata_bad_cdb(cmd, args->done);
863 cmd->result = SAM_STAT_GOOD;
869 * ata_scsiop_inq_std - Simulate INQUIRY command
870 * @args: device IDENTIFY data / SCSI command of interest.
871 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
872 * @buflen: Response buffer length.
874 * Returns standard device identification data associated
875 * with non-EVPD INQUIRY command output.
878 * spin_lock_irqsave(host_set lock)
881 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
887 0x5, /* claim SPC-3 version compatibility */
892 /* set scsi removeable (RMB) bit per ata bit */
893 if (ata_id_removeable(args->id))
898 memcpy(rbuf, hdr, sizeof(hdr));
901 memcpy(&rbuf[8], "ATA ", 8);
902 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
903 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
904 if (rbuf[32] == 0 || rbuf[32] == ' ')
905 memcpy(&rbuf[32], "n/a ", 4);
909 const u8 versions[] = {
910 0x60, /* SAM-3 (no version claimed) */
913 0x20, /* SBC-2 (no version claimed) */
916 0x60 /* SPC-3 (no version claimed) */
919 memcpy(rbuf + 59, versions, sizeof(versions));
926 * ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
927 * @args: device IDENTIFY data / SCSI command of interest.
928 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
929 * @buflen: Response buffer length.
931 * Returns list of inquiry EVPD pages available.
934 * spin_lock_irqsave(host_set lock)
937 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
941 0x00, /* page 0x00, this page */
942 0x80, /* page 0x80, unit serial no page */
943 0x83 /* page 0x83, device ident page */
945 rbuf[3] = sizeof(pages); /* number of supported EVPD pages */
948 memcpy(rbuf + 4, pages, sizeof(pages));
954 * ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
955 * @args: device IDENTIFY data / SCSI command of interest.
956 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
957 * @buflen: Response buffer length.
959 * Returns ATA device serial number.
962 * spin_lock_irqsave(host_set lock)
965 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
970 0x80, /* this page code */
972 ATA_SERNO_LEN, /* page len */
974 memcpy(rbuf, hdr, sizeof(hdr));
976 if (buflen > (ATA_SERNO_LEN + 4 - 1))
977 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
978 ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
983 static const char *inq_83_str = "Linux ATA-SCSI simulator";
986 * ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
987 * @args: device IDENTIFY data / SCSI command of interest.
988 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
989 * @buflen: Response buffer length.
991 * Returns device identification. Currently hardcoded to
992 * return "Linux ATA-SCSI simulator".
995 * spin_lock_irqsave(host_set lock)
998 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1001 rbuf[1] = 0x83; /* this page code */
1002 rbuf[3] = 4 + strlen(inq_83_str); /* page len */
1004 /* our one and only identification descriptor (vendor-specific) */
1005 if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
1006 rbuf[4 + 0] = 2; /* code set: ASCII */
1007 rbuf[4 + 3] = strlen(inq_83_str);
1008 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
1015 * ata_scsiop_noop - Command handler that simply returns success.
1016 * @args: device IDENTIFY data / SCSI command of interest.
1017 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1018 * @buflen: Response buffer length.
1020 * No operation. Simply returns success to caller, to indicate
1021 * that the caller should successfully complete this SCSI command.
1024 * spin_lock_irqsave(host_set lock)
1027 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1028 unsigned int buflen)
1035 * ata_msense_push - Push data onto MODE SENSE data output buffer
1036 * @ptr_io: (input/output) Location to store more output data
1037 * @last: End of output data buffer
1038 * @buf: Pointer to BLOB being added to output buffer
1039 * @buflen: Length of BLOB
1041 * Store MODE SENSE data on an output buffer.
1047 static void ata_msense_push(u8 **ptr_io, const u8 *last,
1048 const u8 *buf, unsigned int buflen)
1052 if ((ptr + buflen - 1) > last)
1055 memcpy(ptr, buf, buflen);
1063 * ata_msense_caching - Simulate MODE SENSE caching info page
1064 * @id: device IDENTIFY data
1065 * @ptr_io: (input/output) Location to store more output data
1066 * @last: End of output data buffer
1068 * Generate a caching info page, which conditionally indicates
1069 * write caching to the SCSI layer, depending on device
1076 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1080 0x8, /* page code */
1081 0x12, /* page length */
1082 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 zeroes */
1083 0, 0, 0, 0, 0, 0, 0, 0 /* 8 zeroes */
1086 if (ata_id_wcache_enabled(id))
1087 page[2] |= (1 << 2); /* write cache enable */
1088 if (!ata_id_rahead_enabled(id))
1089 page[12] |= (1 << 5); /* disable read ahead */
1091 ata_msense_push(ptr_io, last, page, sizeof(page));
1092 return sizeof(page);
1096 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1097 * @dev: Device associated with this MODE SENSE command
1098 * @ptr_io: (input/output) Location to store more output data
1099 * @last: End of output data buffer
1101 * Generate a generic MODE SENSE control mode page.
1107 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1109 const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1111 /* byte 2: set the descriptor format sense data bit (bit 2)
1112 * since we need to support returning this format for SAT
1113 * commands and any SCSI commands against a 48b LBA device.
1116 ata_msense_push(ptr_io, last, page, sizeof(page));
1117 return sizeof(page);
1121 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1122 * @dev: Device associated with this MODE SENSE command
1123 * @ptr_io: (input/output) Location to store more output data
1124 * @last: End of output data buffer
1126 * Generate a generic MODE SENSE r/w error recovery page.
1132 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1135 0x1, /* page code */
1136 0xa, /* page length */
1137 (1 << 7) | (1 << 6), /* note auto r/w reallocation */
1138 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1141 ata_msense_push(ptr_io, last, page, sizeof(page));
1142 return sizeof(page);
1146 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 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 MODE SENSE commands.
1154 * spin_lock_irqsave(host_set lock)
1157 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1158 unsigned int buflen)
1160 u8 *scsicmd = args->cmd->cmnd, *p, *last;
1161 unsigned int page_control, six_byte, output_len;
1165 six_byte = (scsicmd[0] == MODE_SENSE);
1167 /* we only support saved and current values (which we treat
1168 * in the same manner)
1170 page_control = scsicmd[2] >> 6;
1171 if ((page_control != 0) && (page_control != 3))
1179 p = rbuf + output_len;
1180 last = rbuf + buflen - 1;
1182 switch(scsicmd[2] & 0x3f) {
1183 case 0x01: /* r/w error recovery */
1184 output_len += ata_msense_rw_recovery(&p, last);
1187 case 0x08: /* caching */
1188 output_len += ata_msense_caching(args->id, &p, last);
1191 case 0x0a: { /* control mode */
1192 output_len += ata_msense_ctl_mode(&p, last);
1196 case 0x3f: /* all pages */
1197 output_len += ata_msense_rw_recovery(&p, last);
1198 output_len += ata_msense_caching(args->id, &p, last);
1199 output_len += ata_msense_ctl_mode(&p, last);
1202 default: /* invalid page code */
1208 rbuf[0] = output_len;
1211 rbuf[0] = output_len >> 8;
1212 rbuf[1] = output_len;
1219 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1220 * @args: device IDENTIFY data / SCSI command of interest.
1221 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1222 * @buflen: Response buffer length.
1224 * Simulate READ CAPACITY commands.
1227 * spin_lock_irqsave(host_set lock)
1230 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1231 unsigned int buflen)
1238 if (ata_id_has_lba(args->id)) {
1239 if (ata_id_has_lba48(args->id))
1240 n_sectors = ata_id_u64(args->id, 100);
1242 n_sectors = ata_id_u32(args->id, 60);
1244 /* CHS default translation */
1245 n_sectors = args->id[1] * args->id[3] * args->id[6];
1247 if (ata_id_current_chs_valid(args->id))
1248 /* CHS current translation */
1249 n_sectors = ata_id_u32(args->id, 57);
1252 n_sectors--; /* ATA TotalUserSectors - 1 */
1254 if (args->cmd->cmnd[0] == READ_CAPACITY) {
1255 if( n_sectors >= 0xffffffffULL )
1256 tmp = 0xffffffff ; /* Return max count on overflow */
1260 /* sector count, 32-bit */
1261 rbuf[0] = tmp >> (8 * 3);
1262 rbuf[1] = tmp >> (8 * 2);
1263 rbuf[2] = tmp >> (8 * 1);
1267 tmp = ATA_SECT_SIZE;
1272 /* sector count, 64-bit */
1273 tmp = n_sectors >> (8 * 4);
1274 rbuf[2] = tmp >> (8 * 3);
1275 rbuf[3] = tmp >> (8 * 2);
1276 rbuf[4] = tmp >> (8 * 1);
1279 rbuf[6] = tmp >> (8 * 3);
1280 rbuf[7] = tmp >> (8 * 2);
1281 rbuf[8] = tmp >> (8 * 1);
1285 tmp = ATA_SECT_SIZE;
1286 rbuf[12] = tmp >> 8;
1294 * ata_scsiop_report_luns - Simulate REPORT LUNS command
1295 * @args: device IDENTIFY data / SCSI command of interest.
1296 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1297 * @buflen: Response buffer length.
1299 * Simulate REPORT LUNS command.
1302 * spin_lock_irqsave(host_set lock)
1305 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1306 unsigned int buflen)
1309 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
1315 * ata_scsi_badcmd - End a SCSI request with an error
1316 * @cmd: SCSI request to be handled
1317 * @done: SCSI command completion function
1318 * @asc: SCSI-defined additional sense code
1319 * @ascq: SCSI-defined additional sense code qualifier
1321 * Helper function that completes a SCSI command with
1322 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1323 * and the specified additional sense codes.
1326 * spin_lock_irqsave(host_set lock)
1329 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1332 cmd->result = SAM_STAT_CHECK_CONDITION;
1334 cmd->sense_buffer[0] = 0x70;
1335 cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1336 cmd->sense_buffer[7] = 14 - 8; /* addnl. sense len. FIXME: correct? */
1337 cmd->sense_buffer[12] = asc;
1338 cmd->sense_buffer[13] = ascq;
1343 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1345 struct scsi_cmnd *cmd = qc->scsicmd;
1347 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1348 DPRINTK("request check condition\n");
1350 cmd->result = SAM_STAT_CHECK_CONDITION;
1356 u8 *scsicmd = cmd->cmnd;
1358 if (scsicmd[0] == INQUIRY) {
1360 unsigned int buflen;
1362 buflen = ata_scsi_rbuf_get(cmd, &buf);
1364 buf[3] = (buf[3] & 0xf0) | 2;
1365 ata_scsi_rbuf_put(cmd, buf);
1367 cmd->result = SAM_STAT_GOOD;
1375 * atapi_xlat - Initialize PACKET taskfile
1376 * @qc: command structure to be initialized
1377 * @scsicmd: SCSI CDB associated with this PACKET command
1380 * spin_lock_irqsave(host_set lock)
1383 * Zero on success, non-zero on failure.
1386 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1388 struct scsi_cmnd *cmd = qc->scsicmd;
1389 struct ata_device *dev = qc->dev;
1390 int using_pio = (dev->flags & ATA_DFLAG_PIO);
1391 int nodata = (cmd->sc_data_direction == DMA_NONE);
1394 /* Check whether ATAPI DMA is safe */
1395 if (ata_check_atapi_dma(qc))
1398 memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1400 qc->complete_fn = atapi_qc_complete;
1402 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1403 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1404 qc->tf.flags |= ATA_TFLAG_WRITE;
1405 DPRINTK("direction: write\n");
1408 qc->tf.command = ATA_CMD_PACKET;
1410 /* no data, or PIO data xfer */
1411 if (using_pio || nodata) {
1413 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1415 qc->tf.protocol = ATA_PROT_ATAPI;
1416 qc->tf.lbam = (8 * 1024) & 0xff;
1417 qc->tf.lbah = (8 * 1024) >> 8;
1422 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1423 qc->tf.feature |= ATAPI_PKT_DMA;
1425 #ifdef ATAPI_ENABLE_DMADIR
1426 /* some SATA bridges need us to indicate data xfer direction */
1427 if (cmd->sc_data_direction != DMA_TO_DEVICE)
1428 qc->tf.feature |= ATAPI_DMADIR;
1432 qc->nbytes = cmd->bufflen;
1438 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1439 * @ap: ATA port to which the device is attached
1440 * @scsidev: SCSI device from which we derive the ATA device
1442 * Given various information provided in struct scsi_cmnd,
1443 * map that onto an ATA bus, and using that mapping
1444 * determine which ata_device is associated with the
1445 * SCSI command to be sent.
1448 * spin_lock_irqsave(host_set lock)
1451 * Associated ATA device, or %NULL if not found.
1454 static struct ata_device *
1455 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1457 struct ata_device *dev;
1459 /* skip commands not addressed to targets we simulate */
1460 if (likely(scsidev->id < ATA_MAX_DEVICES))
1461 dev = &ap->device[scsidev->id];
1465 if (unlikely((scsidev->channel != 0) ||
1466 (scsidev->lun != 0)))
1469 if (unlikely(!ata_dev_present(dev)))
1472 #ifndef ATA_ENABLE_ATAPI
1473 if (unlikely(dev->class == ATA_DEV_ATAPI))
1481 * ata_get_xlat_func - check if SCSI to ATA translation is possible
1483 * @cmd: SCSI command opcode to consider
1485 * Look up the SCSI command given, and determine whether the
1486 * SCSI command is to be translated or simulated.
1489 * Pointer to translation function if possible, %NULL if not.
1492 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1502 return ata_scsi_rw_xlat;
1504 case SYNCHRONIZE_CACHE:
1505 if (ata_try_flush_cache(dev))
1506 return ata_scsi_flush_xlat;
1511 return ata_scsi_verify_xlat;
1518 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1519 * @ap: ATA port to which the command was being sent
1520 * @cmd: SCSI command to dump
1522 * Prints the contents of a SCSI command via printk().
1525 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1526 struct scsi_cmnd *cmd)
1529 struct scsi_device *scsidev = cmd->device;
1530 u8 *scsicmd = cmd->cmnd;
1532 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1534 scsidev->channel, scsidev->id, scsidev->lun,
1535 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1536 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1542 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1543 * @cmd: SCSI command to be sent
1544 * @done: Completion function, called when command is complete
1546 * In some cases, this function translates SCSI commands into
1547 * ATA taskfiles, and queues the taskfiles to be sent to
1548 * hardware. In other cases, this function simulates a
1549 * SCSI device by evaluating and responding to certain
1550 * SCSI commands. This creates the overall effect of
1551 * ATA and ATAPI devices appearing as SCSI devices.
1554 * Releases scsi-layer-held lock, and obtains host_set lock.
1560 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1562 struct ata_port *ap;
1563 struct ata_device *dev;
1564 struct scsi_device *scsidev = cmd->device;
1566 ap = (struct ata_port *) &scsidev->host->hostdata[0];
1568 ata_scsi_dump_cdb(ap, cmd);
1570 dev = ata_scsi_find_dev(ap, scsidev);
1571 if (unlikely(!dev)) {
1572 cmd->result = (DID_BAD_TARGET << 16);
1577 if (dev->class == ATA_DEV_ATA) {
1578 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1582 ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1584 ata_scsi_simulate(dev->id, cmd, done);
1586 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1593 * ata_scsi_simulate - simulate SCSI command on ATA device
1594 * @id: current IDENTIFY data for target device.
1595 * @cmd: SCSI command being sent to device.
1596 * @done: SCSI command completion function.
1598 * Interprets and directly executes a select list of SCSI commands
1599 * that can be handled internally.
1602 * spin_lock_irqsave(host_set lock)
1605 void ata_scsi_simulate(u16 *id,
1606 struct scsi_cmnd *cmd,
1607 void (*done)(struct scsi_cmnd *))
1609 struct ata_scsi_args args;
1610 u8 *scsicmd = cmd->cmnd;
1616 switch(scsicmd[0]) {
1617 /* no-op's, complete with success */
1618 case SYNCHRONIZE_CACHE:
1622 case TEST_UNIT_READY:
1623 case FORMAT_UNIT: /* FIXME: correct? */
1624 case SEND_DIAGNOSTIC: /* FIXME: correct? */
1625 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1629 if (scsicmd[1] & 2) /* is CmdDt set? */
1630 ata_bad_cdb(cmd, done);
1631 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
1632 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1633 else if (scsicmd[2] == 0x00)
1634 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1635 else if (scsicmd[2] == 0x80)
1636 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1637 else if (scsicmd[2] == 0x83)
1638 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1640 ata_bad_cdb(cmd, done);
1645 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1648 case MODE_SELECT: /* unconditionally return */
1649 case MODE_SELECT_10: /* bad-field-in-cdb */
1650 ata_bad_cdb(cmd, done);
1654 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1657 case SERVICE_ACTION_IN:
1658 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1659 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1661 ata_bad_cdb(cmd, done);
1665 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1668 /* mandantory commands we haven't implemented yet */
1671 /* all other commands */
1673 ata_bad_scsiop(cmd, done);