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 <linux/hdreg.h>
33 #include <asm/uaccess.h>
37 #define SECTOR_SIZE 512
39 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, u8 *scsicmd);
40 static struct ata_device *
41 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
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);
74 * ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
75 * @dev: Device to whom we are issuing command
76 * @arg: User provided data for issuing command
79 * Defined by the SCSI layer. We don't really care.
82 * Zero on success, negative errno on error.
85 int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
88 u8 scsi_cmd[MAX_COMMAND_SIZE];
89 u8 args[4], *argbuf = NULL;
91 struct scsi_request *sreq;
93 if (NULL == (void *)arg)
96 if (copy_from_user(args, arg, sizeof(args)))
99 sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
103 memset(scsi_cmd, 0, sizeof(scsi_cmd));
106 argsize = SECTOR_SIZE * args[3];
107 argbuf = kmalloc(argsize, GFP_KERNEL);
111 scsi_cmd[1] = (4 << 1); /* PIO Data-in */
112 scsi_cmd[2] = 0x0e; /* no off.line or cc, read from dev,
113 block count in sector count field */
114 sreq->sr_data_direction = DMA_FROM_DEVICE;
116 scsi_cmd[1] = (3 << 1); /* Non-data */
117 /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
118 sreq->sr_data_direction = DMA_NONE;
121 scsi_cmd[0] = ATA_16;
123 scsi_cmd[4] = args[2];
124 if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
125 scsi_cmd[6] = args[3];
126 scsi_cmd[8] = args[1];
130 scsi_cmd[6] = args[1];
132 scsi_cmd[14] = args[0];
134 /* Good values for timeout and retries? Values below
135 from scsi_ioctl_send_command() for default case... */
136 scsi_wait_req(sreq, scsi_cmd, argbuf, argsize, (10*HZ), 5);
138 if (sreq->sr_result) {
143 /* Need code to retrieve data from check condition? */
146 && copy_to_user((void *)(arg + sizeof(args)), argbuf, argsize))
149 scsi_release_request(sreq);
158 * ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
159 * @dev: Device to whom we are issuing command
160 * @arg: User provided data for issuing command
163 * Defined by the SCSI layer. We don't really care.
166 * Zero on success, negative errno on error.
168 int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
171 u8 scsi_cmd[MAX_COMMAND_SIZE];
173 struct scsi_request *sreq;
175 if (NULL == (void *)arg)
178 if (copy_from_user(args, arg, sizeof(args)))
181 memset(scsi_cmd, 0, sizeof(scsi_cmd));
182 scsi_cmd[0] = ATA_16;
183 scsi_cmd[1] = (3 << 1); /* Non-data */
184 /* scsi_cmd[2] is already 0 -- no off.line, cc, or data xfer */
185 scsi_cmd[4] = args[1];
186 scsi_cmd[6] = args[2];
187 scsi_cmd[8] = args[3];
188 scsi_cmd[10] = args[4];
189 scsi_cmd[12] = args[5];
190 scsi_cmd[14] = args[0];
192 sreq = scsi_allocate_request(scsidev, GFP_KERNEL);
198 sreq->sr_data_direction = DMA_NONE;
199 /* Good values for timeout and retries? Values below
200 from scsi_ioctl_send_command() for default case... */
201 scsi_wait_req(sreq, scsi_cmd, NULL, 0, (10*HZ), 5);
203 if (sreq->sr_result) {
208 /* Need code to retrieve data from check condition? */
211 scsi_release_request(sreq);
215 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
218 struct ata_device *dev;
219 int val = -EINVAL, rc = -EINVAL;
221 ap = (struct ata_port *) &scsidev->host->hostdata[0];
225 dev = ata_scsi_find_dev(ap, scsidev);
232 case ATA_IOC_GET_IO32:
234 if (copy_to_user(arg, &val, 1))
238 case ATA_IOC_SET_IO32:
239 val = (unsigned long) arg;
245 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
247 return ata_cmd_ioctl(scsidev, arg);
249 case HDIO_DRIVE_TASK:
250 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
252 return ata_task_ioctl(scsidev, arg);
264 * ata_scsi_qc_new - acquire new ata_queued_cmd reference
265 * @ap: ATA port to which the new command is attached
266 * @dev: ATA device to which the new command is attached
267 * @cmd: SCSI command that originated this ATA command
268 * @done: SCSI command completion function
270 * Obtain a reference to an unused ata_queued_cmd structure,
271 * which is the basic libata structure representing a single
272 * ATA command sent to the hardware.
274 * If a command was available, fill in the SCSI-specific
275 * portions of the structure with information on the
279 * spin_lock_irqsave(host_set lock)
282 * Command allocated, or %NULL if none available.
284 struct ata_queued_cmd *ata_scsi_qc_new(struct ata_port *ap,
285 struct ata_device *dev,
286 struct scsi_cmnd *cmd,
287 void (*done)(struct scsi_cmnd *))
289 struct ata_queued_cmd *qc;
291 qc = ata_qc_new_init(ap, dev);
297 qc->sg = (struct scatterlist *) cmd->request_buffer;
298 qc->n_elem = cmd->use_sg;
304 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
312 * ata_dump_status - user friendly display of error info
313 * @id: id of the port in question
314 * @tf: ptr to filled out taskfile
316 * Decode and dump the ATA error/status registers for the user so
317 * that they have some idea what really happened at the non
318 * make-believe layer.
321 * inherited from caller
323 void ata_dump_status(unsigned id, struct ata_taskfile *tf)
325 u8 stat = tf->command, err = tf->feature;
327 printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
328 if (stat & ATA_BUSY) {
329 printk("Busy }\n"); /* Data is not valid in this case */
331 if (stat & 0x40) printk("DriveReady ");
332 if (stat & 0x20) printk("DeviceFault ");
333 if (stat & 0x10) printk("SeekComplete ");
334 if (stat & 0x08) printk("DataRequest ");
335 if (stat & 0x04) printk("CorrectedError ");
336 if (stat & 0x02) printk("Index ");
337 if (stat & 0x01) printk("Error ");
341 printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
342 if (err & 0x04) printk("DriveStatusError ");
344 if (err & 0x04) printk("BadCRC ");
345 else printk("Sector ");
347 if (err & 0x40) printk("UncorrectableError ");
348 if (err & 0x10) printk("SectorIdNotFound ");
349 if (err & 0x02) printk("TrackZeroNotFound ");
350 if (err & 0x01) printk("AddrMarkNotFound ");
357 * ata_to_sense_error - convert ATA error to SCSI error
358 * @drv_stat: value contained in ATA status register
359 * @drv_err: value contained in ATA error register
360 * @sk: the sense key we'll fill out
361 * @asc: the additional sense code we'll fill out
362 * @ascq: the additional sense code qualifier we'll fill out
364 * Converts an ATA error into a SCSI error. Fill out pointers to
365 * SK, ASC, and ASCQ bytes for later use in fixed or descriptor
366 * format sense blocks.
369 * spin_lock_irqsave(host_set lock)
371 void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
375 /* Based on the 3ware driver translation table */
376 static unsigned char sense_table[][4] = {
378 {0xd1, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
380 {0xd0, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
382 {0x61, HARDWARE_ERROR, 0x00, 0x00}, // Device fault Hardware error
383 /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
384 {0x84, ABORTED_COMMAND, 0x47, 0x00}, // Data CRC error SCSI parity error
385 /* MC|ID|ABRT|TRK0|MARK */
386 {0x37, NOT_READY, 0x04, 0x00}, // Unit offline Not ready
388 {0x09, NOT_READY, 0x04, 0x00}, // Unrecovered disk error Not ready
389 /* Bad address mark */
390 {0x01, MEDIUM_ERROR, 0x13, 0x00}, // Address mark not found Address mark not found for data field
392 {0x02, HARDWARE_ERROR, 0x00, 0x00}, // Track 0 not found Hardware error
394 {0x04, ABORTED_COMMAND, 0x00, 0x00}, // Aborted command Aborted command
395 /* Media change request */
396 {0x08, NOT_READY, 0x04, 0x00}, // Media change request FIXME: faking offline
398 {0x10, ABORTED_COMMAND, 0x14, 0x00}, // ID not found Recorded entity not found
400 {0x08, NOT_READY, 0x04, 0x00}, // Media change FIXME: faking offline
402 {0x40, MEDIUM_ERROR, 0x11, 0x04}, // Uncorrectable ECC error Unrecovered read error
403 /* BBD - block marked bad */
404 {0x80, MEDIUM_ERROR, 0x11, 0x04}, // Block marked bad Medium error, unrecovered read error
405 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
407 static unsigned char stat_table[][4] = {
408 /* Must be first because BUSY means no other bits valid */
409 {0x80, ABORTED_COMMAND, 0x47, 0x00}, // Busy, fake parity for now
410 {0x20, HARDWARE_ERROR, 0x00, 0x00}, // Device fault
411 {0x08, ABORTED_COMMAND, 0x47, 0x00}, // Timed out in xfer, fake parity for now
412 {0x04, RECOVERED_ERROR, 0x11, 0x00}, // Recovered ECC error Medium error, recovered
413 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
417 * Is this an error we can process/parse
419 if (drv_stat & ATA_BUSY) {
420 drv_err = 0; /* Ignore the err bits, they're invalid */
424 /* Look for drv_err */
425 for (i = 0; sense_table[i][0] != 0xFF; i++) {
426 /* Look for best matches first */
427 if ((sense_table[i][0] & drv_err) ==
429 *sk = sense_table[i][1];
430 *asc = sense_table[i][2];
431 *ascq = sense_table[i][3];
435 /* No immediate match */
436 printk(KERN_WARNING "ata%u: no sense translation for "
437 "error 0x%02x\n", id, drv_err);
440 /* Fall back to interpreting status bits */
441 for (i = 0; stat_table[i][0] != 0xFF; i++) {
442 if (stat_table[i][0] & drv_stat) {
443 *sk = stat_table[i][1];
444 *asc = stat_table[i][2];
445 *ascq = stat_table[i][3];
449 /* No error? Undecoded? */
450 printk(KERN_WARNING "ata%u: no sense translation for status: 0x%02x\n",
453 /* For our last chance pick, use medium read error because
454 * it's much more common than an ATA drive telling you a write
458 *asc = 0x11; /* "unrecovered read error" */
459 *ascq = 0x04; /* "auto-reallocation failed" */
462 printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x to "
463 "SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n", id, drv_stat, drv_err,
469 * ata_gen_ata_desc_sense - Generate check condition sense block.
470 * @qc: Command that completed.
472 * This function is specific to the ATA descriptor format sense
473 * block specified for the ATA pass through commands. Regardless
474 * of whether the command errored or not, return a sense
475 * block. Copy all controller registers into the sense
476 * block. Clear sense key, ASC & ASCQ if there is no error.
479 * spin_lock_irqsave(host_set lock)
481 void ata_gen_ata_desc_sense(struct ata_queued_cmd *qc)
483 struct scsi_cmnd *cmd = qc->scsicmd;
484 struct ata_taskfile *tf = &qc->tf;
485 unsigned char *sb = cmd->sense_buffer;
486 unsigned char *desc = sb + 8;
488 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
490 cmd->result = SAM_STAT_CHECK_CONDITION;
493 * Read the controller registers.
495 assert(NULL != qc->ap->ops->tf_read);
496 qc->ap->ops->tf_read(qc->ap, tf);
499 * Use ata_to_sense_error() to map status register bits
500 * onto sense key, asc & ascq.
502 if (unlikely(tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ))) {
503 ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
504 &sb[1], &sb[2], &sb[3]);
509 * Sense data is current and format is descriptor.
516 * Set length of additional sense data.
517 * Since we only populate descriptor 0, the total
518 * length is the same (fixed) length as descriptor 0.
520 desc[1] = sb[7] = 14;
523 * Copy registers into sense buffer.
526 desc[3] = tf->feature; /* == error reg */
531 desc[12] = tf->device;
532 desc[13] = tf->command; /* == status reg */
535 * Fill in Extend bit, and the high order bytes
538 if (tf->flags & ATA_TFLAG_LBA48) {
540 desc[4] = tf->hob_nsect;
541 desc[6] = tf->hob_lbal;
542 desc[8] = tf->hob_lbam;
543 desc[10] = tf->hob_lbah;
548 * ata_gen_fixed_sense - generate a SCSI fixed sense block
549 * @qc: Command that we are erroring out
551 * Leverage ata_to_sense_error() to give us the codes. Fit our
552 * LBA in here if there's room.
555 * inherited from caller
557 void ata_gen_fixed_sense(struct ata_queued_cmd *qc)
559 struct scsi_cmnd *cmd = qc->scsicmd;
560 struct ata_taskfile *tf = &qc->tf;
561 unsigned char *sb = cmd->sense_buffer;
563 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
565 cmd->result = SAM_STAT_CHECK_CONDITION;
568 * Read the controller registers.
570 assert(NULL != qc->ap->ops->tf_read);
571 qc->ap->ops->tf_read(qc->ap, tf);
574 * Use ata_to_sense_error() to map status register bits
575 * onto sense key, asc & ascq.
577 if (unlikely(tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ))) {
578 ata_to_sense_error(qc->ap->id, tf->command, tf->feature,
579 &sb[2], &sb[12], &sb[13]);
586 #if 0 /* when C/H/S support is merged */
587 if (tf->flags & ATA_TFLAG_LBA && !(tf->flags & ATA_TFLAG_LBA48)) {
589 if (!(tf->flags & ATA_TFLAG_LBA48)) {
590 /* A small (28b) LBA will fit in the 32b info field */
591 sb[0] |= 0x80; /* set valid bit */
592 sb[3] = tf->device & 0x0f;
600 * ata_scsi_slave_config - Set SCSI device attributes
601 * @sdev: SCSI device to examine
603 * This is called before we actually start reading
604 * and writing to the device, to configure certain
605 * SCSI mid-layer behaviors.
608 * Defined by SCSI layer. We don't really care.
611 int ata_scsi_slave_config(struct scsi_device *sdev)
613 sdev->use_10_for_rw = 1;
614 sdev->use_10_for_ms = 1;
616 blk_queue_max_phys_segments(sdev->request_queue, LIBATA_MAX_PRD);
618 if (sdev->id < ATA_MAX_DEVICES) {
620 struct ata_device *dev;
622 ap = (struct ata_port *) &sdev->host->hostdata[0];
623 dev = &ap->device[sdev->id];
625 /* TODO: 1024 is an arbitrary number, not the
626 * hardware maximum. This should be increased to
627 * 65534 when Jens Axboe's patch for dynamically
628 * determining max_sectors is merged.
630 if ((dev->flags & ATA_DFLAG_LBA48) &&
631 ((dev->flags & ATA_DFLAG_LOCK_SECTORS) == 0)) {
633 * do not overwrite sdev->host->max_sectors, since
634 * other drives on this host may not support LBA48
636 blk_queue_max_sectors(sdev->request_queue, 2048);
640 return 0; /* scsi layer doesn't check return value, sigh */
644 * ata_scsi_error - SCSI layer error handler callback
645 * @host: SCSI host on which error occurred
647 * Handles SCSI-layer-thrown error events.
650 * Inherited from SCSI layer (none, can sleep)
656 int ata_scsi_error(struct Scsi_Host *host)
662 ap = (struct ata_port *) &host->hostdata[0];
663 ap->ops->eng_timeout(ap);
665 /* TODO: this is per-command; when queueing is supported
666 * this code will either change or move to a more
676 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
677 * @qc: Storage for translated ATA taskfile
678 * @scsicmd: SCSI command to translate (ignored)
680 * Sets up an ATA taskfile to issue FLUSH CACHE or
684 * spin_lock_irqsave(host_set lock)
687 * Zero on success, non-zero on error.
690 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
692 struct ata_taskfile *tf = &qc->tf;
694 tf->flags |= ATA_TFLAG_DEVICE;
695 tf->protocol = ATA_PROT_NODATA;
697 if ((tf->flags & ATA_TFLAG_LBA48) &&
698 (ata_id_has_flush_ext(qc->dev->id)))
699 tf->command = ATA_CMD_FLUSH_EXT;
701 tf->command = ATA_CMD_FLUSH;
707 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
708 * @qc: Storage for translated ATA taskfile
709 * @scsicmd: SCSI command to translate
711 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
714 * spin_lock_irqsave(host_set lock)
717 * Zero on success, non-zero on error.
720 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
722 struct ata_taskfile *tf = &qc->tf;
723 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
724 u64 dev_sectors = qc->dev->n_sectors;
728 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
729 tf->protocol = ATA_PROT_NODATA;
730 tf->device |= ATA_LBA;
732 if (scsicmd[0] == VERIFY) {
733 sect |= ((u64)scsicmd[2]) << 24;
734 sect |= ((u64)scsicmd[3]) << 16;
735 sect |= ((u64)scsicmd[4]) << 8;
736 sect |= ((u64)scsicmd[5]);
738 n_sect |= ((u32)scsicmd[7]) << 8;
739 n_sect |= ((u32)scsicmd[8]);
742 else if (scsicmd[0] == VERIFY_16) {
743 sect |= ((u64)scsicmd[2]) << 56;
744 sect |= ((u64)scsicmd[3]) << 48;
745 sect |= ((u64)scsicmd[4]) << 40;
746 sect |= ((u64)scsicmd[5]) << 32;
747 sect |= ((u64)scsicmd[6]) << 24;
748 sect |= ((u64)scsicmd[7]) << 16;
749 sect |= ((u64)scsicmd[8]) << 8;
750 sect |= ((u64)scsicmd[9]);
752 n_sect |= ((u32)scsicmd[10]) << 24;
753 n_sect |= ((u32)scsicmd[11]) << 16;
754 n_sect |= ((u32)scsicmd[12]) << 8;
755 n_sect |= ((u32)scsicmd[13]);
763 if (sect >= dev_sectors)
765 if ((sect + n_sect) > dev_sectors)
768 if (n_sect > (64 * 1024))
776 tf->command = ATA_CMD_VERIFY_EXT;
778 tf->hob_nsect = (n_sect >> 8) & 0xff;
780 tf->hob_lbah = (sect >> 40) & 0xff;
781 tf->hob_lbam = (sect >> 32) & 0xff;
782 tf->hob_lbal = (sect >> 24) & 0xff;
784 tf->command = ATA_CMD_VERIFY;
786 tf->device |= (sect >> 24) & 0xf;
789 tf->nsect = n_sect & 0xff;
791 tf->lbah = (sect >> 16) & 0xff;
792 tf->lbam = (sect >> 8) & 0xff;
793 tf->lbal = sect & 0xff;
799 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
800 * @qc: Storage for translated ATA taskfile
801 * @scsicmd: SCSI command to translate
803 * Converts any of six SCSI read/write commands into the
804 * ATA counterpart, including starting sector (LBA),
805 * sector count, and taking into account the device's LBA48
808 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
809 * %WRITE_16 are currently supported.
812 * spin_lock_irqsave(host_set lock)
815 * Zero on success, non-zero on error.
818 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
820 struct ata_taskfile *tf = &qc->tf;
821 unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
823 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
824 tf->protocol = qc->dev->xfer_protocol;
825 tf->device |= ATA_LBA;
827 if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
828 scsicmd[0] == READ_16) {
829 tf->command = qc->dev->read_cmd;
831 tf->command = qc->dev->write_cmd;
832 tf->flags |= ATA_TFLAG_WRITE;
835 if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
837 tf->hob_nsect = scsicmd[7];
838 tf->hob_lbal = scsicmd[2];
840 qc->nsect = ((unsigned int)scsicmd[7] << 8) |
843 /* if we don't support LBA48 addressing, the request
844 * -may- be too large. */
845 if ((scsicmd[2] & 0xf0) || scsicmd[7])
848 /* stores LBA27:24 in lower 4 bits of device reg */
849 tf->device |= scsicmd[2];
851 qc->nsect = scsicmd[8];
854 tf->nsect = scsicmd[8];
855 tf->lbal = scsicmd[5];
856 tf->lbam = scsicmd[4];
857 tf->lbah = scsicmd[3];
859 VPRINTK("ten-byte command\n");
863 if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
864 qc->nsect = tf->nsect = scsicmd[4];
865 tf->lbal = scsicmd[3];
866 tf->lbam = scsicmd[2];
867 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
869 VPRINTK("six-byte command\n");
873 if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
874 /* rule out impossible LBAs and sector counts */
875 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
879 tf->hob_nsect = scsicmd[12];
880 tf->hob_lbal = scsicmd[6];
881 tf->hob_lbam = scsicmd[5];
882 tf->hob_lbah = scsicmd[4];
884 qc->nsect = ((unsigned int)scsicmd[12] << 8) |
887 /* once again, filter out impossible non-zero values */
888 if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
892 /* stores LBA27:24 in lower 4 bits of device reg */
893 tf->device |= scsicmd[6];
895 qc->nsect = scsicmd[13];
898 tf->nsect = scsicmd[13];
899 tf->lbal = scsicmd[9];
900 tf->lbam = scsicmd[8];
901 tf->lbah = scsicmd[7];
903 VPRINTK("sixteen-byte command\n");
907 DPRINTK("no-byte command\n");
911 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
913 struct scsi_cmnd *cmd = qc->scsicmd;
914 int need_sense = drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ);
916 /* For ATA pass thru (SAT) commands, generate a sense block if
917 * user mandated it or if there's an error. Note that if we
918 * generate because the user forced us to, a check condition
919 * is generated and the ATA register values are returned
920 * whether the command completed successfully or not. If there
921 * was no error, SK, ASC and ASCQ will all be zero.
923 if (((cmd->cmnd[0] == ATA_16) || (cmd->cmnd[0] == ATA_12)) &&
924 ((cmd->cmnd[2] & 0x20) || need_sense)) {
925 ata_gen_ata_desc_sense(qc);
928 cmd->result = SAM_STAT_GOOD;
930 /* TODO: decide which descriptor format to use
931 * for 48b LBA devices and call that here
932 * instead of the fixed desc, which is only
933 * good for smaller LBA (and maybe CHS?)
936 ata_gen_fixed_sense(qc);
941 /* The ata_gen_..._sense routines fill in tf */
942 ata_dump_status(qc->ap->id, &qc->tf);
951 * ata_scsi_translate - Translate then issue SCSI command to ATA device
952 * @ap: ATA port to which the command is addressed
953 * @dev: ATA device to which the command is addressed
954 * @cmd: SCSI command to execute
955 * @done: SCSI command completion function
956 * @xlat_func: Actor which translates @cmd to an ATA taskfile
958 * Our ->queuecommand() function has decided that the SCSI
959 * command issued can be directly translated into an ATA
960 * command, rather than handled internally.
962 * This function sets up an ata_queued_cmd structure for the
963 * SCSI command, and sends that ata_queued_cmd to the hardware.
966 * spin_lock_irqsave(host_set lock)
969 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
970 struct scsi_cmnd *cmd,
971 void (*done)(struct scsi_cmnd *),
972 ata_xlat_func_t xlat_func)
974 struct ata_queued_cmd *qc;
975 u8 *scsicmd = cmd->cmnd;
979 qc = ata_scsi_qc_new(ap, dev, cmd, done);
983 /* data is present; dma-map it */
984 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
985 cmd->sc_data_direction == DMA_TO_DEVICE) {
986 if (unlikely(cmd->request_bufflen < 1)) {
987 printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
993 ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
995 ata_sg_init_one(qc, cmd->request_buffer,
996 cmd->request_bufflen);
998 qc->dma_dir = cmd->sc_data_direction;
1001 qc->complete_fn = ata_scsi_qc_complete;
1003 if (xlat_func(qc, scsicmd))
1005 /* select device, send command to hardware */
1006 if (ata_qc_issue(qc))
1014 ata_bad_cdb(cmd, done);
1015 DPRINTK("EXIT - badcmd\n");
1019 * ata_scsi_rbuf_get - Map response buffer.
1020 * @cmd: SCSI command containing buffer to be mapped.
1021 * @buf_out: Pointer to mapped area.
1023 * Maps buffer contained within SCSI command @cmd.
1026 * spin_lock_irqsave(host_set lock)
1029 * Length of response buffer.
1032 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
1035 unsigned int buflen;
1038 struct scatterlist *sg;
1040 sg = (struct scatterlist *) cmd->request_buffer;
1041 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
1042 buflen = sg->length;
1044 buf = cmd->request_buffer;
1045 buflen = cmd->request_bufflen;
1053 * ata_scsi_rbuf_put - Unmap response buffer.
1054 * @cmd: SCSI command containing buffer to be unmapped.
1055 * @buf: buffer to unmap
1057 * Unmaps response buffer contained within @cmd.
1060 * spin_lock_irqsave(host_set lock)
1063 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
1066 struct scatterlist *sg;
1068 sg = (struct scatterlist *) cmd->request_buffer;
1069 kunmap_atomic(buf - sg->offset, KM_USER0);
1074 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1075 * @args: device IDENTIFY data / SCSI command of interest.
1076 * @actor: Callback hook for desired SCSI command simulator
1078 * Takes care of the hard work of simulating a SCSI command...
1079 * Mapping the response buffer, calling the command's handler,
1080 * and handling the handler's return value. This return value
1081 * indicates whether the handler wishes the SCSI command to be
1082 * completed successfully, or not.
1085 * spin_lock_irqsave(host_set lock)
1088 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1089 unsigned int (*actor) (struct ata_scsi_args *args,
1090 u8 *rbuf, unsigned int buflen))
1093 unsigned int buflen, rc;
1094 struct scsi_cmnd *cmd = args->cmd;
1096 buflen = ata_scsi_rbuf_get(cmd, &rbuf);
1097 memset(rbuf, 0, buflen);
1098 rc = actor(args, rbuf, buflen);
1099 ata_scsi_rbuf_put(cmd, rbuf);
1102 ata_bad_cdb(cmd, args->done);
1104 cmd->result = SAM_STAT_GOOD;
1110 * ata_scsiop_inq_std - Simulate INQUIRY command
1111 * @args: device IDENTIFY data / SCSI command of interest.
1112 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1113 * @buflen: Response buffer length.
1115 * Returns standard device identification data associated
1116 * with non-EVPD INQUIRY command output.
1119 * spin_lock_irqsave(host_set lock)
1122 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
1123 unsigned int buflen)
1128 0x5, /* claim SPC-3 version compatibility */
1133 /* set scsi removeable (RMB) bit per ata bit */
1134 if (ata_id_removeable(args->id))
1139 memcpy(rbuf, hdr, sizeof(hdr));
1142 memcpy(&rbuf[8], "ATA ", 8);
1143 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
1144 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
1145 if (rbuf[32] == 0 || rbuf[32] == ' ')
1146 memcpy(&rbuf[32], "n/a ", 4);
1150 const u8 versions[] = {
1151 0x60, /* SAM-3 (no version claimed) */
1154 0x20, /* SBC-2 (no version claimed) */
1157 0x60 /* SPC-3 (no version claimed) */
1160 memcpy(rbuf + 59, versions, sizeof(versions));
1167 * ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
1168 * @args: device IDENTIFY data / SCSI command of interest.
1169 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1170 * @buflen: Response buffer length.
1172 * Returns list of inquiry EVPD pages available.
1175 * spin_lock_irqsave(host_set lock)
1178 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
1179 unsigned int buflen)
1181 const u8 pages[] = {
1182 0x00, /* page 0x00, this page */
1183 0x80, /* page 0x80, unit serial no page */
1184 0x83 /* page 0x83, device ident page */
1186 rbuf[3] = sizeof(pages); /* number of supported EVPD pages */
1189 memcpy(rbuf + 4, pages, sizeof(pages));
1195 * ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
1196 * @args: device IDENTIFY data / SCSI command of interest.
1197 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1198 * @buflen: Response buffer length.
1200 * Returns ATA device serial number.
1203 * spin_lock_irqsave(host_set lock)
1206 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
1207 unsigned int buflen)
1211 0x80, /* this page code */
1213 ATA_SERNO_LEN, /* page len */
1215 memcpy(rbuf, hdr, sizeof(hdr));
1217 if (buflen > (ATA_SERNO_LEN + 4 - 1))
1218 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
1219 ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
1224 static const char *inq_83_str = "Linux ATA-SCSI simulator";
1227 * ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
1228 * @args: device IDENTIFY data / SCSI command of interest.
1229 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1230 * @buflen: Response buffer length.
1232 * Returns device identification. Currently hardcoded to
1233 * return "Linux ATA-SCSI simulator".
1236 * spin_lock_irqsave(host_set lock)
1239 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1240 unsigned int buflen)
1242 rbuf[1] = 0x83; /* this page code */
1243 rbuf[3] = 4 + strlen(inq_83_str); /* page len */
1245 /* our one and only identification descriptor (vendor-specific) */
1246 if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
1247 rbuf[4 + 0] = 2; /* code set: ASCII */
1248 rbuf[4 + 3] = strlen(inq_83_str);
1249 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
1256 * ata_scsiop_noop - Command handler that simply returns success.
1257 * @args: device IDENTIFY data / SCSI command of interest.
1258 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1259 * @buflen: Response buffer length.
1261 * No operation. Simply returns success to caller, to indicate
1262 * that the caller should successfully complete this SCSI command.
1265 * spin_lock_irqsave(host_set lock)
1268 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1269 unsigned int buflen)
1276 * ata_msense_push - Push data onto MODE SENSE data output buffer
1277 * @ptr_io: (input/output) Location to store more output data
1278 * @last: End of output data buffer
1279 * @buf: Pointer to BLOB being added to output buffer
1280 * @buflen: Length of BLOB
1282 * Store MODE SENSE data on an output buffer.
1288 static void ata_msense_push(u8 **ptr_io, const u8 *last,
1289 const u8 *buf, unsigned int buflen)
1293 if ((ptr + buflen - 1) > last)
1296 memcpy(ptr, buf, buflen);
1304 * ata_msense_caching - Simulate MODE SENSE caching info page
1305 * @id: device IDENTIFY data
1306 * @ptr_io: (input/output) Location to store more output data
1307 * @last: End of output data buffer
1309 * Generate a caching info page, which conditionally indicates
1310 * write caching to the SCSI layer, depending on device
1317 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1321 0x8, /* page code */
1322 0x12, /* page length */
1323 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 zeroes */
1324 0, 0, 0, 0, 0, 0, 0, 0 /* 8 zeroes */
1327 if (ata_id_wcache_enabled(id))
1328 page[2] |= (1 << 2); /* write cache enable */
1329 if (!ata_id_rahead_enabled(id))
1330 page[12] |= (1 << 5); /* disable read ahead */
1332 ata_msense_push(ptr_io, last, page, sizeof(page));
1333 return sizeof(page);
1337 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1338 * @dev: Device associated with this MODE SENSE command
1339 * @ptr_io: (input/output) Location to store more output data
1340 * @last: End of output data buffer
1342 * Generate a generic MODE SENSE control mode page.
1348 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1350 const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1352 /* byte 2: set the descriptor format sense data bit (bit 2)
1353 * since we need to support returning this format for SAT
1354 * commands and any SCSI commands against a 48b LBA device.
1357 ata_msense_push(ptr_io, last, page, sizeof(page));
1358 return sizeof(page);
1362 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1363 * @dev: Device associated with this MODE SENSE command
1364 * @ptr_io: (input/output) Location to store more output data
1365 * @last: End of output data buffer
1367 * Generate a generic MODE SENSE r/w error recovery page.
1373 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1376 0x1, /* page code */
1377 0xa, /* page length */
1378 (1 << 7) | (1 << 6), /* note auto r/w reallocation */
1379 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1382 ata_msense_push(ptr_io, last, page, sizeof(page));
1383 return sizeof(page);
1387 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1388 * @args: device IDENTIFY data / SCSI command of interest.
1389 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1390 * @buflen: Response buffer length.
1392 * Simulate MODE SENSE commands.
1395 * spin_lock_irqsave(host_set lock)
1398 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1399 unsigned int buflen)
1401 u8 *scsicmd = args->cmd->cmnd, *p, *last;
1402 unsigned int page_control, six_byte, output_len;
1406 six_byte = (scsicmd[0] == MODE_SENSE);
1408 /* we only support saved and current values (which we treat
1409 * in the same manner)
1411 page_control = scsicmd[2] >> 6;
1412 if ((page_control != 0) && (page_control != 3))
1420 p = rbuf + output_len;
1421 last = rbuf + buflen - 1;
1423 switch(scsicmd[2] & 0x3f) {
1424 case 0x01: /* r/w error recovery */
1425 output_len += ata_msense_rw_recovery(&p, last);
1428 case 0x08: /* caching */
1429 output_len += ata_msense_caching(args->id, &p, last);
1432 case 0x0a: { /* control mode */
1433 output_len += ata_msense_ctl_mode(&p, last);
1437 case 0x3f: /* all pages */
1438 output_len += ata_msense_rw_recovery(&p, last);
1439 output_len += ata_msense_caching(args->id, &p, last);
1440 output_len += ata_msense_ctl_mode(&p, last);
1443 default: /* invalid page code */
1449 rbuf[0] = output_len;
1452 rbuf[0] = output_len >> 8;
1453 rbuf[1] = output_len;
1460 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1461 * @args: device IDENTIFY data / SCSI command of interest.
1462 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1463 * @buflen: Response buffer length.
1465 * Simulate READ CAPACITY commands.
1468 * spin_lock_irqsave(host_set lock)
1471 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1472 unsigned int buflen)
1479 if (ata_id_has_lba48(args->id))
1480 n_sectors = ata_id_u64(args->id, 100);
1482 n_sectors = ata_id_u32(args->id, 60);
1483 n_sectors--; /* ATA TotalUserSectors - 1 */
1485 if (args->cmd->cmnd[0] == READ_CAPACITY) {
1486 if( n_sectors >= 0xffffffffULL )
1487 tmp = 0xffffffff ; /* Return max count on overflow */
1491 /* sector count, 32-bit */
1492 rbuf[0] = tmp >> (8 * 3);
1493 rbuf[1] = tmp >> (8 * 2);
1494 rbuf[2] = tmp >> (8 * 1);
1498 tmp = ATA_SECT_SIZE;
1503 /* sector count, 64-bit */
1504 tmp = n_sectors >> (8 * 4);
1505 rbuf[2] = tmp >> (8 * 3);
1506 rbuf[3] = tmp >> (8 * 2);
1507 rbuf[4] = tmp >> (8 * 1);
1510 rbuf[6] = tmp >> (8 * 3);
1511 rbuf[7] = tmp >> (8 * 2);
1512 rbuf[8] = tmp >> (8 * 1);
1516 tmp = ATA_SECT_SIZE;
1517 rbuf[12] = tmp >> 8;
1525 * ata_scsiop_report_luns - Simulate REPORT LUNS command
1526 * @args: device IDENTIFY data / SCSI command of interest.
1527 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1528 * @buflen: Response buffer length.
1530 * Simulate REPORT LUNS command.
1533 * spin_lock_irqsave(host_set lock)
1536 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1537 unsigned int buflen)
1540 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
1546 * ata_scsi_badcmd - End a SCSI request with an error
1547 * @cmd: SCSI request to be handled
1548 * @done: SCSI command completion function
1549 * @asc: SCSI-defined additional sense code
1550 * @ascq: SCSI-defined additional sense code qualifier
1552 * Helper function that completes a SCSI command with
1553 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1554 * and the specified additional sense codes.
1557 * spin_lock_irqsave(host_set lock)
1560 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1563 cmd->result = SAM_STAT_CHECK_CONDITION;
1565 cmd->sense_buffer[0] = 0x70;
1566 cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1567 cmd->sense_buffer[7] = 14 - 8; /* addnl. sense len. FIXME: correct? */
1568 cmd->sense_buffer[12] = asc;
1569 cmd->sense_buffer[13] = ascq;
1574 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1576 struct scsi_cmnd *cmd = qc->scsicmd;
1578 if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1579 DPRINTK("request check condition\n");
1581 cmd->result = SAM_STAT_CHECK_CONDITION;
1587 u8 *scsicmd = cmd->cmnd;
1589 if (scsicmd[0] == INQUIRY) {
1591 unsigned int buflen;
1593 buflen = ata_scsi_rbuf_get(cmd, &buf);
1595 buf[3] = (buf[3] & 0xf0) | 2;
1596 ata_scsi_rbuf_put(cmd, buf);
1598 cmd->result = SAM_STAT_GOOD;
1606 * atapi_xlat - Initialize PACKET taskfile
1607 * @qc: command structure to be initialized
1608 * @scsicmd: SCSI CDB associated with this PACKET command
1611 * spin_lock_irqsave(host_set lock)
1614 * Zero on success, non-zero on failure.
1617 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1619 struct scsi_cmnd *cmd = qc->scsicmd;
1620 struct ata_device *dev = qc->dev;
1621 int using_pio = (dev->flags & ATA_DFLAG_PIO);
1622 int nodata = (cmd->sc_data_direction == DMA_NONE);
1625 /* Check whether ATAPI DMA is safe */
1626 if (ata_check_atapi_dma(qc))
1629 memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1631 qc->complete_fn = atapi_qc_complete;
1633 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1634 if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1635 qc->tf.flags |= ATA_TFLAG_WRITE;
1636 DPRINTK("direction: write\n");
1639 qc->tf.command = ATA_CMD_PACKET;
1641 /* no data, or PIO data xfer */
1642 if (using_pio || nodata) {
1644 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1646 qc->tf.protocol = ATA_PROT_ATAPI;
1647 qc->tf.lbam = (8 * 1024) & 0xff;
1648 qc->tf.lbah = (8 * 1024) >> 8;
1653 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1654 qc->tf.feature |= ATAPI_PKT_DMA;
1656 #ifdef ATAPI_ENABLE_DMADIR
1657 /* some SATA bridges need us to indicate data xfer direction */
1658 if (cmd->sc_data_direction != DMA_TO_DEVICE)
1659 qc->tf.feature |= ATAPI_DMADIR;
1663 qc->nbytes = cmd->bufflen;
1669 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1670 * @ap: ATA port to which the device is attached
1671 * @scsidev: SCSI device from which we derive the ATA device
1673 * Given various information provided in struct scsi_cmnd,
1674 * map that onto an ATA bus, and using that mapping
1675 * determine which ata_device is associated with the
1676 * SCSI command to be sent.
1679 * spin_lock_irqsave(host_set lock)
1682 * Associated ATA device, or %NULL if not found.
1685 static struct ata_device *
1686 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1688 struct ata_device *dev;
1690 /* skip commands not addressed to targets we simulate */
1691 if (likely(scsidev->id < ATA_MAX_DEVICES))
1692 dev = &ap->device[scsidev->id];
1696 if (unlikely((scsidev->channel != 0) ||
1697 (scsidev->lun != 0)))
1700 if (unlikely(!ata_dev_present(dev)))
1703 #ifndef ATA_ENABLE_ATAPI
1704 if (unlikely(dev->class == ATA_DEV_ATAPI))
1712 * ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
1713 * @byte1: Byte 1 from pass-thru CDB.
1716 * ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
1719 ata_scsi_map_proto(u8 byte1)
1721 switch((byte1 & 0x1e) >> 1) {
1722 case 3: /* Non-data */
1723 return ATA_PROT_NODATA;
1726 return ATA_PROT_DMA;
1728 case 4: /* PIO Data-in */
1729 case 5: /* PIO Data-out */
1731 return ATA_PROT_PIO_MULT;
1733 return ATA_PROT_PIO;
1735 case 10: /* Device Reset */
1736 case 0: /* Hard Reset */
1738 case 2: /* Bus Idle */
1739 case 7: /* Packet */
1740 case 8: /* DMA Queued */
1741 case 9: /* Device Diagnostic */
1742 case 11: /* UDMA Data-in */
1743 case 12: /* UDMA Data-Out */
1744 case 13: /* FPDMA */
1745 default: /* Reserved */
1749 return ATA_PROT_UNKNOWN;
1753 * ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
1754 * @qc: command structure to be initialized
1755 * @cmd: SCSI command to convert
1757 * Handles either 12 or 16-byte versions of the CDB.
1760 * Zero on success, non-zero on failure.
1763 ata_scsi_pass_thru(struct ata_queued_cmd *qc, u8 *scsicmd)
1765 struct ata_taskfile *tf = &(qc->tf);
1766 struct scsi_cmnd *cmd = qc->scsicmd;
1768 if ((tf->protocol = ata_scsi_map_proto(scsicmd[1])) == ATA_PROT_UNKNOWN)
1772 * 12 and 16 byte CDBs use different offsets to
1773 * provide the various register values.
1775 if (scsicmd[0] == ATA_16) {
1777 * 16-byte CDB - may contain extended commands.
1779 * If that is the case, copy the upper byte register values.
1781 if (scsicmd[1] & 0x01) {
1782 tf->hob_feature = scsicmd[3];
1783 tf->hob_nsect = scsicmd[5];
1784 tf->hob_lbal = scsicmd[7];
1785 tf->hob_lbam = scsicmd[9];
1786 tf->hob_lbah = scsicmd[11];
1787 tf->flags |= ATA_TFLAG_LBA48;
1789 tf->flags &= ~ATA_TFLAG_LBA48;
1792 * Always copy low byte, device and command registers.
1794 tf->feature = scsicmd[4];
1795 tf->nsect = scsicmd[6];
1796 tf->lbal = scsicmd[8];
1797 tf->lbam = scsicmd[10];
1798 tf->lbah = scsicmd[12];
1799 tf->device = scsicmd[13];
1800 tf->command = scsicmd[14];
1803 * 12-byte CDB - incapable of extended commands.
1805 tf->flags &= ~ATA_TFLAG_LBA48;
1807 tf->feature = scsicmd[3];
1808 tf->nsect = scsicmd[4];
1809 tf->lbal = scsicmd[5];
1810 tf->lbam = scsicmd[6];
1811 tf->lbah = scsicmd[7];
1812 tf->device = scsicmd[8];
1813 tf->command = scsicmd[9];
1817 * Filter SET_FEATURES - XFER MODE command -- otherwise,
1818 * SET_FEATURES - XFER MODE must be preceded/succeeded
1819 * by an update to hardware-specific registers for each
1820 * controller (i.e. the reason for ->set_piomode(),
1821 * ->set_dmamode(), and ->post_set_mode() hooks).
1823 if ((tf->command == ATA_CMD_SET_FEATURES)
1824 && (tf->feature == SETFEATURES_XFER))
1828 * Set flags so that all registers will be written,
1829 * and pass on write indication (used for PIO/DMA
1832 tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
1834 if (cmd->sc_data_direction == DMA_TO_DEVICE)
1835 tf->flags |= ATA_TFLAG_WRITE;
1838 * Set transfer length.
1840 * TODO: find out if we need to do more here to
1841 * cover scatter/gather case.
1843 qc->nsect = cmd->bufflen / ATA_SECT_SIZE;
1849 * ata_get_xlat_func - check if SCSI to ATA translation is possible
1851 * @cmd: SCSI command opcode to consider
1853 * Look up the SCSI command given, and determine whether the
1854 * SCSI command is to be translated or simulated.
1857 * Pointer to translation function if possible, %NULL if not.
1860 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1870 return ata_scsi_rw_xlat;
1872 case SYNCHRONIZE_CACHE:
1873 if (ata_try_flush_cache(dev))
1874 return ata_scsi_flush_xlat;
1879 return ata_scsi_verify_xlat;
1883 return ata_scsi_pass_thru;
1890 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1891 * @ap: ATA port to which the command was being sent
1892 * @cmd: SCSI command to dump
1894 * Prints the contents of a SCSI command via printk().
1897 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1898 struct scsi_cmnd *cmd)
1901 struct scsi_device *scsidev = cmd->device;
1902 u8 *scsicmd = cmd->cmnd;
1904 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1906 scsidev->channel, scsidev->id, scsidev->lun,
1907 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1908 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1914 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1915 * @cmd: SCSI command to be sent
1916 * @done: Completion function, called when command is complete
1918 * In some cases, this function translates SCSI commands into
1919 * ATA taskfiles, and queues the taskfiles to be sent to
1920 * hardware. In other cases, this function simulates a
1921 * SCSI device by evaluating and responding to certain
1922 * SCSI commands. This creates the overall effect of
1923 * ATA and ATAPI devices appearing as SCSI devices.
1926 * Releases scsi-layer-held lock, and obtains host_set lock.
1932 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1934 struct ata_port *ap;
1935 struct ata_device *dev;
1936 struct scsi_device *scsidev = cmd->device;
1938 ap = (struct ata_port *) &scsidev->host->hostdata[0];
1940 ata_scsi_dump_cdb(ap, cmd);
1942 dev = ata_scsi_find_dev(ap, scsidev);
1943 if (unlikely(!dev)) {
1944 cmd->result = (DID_BAD_TARGET << 16);
1949 if (dev->class == ATA_DEV_ATA) {
1950 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1954 ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1956 ata_scsi_simulate(dev->id, cmd, done);
1958 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1965 * ata_scsi_simulate - simulate SCSI command on ATA device
1966 * @id: current IDENTIFY data for target device.
1967 * @cmd: SCSI command being sent to device.
1968 * @done: SCSI command completion function.
1970 * Interprets and directly executes a select list of SCSI commands
1971 * that can be handled internally.
1974 * spin_lock_irqsave(host_set lock)
1977 void ata_scsi_simulate(u16 *id,
1978 struct scsi_cmnd *cmd,
1979 void (*done)(struct scsi_cmnd *))
1981 struct ata_scsi_args args;
1982 u8 *scsicmd = cmd->cmnd;
1988 switch(scsicmd[0]) {
1989 /* no-op's, complete with success */
1990 case SYNCHRONIZE_CACHE:
1994 case TEST_UNIT_READY:
1995 case FORMAT_UNIT: /* FIXME: correct? */
1996 case SEND_DIAGNOSTIC: /* FIXME: correct? */
1997 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
2001 if (scsicmd[1] & 2) /* is CmdDt set? */
2002 ata_bad_cdb(cmd, done);
2003 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
2004 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
2005 else if (scsicmd[2] == 0x00)
2006 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
2007 else if (scsicmd[2] == 0x80)
2008 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
2009 else if (scsicmd[2] == 0x83)
2010 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
2012 ata_bad_cdb(cmd, done);
2017 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
2020 case MODE_SELECT: /* unconditionally return */
2021 case MODE_SELECT_10: /* bad-field-in-cdb */
2022 ata_bad_cdb(cmd, done);
2026 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2029 case SERVICE_ACTION_IN:
2030 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
2031 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2033 ata_bad_cdb(cmd, done);
2037 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
2040 /* mandatory commands we haven't implemented yet */
2043 /* all other commands */
2045 ata_bad_scsiop(cmd, done);