2 * libata-scsi.c - helper library for ATA
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
8 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 * Copyright 2003-2004 Jeff Garzik
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
30 * Hardware documentation available from
31 * - http://www.t10.org/
32 * - http://www.t13.org/
36 #include <linux/kernel.h>
37 #include <linux/blkdev.h>
38 #include <linux/spinlock.h>
39 #include <scsi/scsi.h>
40 #include <scsi/scsi_host.h>
41 #include <scsi/scsi_cmnd.h>
42 #include <scsi/scsi_eh.h>
43 #include <scsi/scsi_device.h>
44 #include <scsi/scsi_tcq.h>
45 #include <scsi/scsi_transport.h>
46 #include <linux/libata.h>
47 #include <linux/hdreg.h>
48 #include <linux/uaccess.h>
52 #define SECTOR_SIZE 512
54 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc);
56 static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
57 const struct scsi_device *scsidev);
58 static struct ata_device *ata_scsi_find_dev(struct ata_port *ap,
59 const struct scsi_device *scsidev);
60 static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
61 unsigned int id, unsigned int lun);
64 #define RW_RECOVERY_MPAGE 0x1
65 #define RW_RECOVERY_MPAGE_LEN 12
66 #define CACHE_MPAGE 0x8
67 #define CACHE_MPAGE_LEN 20
68 #define CONTROL_MPAGE 0xa
69 #define CONTROL_MPAGE_LEN 12
70 #define ALL_MPAGES 0x3f
71 #define ALL_SUB_MPAGES 0xff
74 static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = {
76 RW_RECOVERY_MPAGE_LEN - 2,
78 0, /* read retry count */
80 0, /* write retry count */
84 static const u8 def_cache_mpage[CACHE_MPAGE_LEN] = {
87 0, /* contains WCE, needs to be 0 for logic */
88 0, 0, 0, 0, 0, 0, 0, 0, 0,
89 0, /* contains DRA, needs to be 0 for logic */
93 static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
95 CONTROL_MPAGE_LEN - 2,
96 2, /* DSENSE=0, GLTSD=1 */
97 0, /* [QAM+QERR may be 1, see 05-359r1] */
98 0, 0, 0, 0, 0xff, 0xff,
99 0, 30 /* extended self test time, see 05-359r1 */
103 * libata transport template. libata doesn't do real transport stuff.
104 * It just needs the eh_timed_out hook.
106 static struct scsi_transport_template ata_scsi_transport_template = {
107 .eh_strategy_handler = ata_scsi_error,
108 .eh_timed_out = ata_scsi_timed_out,
109 .user_scan = ata_scsi_user_scan,
113 static const struct {
116 } link_pm_policy[] = {
117 { NOT_AVAILABLE, "max_performance" },
118 { MIN_POWER, "min_power" },
119 { MAX_PERFORMANCE, "max_performance" },
120 { MEDIUM_POWER, "medium_power" },
123 const char *ata_scsi_lpm_get(enum link_pm policy)
127 for (i = 0; i < ARRAY_SIZE(link_pm_policy); i++)
128 if (link_pm_policy[i].value == policy)
129 return link_pm_policy[i].name;
134 static ssize_t ata_scsi_lpm_put(struct class_device *class_dev,
135 const char *buf, size_t count)
137 struct Scsi_Host *shost = class_to_shost(class_dev);
138 struct ata_port *ap = ata_shost_to_port(shost);
139 enum link_pm policy = 0;
143 * we are skipping array location 0 on purpose - this
144 * is because a value of NOT_AVAILABLE is displayed
145 * to the user as max_performance, but when the user
146 * writes "max_performance", they actually want the
147 * value to match MAX_PERFORMANCE.
149 for (i = 1; i < ARRAY_SIZE(link_pm_policy); i++) {
150 const int len = strlen(link_pm_policy[i].name);
151 if (strncmp(link_pm_policy[i].name, buf, len) == 0 &&
153 policy = link_pm_policy[i].value;
160 ata_lpm_schedule(ap, policy);
165 ata_scsi_lpm_show(struct class_device *class_dev, char *buf)
167 struct Scsi_Host *shost = class_to_shost(class_dev);
168 struct ata_port *ap = ata_shost_to_port(shost);
170 ata_scsi_lpm_get(ap->pm_policy);
175 return snprintf(buf, 23, "%s\n", policy);
177 CLASS_DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
178 ata_scsi_lpm_show, ata_scsi_lpm_put);
179 EXPORT_SYMBOL_GPL(class_device_attr_link_power_management_policy);
181 static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
182 void (*done)(struct scsi_cmnd *))
184 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x24, 0x0);
185 /* "Invalid field in cbd" */
190 * ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
191 * @sdev: SCSI device for which BIOS geometry is to be determined
192 * @bdev: block device associated with @sdev
193 * @capacity: capacity of SCSI device
194 * @geom: location to which geometry will be output
196 * Generic bios head/sector/cylinder calculator
197 * used by sd. Most BIOSes nowadays expect a XXX/255/16 (CHS)
198 * mapping. Some situations may arise where the disk is not
199 * bootable if this is not used.
202 * Defined by the SCSI layer. We don't really care.
207 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
208 sector_t capacity, int geom[])
212 sector_div(capacity, 255*63);
219 * ata_get_identity - Handler for HDIO_GET_IDENTITY ioctl
220 * @sdev: SCSI device to get identify data for
221 * @arg: User buffer area for identify data
224 * Defined by the SCSI layer. We don't really care.
227 * Zero on success, negative errno on error.
229 static int ata_get_identity(struct scsi_device *sdev, void __user *arg)
231 struct ata_port *ap = ata_shost_to_port(sdev->host);
232 struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
233 u16 __user *dst = arg;
239 if (copy_to_user(dst, dev->id, ATA_ID_WORDS * sizeof(u16)))
242 ata_id_string(dev->id, buf, ATA_ID_PROD, ATA_ID_PROD_LEN);
243 if (copy_to_user(dst + ATA_ID_PROD, buf, ATA_ID_PROD_LEN))
246 ata_id_string(dev->id, buf, ATA_ID_FW_REV, ATA_ID_FW_REV_LEN);
247 if (copy_to_user(dst + ATA_ID_FW_REV, buf, ATA_ID_FW_REV_LEN))
250 ata_id_string(dev->id, buf, ATA_ID_SERNO, ATA_ID_SERNO_LEN);
251 if (copy_to_user(dst + ATA_ID_SERNO, buf, ATA_ID_SERNO_LEN))
258 * ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
259 * @scsidev: Device to which we are issuing command
260 * @arg: User provided data for issuing command
263 * Defined by the SCSI layer. We don't really care.
266 * Zero on success, negative errno on error.
268 int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
271 u8 scsi_cmd[MAX_COMMAND_SIZE];
272 u8 args[4], *argbuf = NULL, *sensebuf = NULL;
274 enum dma_data_direction data_dir;
280 if (copy_from_user(args, arg, sizeof(args)))
283 sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
287 memset(scsi_cmd, 0, sizeof(scsi_cmd));
290 argsize = SECTOR_SIZE * args[3];
291 argbuf = kmalloc(argsize, GFP_KERNEL);
292 if (argbuf == NULL) {
297 scsi_cmd[1] = (4 << 1); /* PIO Data-in */
298 scsi_cmd[2] = 0x0e; /* no off.line or cc, read from dev,
299 block count in sector count field */
300 data_dir = DMA_FROM_DEVICE;
302 scsi_cmd[1] = (3 << 1); /* Non-data */
303 scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
307 scsi_cmd[0] = ATA_16;
309 scsi_cmd[4] = args[2];
310 if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
311 scsi_cmd[6] = args[3];
312 scsi_cmd[8] = args[1];
316 scsi_cmd[6] = args[1];
318 scsi_cmd[14] = args[0];
320 /* Good values for timeout and retries? Values below
321 from scsi_ioctl_send_command() for default case... */
322 cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
323 sensebuf, (10*HZ), 5, 0);
325 if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
326 u8 *desc = sensebuf + 8;
327 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
329 /* If we set cc then ATA pass-through will cause a
330 * check condition even if no error. Filter that. */
331 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
332 struct scsi_sense_hdr sshdr;
333 scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
335 if (sshdr.sense_key == 0 &&
336 sshdr.asc == 0 && sshdr.ascq == 0)
337 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
340 /* Send userspace a few ATA registers (same as drivers/ide) */
341 if (sensebuf[0] == 0x72 && /* format is "descriptor" */
342 desc[0] == 0x09) { /* code is "ATA Descriptor" */
343 args[0] = desc[13]; /* status */
344 args[1] = desc[3]; /* error */
345 args[2] = desc[5]; /* sector count (0:7) */
346 if (copy_to_user(arg, args, sizeof(args)))
358 && copy_to_user(arg + sizeof(args), argbuf, argsize))
367 * ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
368 * @scsidev: Device to which we are issuing command
369 * @arg: User provided data for issuing command
372 * Defined by the SCSI layer. We don't really care.
375 * Zero on success, negative errno on error.
377 int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
380 u8 scsi_cmd[MAX_COMMAND_SIZE];
381 u8 args[7], *sensebuf = NULL;
387 if (copy_from_user(args, arg, sizeof(args)))
390 sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
394 memset(scsi_cmd, 0, sizeof(scsi_cmd));
395 scsi_cmd[0] = ATA_16;
396 scsi_cmd[1] = (3 << 1); /* Non-data */
397 scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
398 scsi_cmd[4] = args[1];
399 scsi_cmd[6] = args[2];
400 scsi_cmd[8] = args[3];
401 scsi_cmd[10] = args[4];
402 scsi_cmd[12] = args[5];
403 scsi_cmd[13] = args[6] & 0x4f;
404 scsi_cmd[14] = args[0];
406 /* Good values for timeout and retries? Values below
407 from scsi_ioctl_send_command() for default case... */
408 cmd_result = scsi_execute(scsidev, scsi_cmd, DMA_NONE, NULL, 0,
409 sensebuf, (10*HZ), 5, 0);
411 if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
412 u8 *desc = sensebuf + 8;
413 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
415 /* If we set cc then ATA pass-through will cause a
416 * check condition even if no error. Filter that. */
417 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
418 struct scsi_sense_hdr sshdr;
419 scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
421 if (sshdr.sense_key == 0 &&
422 sshdr.asc == 0 && sshdr.ascq == 0)
423 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
426 /* Send userspace ATA registers */
427 if (sensebuf[0] == 0x72 && /* format is "descriptor" */
428 desc[0] == 0x09) {/* code is "ATA Descriptor" */
429 args[0] = desc[13]; /* status */
430 args[1] = desc[3]; /* error */
431 args[2] = desc[5]; /* sector count (0:7) */
432 args[3] = desc[7]; /* lbal */
433 args[4] = desc[9]; /* lbam */
434 args[5] = desc[11]; /* lbah */
435 args[6] = desc[12]; /* select */
436 if (copy_to_user(arg, args, sizeof(args)))
451 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
453 int val = -EINVAL, rc = -EINVAL;
456 case ATA_IOC_GET_IO32:
458 if (copy_to_user(arg, &val, 1))
462 case ATA_IOC_SET_IO32:
463 val = (unsigned long) arg;
468 case HDIO_GET_IDENTITY:
469 return ata_get_identity(scsidev, arg);
472 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
474 return ata_cmd_ioctl(scsidev, arg);
476 case HDIO_DRIVE_TASK:
477 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
479 return ata_task_ioctl(scsidev, arg);
490 * ata_scsi_qc_new - acquire new ata_queued_cmd reference
491 * @dev: ATA device to which the new command is attached
492 * @cmd: SCSI command that originated this ATA command
493 * @done: SCSI command completion function
495 * Obtain a reference to an unused ata_queued_cmd structure,
496 * which is the basic libata structure representing a single
497 * ATA command sent to the hardware.
499 * If a command was available, fill in the SCSI-specific
500 * portions of the structure with information on the
504 * spin_lock_irqsave(host lock)
507 * Command allocated, or %NULL if none available.
509 static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
510 struct scsi_cmnd *cmd,
511 void (*done)(struct scsi_cmnd *))
513 struct ata_queued_cmd *qc;
515 qc = ata_qc_new_init(dev);
520 qc->__sg = scsi_sglist(cmd);
521 qc->n_elem = scsi_sg_count(cmd);
523 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
531 * ata_dump_status - user friendly display of error info
532 * @id: id of the port in question
533 * @tf: ptr to filled out taskfile
535 * Decode and dump the ATA error/status registers for the user so
536 * that they have some idea what really happened at the non
537 * make-believe layer.
540 * inherited from caller
542 static void ata_dump_status(unsigned id, struct ata_taskfile *tf)
544 u8 stat = tf->command, err = tf->feature;
546 printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
547 if (stat & ATA_BUSY) {
548 printk("Busy }\n"); /* Data is not valid in this case */
550 if (stat & 0x40) printk("DriveReady ");
551 if (stat & 0x20) printk("DeviceFault ");
552 if (stat & 0x10) printk("SeekComplete ");
553 if (stat & 0x08) printk("DataRequest ");
554 if (stat & 0x04) printk("CorrectedError ");
555 if (stat & 0x02) printk("Index ");
556 if (stat & 0x01) printk("Error ");
560 printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
561 if (err & 0x04) printk("DriveStatusError ");
563 if (err & 0x04) printk("BadCRC ");
564 else printk("Sector ");
566 if (err & 0x40) printk("UncorrectableError ");
567 if (err & 0x10) printk("SectorIdNotFound ");
568 if (err & 0x02) printk("TrackZeroNotFound ");
569 if (err & 0x01) printk("AddrMarkNotFound ");
576 * ata_to_sense_error - convert ATA error to SCSI error
577 * @id: ATA device number
578 * @drv_stat: value contained in ATA status register
579 * @drv_err: value contained in ATA error register
580 * @sk: the sense key we'll fill out
581 * @asc: the additional sense code we'll fill out
582 * @ascq: the additional sense code qualifier we'll fill out
583 * @verbose: be verbose
585 * Converts an ATA error into a SCSI error. Fill out pointers to
586 * SK, ASC, and ASCQ bytes for later use in fixed or descriptor
587 * format sense blocks.
590 * spin_lock_irqsave(host lock)
592 static void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk,
593 u8 *asc, u8 *ascq, int verbose)
597 /* Based on the 3ware driver translation table */
598 static const unsigned char sense_table[][4] = {
600 {0xd1, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
602 {0xd0, ABORTED_COMMAND, 0x00, 0x00}, // Device busy Aborted command
604 {0x61, HARDWARE_ERROR, 0x00, 0x00}, // Device fault Hardware error
605 /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
606 {0x84, ABORTED_COMMAND, 0x47, 0x00}, // Data CRC error SCSI parity error
607 /* MC|ID|ABRT|TRK0|MARK */
608 {0x37, NOT_READY, 0x04, 0x00}, // Unit offline Not ready
610 {0x09, NOT_READY, 0x04, 0x00}, // Unrecovered disk error Not ready
611 /* Bad address mark */
612 {0x01, MEDIUM_ERROR, 0x13, 0x00}, // Address mark not found Address mark not found for data field
614 {0x02, HARDWARE_ERROR, 0x00, 0x00}, // Track 0 not found Hardware error
616 {0x04, ABORTED_COMMAND, 0x00, 0x00}, // Aborted command Aborted command
617 /* Media change request */
618 {0x08, NOT_READY, 0x04, 0x00}, // Media change request FIXME: faking offline
620 {0x10, ABORTED_COMMAND, 0x14, 0x00}, // ID not found Recorded entity not found
622 {0x08, NOT_READY, 0x04, 0x00}, // Media change FIXME: faking offline
624 {0x40, MEDIUM_ERROR, 0x11, 0x04}, // Uncorrectable ECC error Unrecovered read error
625 /* BBD - block marked bad */
626 {0x80, MEDIUM_ERROR, 0x11, 0x04}, // Block marked bad Medium error, unrecovered read error
627 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
629 static const unsigned char stat_table[][4] = {
630 /* Must be first because BUSY means no other bits valid */
631 {0x80, ABORTED_COMMAND, 0x47, 0x00}, // Busy, fake parity for now
632 {0x20, HARDWARE_ERROR, 0x00, 0x00}, // Device fault
633 {0x08, ABORTED_COMMAND, 0x47, 0x00}, // Timed out in xfer, fake parity for now
634 {0x04, RECOVERED_ERROR, 0x11, 0x00}, // Recovered ECC error Medium error, recovered
635 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
639 * Is this an error we can process/parse
641 if (drv_stat & ATA_BUSY) {
642 drv_err = 0; /* Ignore the err bits, they're invalid */
646 /* Look for drv_err */
647 for (i = 0; sense_table[i][0] != 0xFF; i++) {
648 /* Look for best matches first */
649 if ((sense_table[i][0] & drv_err) ==
651 *sk = sense_table[i][1];
652 *asc = sense_table[i][2];
653 *ascq = sense_table[i][3];
657 /* No immediate match */
659 printk(KERN_WARNING "ata%u: no sense translation for "
660 "error 0x%02x\n", id, drv_err);
663 /* Fall back to interpreting status bits */
664 for (i = 0; stat_table[i][0] != 0xFF; i++) {
665 if (stat_table[i][0] & drv_stat) {
666 *sk = stat_table[i][1];
667 *asc = stat_table[i][2];
668 *ascq = stat_table[i][3];
672 /* No error? Undecoded? */
674 printk(KERN_WARNING "ata%u: no sense translation for "
675 "status: 0x%02x\n", id, drv_stat);
677 /* We need a sensible error return here, which is tricky, and one
678 that won't cause people to do things like return a disk wrongly */
679 *sk = ABORTED_COMMAND;
685 printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x "
686 "to SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n",
687 id, drv_stat, drv_err, *sk, *asc, *ascq);
692 * ata_gen_passthru_sense - Generate check condition sense block.
693 * @qc: Command that completed.
695 * This function is specific to the ATA descriptor format sense
696 * block specified for the ATA pass through commands. Regardless
697 * of whether the command errored or not, return a sense
698 * block. Copy all controller registers into the sense
699 * block. Clear sense key, ASC & ASCQ if there is no error.
704 static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
706 struct scsi_cmnd *cmd = qc->scsicmd;
707 struct ata_taskfile *tf = &qc->result_tf;
708 unsigned char *sb = cmd->sense_buffer;
709 unsigned char *desc = sb + 8;
710 int verbose = qc->ap->ops->error_handler == NULL;
712 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
714 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
717 * Use ata_to_sense_error() to map status register bits
718 * onto sense key, asc & ascq.
721 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
722 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
723 &sb[1], &sb[2], &sb[3], verbose);
728 * Sense data is current and format is descriptor.
734 /* set length of additional sense data */
739 * Copy registers into sense buffer.
742 desc[3] = tf->feature; /* == error reg */
747 desc[12] = tf->device;
748 desc[13] = tf->command; /* == status reg */
751 * Fill in Extend bit, and the high order bytes
754 if (tf->flags & ATA_TFLAG_LBA48) {
756 desc[4] = tf->hob_nsect;
757 desc[6] = tf->hob_lbal;
758 desc[8] = tf->hob_lbam;
759 desc[10] = tf->hob_lbah;
764 * ata_gen_ata_sense - generate a SCSI fixed sense block
765 * @qc: Command that we are erroring out
767 * Generate sense block for a failed ATA command @qc. Descriptor
768 * format is used to accomodate LBA48 block address.
773 static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
775 struct ata_device *dev = qc->dev;
776 struct scsi_cmnd *cmd = qc->scsicmd;
777 struct ata_taskfile *tf = &qc->result_tf;
778 unsigned char *sb = cmd->sense_buffer;
779 unsigned char *desc = sb + 8;
780 int verbose = qc->ap->ops->error_handler == NULL;
783 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
785 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
787 /* sense data is current and format is descriptor */
790 /* Use ata_to_sense_error() to map status register bits
791 * onto sense key, asc & ascq.
794 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
795 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
796 &sb[1], &sb[2], &sb[3], verbose);
800 block = ata_tf_read_block(&qc->result_tf, dev);
802 /* information sense data descriptor */
807 desc[2] |= 0x80; /* valid */
808 desc[6] = block >> 40;
809 desc[7] = block >> 32;
810 desc[8] = block >> 24;
811 desc[9] = block >> 16;
812 desc[10] = block >> 8;
816 static void ata_scsi_sdev_config(struct scsi_device *sdev)
818 sdev->use_10_for_rw = 1;
819 sdev->use_10_for_ms = 1;
821 /* Schedule policy is determined by ->qc_defer() callback and
822 * it needs to see every deferred qc. Set dev_blocked to 1 to
823 * prevent SCSI midlayer from automatically deferring
826 sdev->max_device_blocked = 1;
829 static void ata_scsi_dev_config(struct scsi_device *sdev,
830 struct ata_device *dev)
832 /* configure max sectors */
833 blk_queue_max_sectors(sdev->request_queue, dev->max_sectors);
835 /* SATA DMA transfers must be multiples of 4 byte, so
836 * we need to pad ATAPI transfers using an extra sg.
837 * Decrement max hw segments accordingly.
839 if (dev->class == ATA_DEV_ATAPI) {
840 struct request_queue *q = sdev->request_queue;
841 blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
844 if (dev->flags & ATA_DFLAG_NCQ) {
847 depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
848 depth = min(ATA_MAX_QUEUE - 1, depth);
849 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
854 * ata_scsi_slave_config - Set SCSI device attributes
855 * @sdev: SCSI device to examine
857 * This is called before we actually start reading
858 * and writing to the device, to configure certain
859 * SCSI mid-layer behaviors.
862 * Defined by SCSI layer. We don't really care.
865 int ata_scsi_slave_config(struct scsi_device *sdev)
867 struct ata_port *ap = ata_shost_to_port(sdev->host);
868 struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
870 ata_scsi_sdev_config(sdev);
872 sdev->manage_start_stop = 1;
875 ata_scsi_dev_config(sdev, dev);
877 return 0; /* scsi layer doesn't check return value, sigh */
881 * ata_scsi_slave_destroy - SCSI device is about to be destroyed
882 * @sdev: SCSI device to be destroyed
884 * @sdev is about to be destroyed for hot/warm unplugging. If
885 * this unplugging was initiated by libata as indicated by NULL
886 * dev->sdev, this function doesn't have to do anything.
887 * Otherwise, SCSI layer initiated warm-unplug is in progress.
888 * Clear dev->sdev, schedule the device for ATA detach and invoke
892 * Defined by SCSI layer. We don't really care.
894 void ata_scsi_slave_destroy(struct scsi_device *sdev)
896 struct ata_port *ap = ata_shost_to_port(sdev->host);
898 struct ata_device *dev;
900 if (!ap->ops->error_handler)
903 spin_lock_irqsave(ap->lock, flags);
904 dev = __ata_scsi_find_dev(ap, sdev);
905 if (dev && dev->sdev) {
906 /* SCSI device already in CANCEL state, no need to offline it */
908 dev->flags |= ATA_DFLAG_DETACH;
909 ata_port_schedule_eh(ap);
911 spin_unlock_irqrestore(ap->lock, flags);
915 * ata_scsi_change_queue_depth - SCSI callback for queue depth config
916 * @sdev: SCSI device to configure queue depth for
917 * @queue_depth: new queue depth
919 * This is libata standard hostt->change_queue_depth callback.
920 * SCSI will call into this callback when user tries to set queue
924 * SCSI layer (we don't care)
927 * Newly configured queue depth.
929 int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
931 struct ata_port *ap = ata_shost_to_port(sdev->host);
932 struct ata_device *dev;
935 if (queue_depth < 1 || queue_depth == sdev->queue_depth)
936 return sdev->queue_depth;
938 dev = ata_scsi_find_dev(ap, sdev);
939 if (!dev || !ata_dev_enabled(dev))
940 return sdev->queue_depth;
943 spin_lock_irqsave(ap->lock, flags);
944 dev->flags &= ~ATA_DFLAG_NCQ_OFF;
945 if (queue_depth == 1 || !ata_ncq_enabled(dev)) {
946 dev->flags |= ATA_DFLAG_NCQ_OFF;
949 spin_unlock_irqrestore(ap->lock, flags);
951 /* limit and apply queue depth */
952 queue_depth = min(queue_depth, sdev->host->can_queue);
953 queue_depth = min(queue_depth, ata_id_queue_depth(dev->id));
954 queue_depth = min(queue_depth, ATA_MAX_QUEUE - 1);
956 if (sdev->queue_depth == queue_depth)
959 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
963 /* XXX: for spindown warning */
964 static void ata_delayed_done_timerfn(unsigned long arg)
966 struct scsi_cmnd *scmd = (void *)arg;
968 scmd->scsi_done(scmd);
971 /* XXX: for spindown warning */
972 static void ata_delayed_done(struct scsi_cmnd *scmd)
974 static struct timer_list timer;
976 setup_timer(&timer, ata_delayed_done_timerfn, (unsigned long)scmd);
977 mod_timer(&timer, jiffies + 5 * HZ);
981 * ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
982 * @qc: Storage for translated ATA taskfile
984 * Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
985 * (to start). Perhaps these commands should be preceded by
986 * CHECK POWER MODE to see what power mode the device is already in.
987 * [See SAT revision 5 at www.t10.org]
990 * spin_lock_irqsave(host lock)
993 * Zero on success, non-zero on error.
995 static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
997 struct scsi_cmnd *scmd = qc->scsicmd;
998 struct ata_taskfile *tf = &qc->tf;
999 const u8 *cdb = scmd->cmnd;
1001 if (scmd->cmd_len < 5)
1004 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1005 tf->protocol = ATA_PROT_NODATA;
1007 ; /* ignore IMMED bit, violates sat-r05 */
1010 goto invalid_fld; /* LOEJ bit set not supported */
1011 if (((cdb[4] >> 4) & 0xf) != 0)
1012 goto invalid_fld; /* power conditions not supported */
1014 if (qc->dev->horkage & ATA_HORKAGE_SKIP_PM) {
1015 /* the device lacks PM support, finish without doing anything */
1016 scmd->result = SAM_STAT_GOOD;
1021 tf->nsect = 1; /* 1 sector, lba=0 */
1023 if (qc->dev->flags & ATA_DFLAG_LBA) {
1024 tf->flags |= ATA_TFLAG_LBA;
1029 tf->device |= ATA_LBA;
1032 tf->lbal = 0x1; /* sect */
1033 tf->lbam = 0x0; /* cyl low */
1034 tf->lbah = 0x0; /* cyl high */
1037 tf->command = ATA_CMD_VERIFY; /* READ VERIFY */
1039 /* XXX: This is for backward compatibility, will be
1040 * removed. Read Documentation/feature-removal-schedule.txt
1043 if ((qc->dev->flags & ATA_DFLAG_SPUNDOWN) &&
1044 (system_state == SYSTEM_HALT ||
1045 system_state == SYSTEM_POWER_OFF)) {
1046 static unsigned long warned;
1048 if (!test_and_set_bit(0, &warned)) {
1049 ata_dev_printk(qc->dev, KERN_WARNING,
1050 "DISK MIGHT NOT BE SPUN DOWN PROPERLY. "
1051 "UPDATE SHUTDOWN UTILITY\n");
1052 ata_dev_printk(qc->dev, KERN_WARNING,
1053 "For more info, visit "
1054 "http://linux-ata.org/shutdown.html\n");
1056 /* ->scsi_done is not used, use it for
1057 * delayed completion.
1059 scmd->scsi_done = qc->scsidone;
1060 qc->scsidone = ata_delayed_done;
1062 scmd->result = SAM_STAT_GOOD;
1066 /* Issue ATA STANDBY IMMEDIATE command */
1067 tf->command = ATA_CMD_STANDBYNOW1;
1071 * Standby and Idle condition timers could be implemented but that
1072 * would require libata to implement the Power condition mode page
1073 * and allow the user to change it. Changing mode pages requires
1074 * MODE SELECT to be implemented.
1080 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1081 /* "Invalid field in cbd" */
1087 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
1088 * @qc: Storage for translated ATA taskfile
1090 * Sets up an ATA taskfile to issue FLUSH CACHE or
1094 * spin_lock_irqsave(host lock)
1097 * Zero on success, non-zero on error.
1099 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc)
1101 struct ata_taskfile *tf = &qc->tf;
1103 tf->flags |= ATA_TFLAG_DEVICE;
1104 tf->protocol = ATA_PROT_NODATA;
1106 if (qc->dev->flags & ATA_DFLAG_FLUSH_EXT)
1107 tf->command = ATA_CMD_FLUSH_EXT;
1109 tf->command = ATA_CMD_FLUSH;
1115 * scsi_6_lba_len - Get LBA and transfer length
1116 * @cdb: SCSI command to translate
1118 * Calculate LBA and transfer length for 6-byte commands.
1122 * @plen: the transfer length
1124 static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1129 VPRINTK("six-byte command\n");
1131 lba |= ((u64)(cdb[1] & 0x1f)) << 16;
1132 lba |= ((u64)cdb[2]) << 8;
1133 lba |= ((u64)cdb[3]);
1142 * scsi_10_lba_len - Get LBA and transfer length
1143 * @cdb: SCSI command to translate
1145 * Calculate LBA and transfer length for 10-byte commands.
1149 * @plen: the transfer length
1151 static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1156 VPRINTK("ten-byte command\n");
1158 lba |= ((u64)cdb[2]) << 24;
1159 lba |= ((u64)cdb[3]) << 16;
1160 lba |= ((u64)cdb[4]) << 8;
1161 lba |= ((u64)cdb[5]);
1163 len |= ((u32)cdb[7]) << 8;
1164 len |= ((u32)cdb[8]);
1171 * scsi_16_lba_len - Get LBA and transfer length
1172 * @cdb: SCSI command to translate
1174 * Calculate LBA and transfer length for 16-byte commands.
1178 * @plen: the transfer length
1180 static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1185 VPRINTK("sixteen-byte command\n");
1187 lba |= ((u64)cdb[2]) << 56;
1188 lba |= ((u64)cdb[3]) << 48;
1189 lba |= ((u64)cdb[4]) << 40;
1190 lba |= ((u64)cdb[5]) << 32;
1191 lba |= ((u64)cdb[6]) << 24;
1192 lba |= ((u64)cdb[7]) << 16;
1193 lba |= ((u64)cdb[8]) << 8;
1194 lba |= ((u64)cdb[9]);
1196 len |= ((u32)cdb[10]) << 24;
1197 len |= ((u32)cdb[11]) << 16;
1198 len |= ((u32)cdb[12]) << 8;
1199 len |= ((u32)cdb[13]);
1206 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
1207 * @qc: Storage for translated ATA taskfile
1209 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
1212 * spin_lock_irqsave(host lock)
1215 * Zero on success, non-zero on error.
1217 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
1219 struct scsi_cmnd *scmd = qc->scsicmd;
1220 struct ata_taskfile *tf = &qc->tf;
1221 struct ata_device *dev = qc->dev;
1222 u64 dev_sectors = qc->dev->n_sectors;
1223 const u8 *cdb = scmd->cmnd;
1227 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1228 tf->protocol = ATA_PROT_NODATA;
1230 if (cdb[0] == VERIFY) {
1231 if (scmd->cmd_len < 10)
1233 scsi_10_lba_len(cdb, &block, &n_block);
1234 } else if (cdb[0] == VERIFY_16) {
1235 if (scmd->cmd_len < 16)
1237 scsi_16_lba_len(cdb, &block, &n_block);
1243 if (block >= dev_sectors)
1245 if ((block + n_block) > dev_sectors)
1248 if (dev->flags & ATA_DFLAG_LBA) {
1249 tf->flags |= ATA_TFLAG_LBA;
1251 if (lba_28_ok(block, n_block)) {
1253 tf->command = ATA_CMD_VERIFY;
1254 tf->device |= (block >> 24) & 0xf;
1255 } else if (lba_48_ok(block, n_block)) {
1256 if (!(dev->flags & ATA_DFLAG_LBA48))
1260 tf->flags |= ATA_TFLAG_LBA48;
1261 tf->command = ATA_CMD_VERIFY_EXT;
1263 tf->hob_nsect = (n_block >> 8) & 0xff;
1265 tf->hob_lbah = (block >> 40) & 0xff;
1266 tf->hob_lbam = (block >> 32) & 0xff;
1267 tf->hob_lbal = (block >> 24) & 0xff;
1269 /* request too large even for LBA48 */
1272 tf->nsect = n_block & 0xff;
1274 tf->lbah = (block >> 16) & 0xff;
1275 tf->lbam = (block >> 8) & 0xff;
1276 tf->lbal = block & 0xff;
1278 tf->device |= ATA_LBA;
1281 u32 sect, head, cyl, track;
1283 if (!lba_28_ok(block, n_block))
1286 /* Convert LBA to CHS */
1287 track = (u32)block / dev->sectors;
1288 cyl = track / dev->heads;
1289 head = track % dev->heads;
1290 sect = (u32)block % dev->sectors + 1;
1292 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1293 (u32)block, track, cyl, head, sect);
1295 /* Check whether the converted CHS can fit.
1299 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
1302 tf->command = ATA_CMD_VERIFY;
1303 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
1306 tf->lbah = cyl >> 8;
1313 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1314 /* "Invalid field in cbd" */
1318 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1319 /* "Logical Block Address out of range" */
1323 scmd->result = SAM_STAT_GOOD;
1328 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
1329 * @qc: Storage for translated ATA taskfile
1331 * Converts any of six SCSI read/write commands into the
1332 * ATA counterpart, including starting sector (LBA),
1333 * sector count, and taking into account the device's LBA48
1336 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
1337 * %WRITE_16 are currently supported.
1340 * spin_lock_irqsave(host lock)
1343 * Zero on success, non-zero on error.
1345 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
1347 struct scsi_cmnd *scmd = qc->scsicmd;
1348 const u8 *cdb = scmd->cmnd;
1349 unsigned int tf_flags = 0;
1354 if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
1355 tf_flags |= ATA_TFLAG_WRITE;
1357 /* Calculate the SCSI LBA, transfer length and FUA. */
1361 if (unlikely(scmd->cmd_len < 10))
1363 scsi_10_lba_len(cdb, &block, &n_block);
1364 if (unlikely(cdb[1] & (1 << 3)))
1365 tf_flags |= ATA_TFLAG_FUA;
1369 if (unlikely(scmd->cmd_len < 6))
1371 scsi_6_lba_len(cdb, &block, &n_block);
1373 /* for 6-byte r/w commands, transfer length 0
1374 * means 256 blocks of data, not 0 block.
1381 if (unlikely(scmd->cmd_len < 16))
1383 scsi_16_lba_len(cdb, &block, &n_block);
1384 if (unlikely(cdb[1] & (1 << 3)))
1385 tf_flags |= ATA_TFLAG_FUA;
1388 DPRINTK("no-byte command\n");
1392 /* Check and compose ATA command */
1394 /* For 10-byte and 16-byte SCSI R/W commands, transfer
1395 * length 0 means transfer 0 block of data.
1396 * However, for ATA R/W commands, sector count 0 means
1397 * 256 or 65536 sectors, not 0 sectors as in SCSI.
1399 * WARNING: one or two older ATA drives treat 0 as 0...
1403 qc->flags |= ATA_QCFLAG_IO;
1404 qc->nbytes = n_block * ATA_SECT_SIZE;
1406 rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
1408 if (likely(rc == 0))
1413 /* treat all other errors as -EINVAL, fall through */
1415 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1416 /* "Invalid field in cbd" */
1420 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1421 /* "Logical Block Address out of range" */
1425 scmd->result = SAM_STAT_GOOD;
1429 static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
1431 struct ata_port *ap = qc->ap;
1432 struct scsi_cmnd *cmd = qc->scsicmd;
1433 u8 *cdb = cmd->cmnd;
1434 int need_sense = (qc->err_mask != 0);
1436 /* For ATA pass thru (SAT) commands, generate a sense block if
1437 * user mandated it or if there's an error. Note that if we
1438 * generate because the user forced us to, a check condition
1439 * is generated and the ATA register values are returned
1440 * whether the command completed successfully or not. If there
1441 * was no error, SK, ASC and ASCQ will all be zero.
1443 if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
1444 ((cdb[2] & 0x20) || need_sense)) {
1445 ata_gen_passthru_sense(qc);
1448 cmd->result = SAM_STAT_GOOD;
1450 /* TODO: decide which descriptor format to use
1451 * for 48b LBA devices and call that here
1452 * instead of the fixed desc, which is only
1453 * good for smaller LBA (and maybe CHS?)
1456 ata_gen_ata_sense(qc);
1460 /* XXX: track spindown state for spindown skipping and warning */
1461 if (unlikely(qc->tf.command == ATA_CMD_STANDBY ||
1462 qc->tf.command == ATA_CMD_STANDBYNOW1))
1463 qc->dev->flags |= ATA_DFLAG_SPUNDOWN;
1464 else if (likely(system_state != SYSTEM_HALT &&
1465 system_state != SYSTEM_POWER_OFF))
1466 qc->dev->flags &= ~ATA_DFLAG_SPUNDOWN;
1468 if (need_sense && !ap->ops->error_handler)
1469 ata_dump_status(ap->print_id, &qc->result_tf);
1477 * ata_scsi_translate - Translate then issue SCSI command to ATA device
1478 * @dev: ATA device to which the command is addressed
1479 * @cmd: SCSI command to execute
1480 * @done: SCSI command completion function
1481 * @xlat_func: Actor which translates @cmd to an ATA taskfile
1483 * Our ->queuecommand() function has decided that the SCSI
1484 * command issued can be directly translated into an ATA
1485 * command, rather than handled internally.
1487 * This function sets up an ata_queued_cmd structure for the
1488 * SCSI command, and sends that ata_queued_cmd to the hardware.
1490 * The xlat_func argument (actor) returns 0 if ready to execute
1491 * ATA command, else 1 to finish translation. If 1 is returned
1492 * then cmd->result (and possibly cmd->sense_buffer) are assumed
1493 * to be set reflecting an error condition or clean (early)
1497 * spin_lock_irqsave(host lock)
1500 * 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
1501 * needs to be deferred.
1503 static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
1504 void (*done)(struct scsi_cmnd *),
1505 ata_xlat_func_t xlat_func)
1507 struct ata_port *ap = dev->link->ap;
1508 struct ata_queued_cmd *qc;
1513 qc = ata_scsi_qc_new(dev, cmd, done);
1517 /* data is present; dma-map it */
1518 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1519 cmd->sc_data_direction == DMA_TO_DEVICE) {
1520 if (unlikely(scsi_bufflen(cmd) < 1)) {
1521 ata_dev_printk(dev, KERN_WARNING,
1522 "WARNING: zero len r/w req\n");
1526 ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
1528 qc->dma_dir = cmd->sc_data_direction;
1531 qc->complete_fn = ata_scsi_qc_complete;
1536 if (ap->ops->qc_defer) {
1537 if ((rc = ap->ops->qc_defer(qc)))
1541 /* select device, send command to hardware */
1550 DPRINTK("EXIT - early finish (good or error)\n");
1555 cmd->result = (DID_ERROR << 16);
1558 DPRINTK("EXIT - internal\n");
1563 DPRINTK("EXIT - defer\n");
1564 if (rc == ATA_DEFER_LINK)
1565 return SCSI_MLQUEUE_DEVICE_BUSY;
1567 return SCSI_MLQUEUE_HOST_BUSY;
1571 * ata_scsi_rbuf_get - Map response buffer.
1572 * @cmd: SCSI command containing buffer to be mapped.
1573 * @buf_out: Pointer to mapped area.
1575 * Maps buffer contained within SCSI command @cmd.
1578 * spin_lock_irqsave(host lock)
1581 * Length of response buffer.
1584 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
1587 unsigned int buflen;
1589 struct scatterlist *sg = scsi_sglist(cmd);
1592 buf = kmap_atomic(sg_page(sg), KM_IRQ0) + sg->offset;
1593 buflen = sg->length;
1604 * ata_scsi_rbuf_put - Unmap response buffer.
1605 * @cmd: SCSI command containing buffer to be unmapped.
1606 * @buf: buffer to unmap
1608 * Unmaps response buffer contained within @cmd.
1611 * spin_lock_irqsave(host lock)
1614 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
1616 struct scatterlist *sg = scsi_sglist(cmd);
1618 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1622 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1623 * @args: device IDENTIFY data / SCSI command of interest.
1624 * @actor: Callback hook for desired SCSI command simulator
1626 * Takes care of the hard work of simulating a SCSI command...
1627 * Mapping the response buffer, calling the command's handler,
1628 * and handling the handler's return value. This return value
1629 * indicates whether the handler wishes the SCSI command to be
1630 * completed successfully (0), or not (in which case cmd->result
1631 * and sense buffer are assumed to be set).
1634 * spin_lock_irqsave(host lock)
1637 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1638 unsigned int (*actor) (struct ata_scsi_args *args,
1639 u8 *rbuf, unsigned int buflen))
1642 unsigned int buflen, rc;
1643 struct scsi_cmnd *cmd = args->cmd;
1645 buflen = ata_scsi_rbuf_get(cmd, &rbuf);
1646 memset(rbuf, 0, buflen);
1647 rc = actor(args, rbuf, buflen);
1648 ata_scsi_rbuf_put(cmd, rbuf);
1651 cmd->result = SAM_STAT_GOOD;
1656 * ATA_SCSI_RBUF_SET - helper to set values in SCSI response buffer
1657 * @idx: byte index into SCSI response buffer
1658 * @val: value to set
1660 * To be used by SCSI command simulator functions. This macros
1661 * expects two local variables, u8 *rbuf and unsigned int buflen,
1667 #define ATA_SCSI_RBUF_SET(idx, val) do { \
1668 if ((idx) < buflen) rbuf[(idx)] = (u8)(val); \
1672 * ata_scsiop_inq_std - Simulate INQUIRY command
1673 * @args: device IDENTIFY data / SCSI command of interest.
1674 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1675 * @buflen: Response buffer length.
1677 * Returns standard device identification data associated
1678 * with non-VPD INQUIRY command output.
1681 * spin_lock_irqsave(host lock)
1684 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
1685 unsigned int buflen)
1690 0x5, /* claim SPC-3 version compatibility */
1695 /* set scsi removeable (RMB) bit per ata bit */
1696 if (ata_id_removeable(args->id))
1701 memcpy(rbuf, hdr, sizeof(hdr));
1704 memcpy(&rbuf[8], "ATA ", 8);
1705 ata_id_string(args->id, &rbuf[16], ATA_ID_PROD, 16);
1706 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV, 4);
1707 if (rbuf[32] == 0 || rbuf[32] == ' ')
1708 memcpy(&rbuf[32], "n/a ", 4);
1712 const u8 versions[] = {
1713 0x60, /* SAM-3 (no version claimed) */
1716 0x20, /* SBC-2 (no version claimed) */
1719 0x60 /* SPC-3 (no version claimed) */
1722 memcpy(rbuf + 59, versions, sizeof(versions));
1729 * ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
1730 * @args: device IDENTIFY data / SCSI command of interest.
1731 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1732 * @buflen: Response buffer length.
1734 * Returns list of inquiry VPD pages available.
1737 * spin_lock_irqsave(host lock)
1740 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
1741 unsigned int buflen)
1743 const u8 pages[] = {
1744 0x00, /* page 0x00, this page */
1745 0x80, /* page 0x80, unit serial no page */
1746 0x83 /* page 0x83, device ident page */
1748 rbuf[3] = sizeof(pages); /* number of supported VPD pages */
1751 memcpy(rbuf + 4, pages, sizeof(pages));
1757 * ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
1758 * @args: device IDENTIFY data / SCSI command of interest.
1759 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1760 * @buflen: Response buffer length.
1762 * Returns ATA device serial number.
1765 * spin_lock_irqsave(host lock)
1768 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
1769 unsigned int buflen)
1773 0x80, /* this page code */
1775 ATA_ID_SERNO_LEN, /* page len */
1777 memcpy(rbuf, hdr, sizeof(hdr));
1779 if (buflen > (ATA_ID_SERNO_LEN + 4 - 1))
1780 ata_id_string(args->id, (unsigned char *) &rbuf[4],
1781 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1787 * ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
1788 * @args: device IDENTIFY data / SCSI command of interest.
1789 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1790 * @buflen: Response buffer length.
1792 * Yields two logical unit device identification designators:
1793 * - vendor specific ASCII containing the ATA serial number
1794 * - SAT defined "t10 vendor id based" containing ASCII vendor
1795 * name ("ATA "), model and serial numbers.
1798 * spin_lock_irqsave(host lock)
1801 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1802 unsigned int buflen)
1805 const int sat_model_serial_desc_len = 68;
1807 rbuf[1] = 0x83; /* this page code */
1810 if (buflen > (ATA_ID_SERNO_LEN + num + 3)) {
1811 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
1813 rbuf[num + 3] = ATA_ID_SERNO_LEN;
1815 ata_id_string(args->id, (unsigned char *) rbuf + num,
1816 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1817 num += ATA_ID_SERNO_LEN;
1819 if (buflen > (sat_model_serial_desc_len + num + 3)) {
1820 /* SAT defined lu model and serial numbers descriptor */
1821 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
1824 rbuf[num + 3] = sat_model_serial_desc_len;
1826 memcpy(rbuf + num, "ATA ", 8);
1828 ata_id_string(args->id, (unsigned char *) rbuf + num,
1829 ATA_ID_PROD, ATA_ID_PROD_LEN);
1830 num += ATA_ID_PROD_LEN;
1831 ata_id_string(args->id, (unsigned char *) rbuf + num,
1832 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1833 num += ATA_ID_SERNO_LEN;
1835 rbuf[3] = num - 4; /* page len (assume less than 256 bytes) */
1840 * ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
1841 * @args: device IDENTIFY data / SCSI command of interest.
1842 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1843 * @buflen: Response buffer length.
1845 * Yields SAT-specified ATA VPD page.
1848 * spin_lock_irqsave(host lock)
1851 unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf,
1852 unsigned int buflen)
1855 struct ata_taskfile tf;
1861 memset(&pbuf, 0, sizeof(pbuf));
1862 memset(&tf, 0, sizeof(tf));
1864 pbuf[1] = 0x89; /* our page code */
1865 pbuf[2] = (0x238 >> 8); /* page size fixed at 238h */
1866 pbuf[3] = (0x238 & 0xff);
1868 memcpy(&pbuf[8], "linux ", 8);
1869 memcpy(&pbuf[16], "libata ", 16);
1870 memcpy(&pbuf[32], DRV_VERSION, 4);
1871 ata_id_string(args->id, &pbuf[32], ATA_ID_FW_REV, 4);
1873 /* we don't store the ATA device signature, so we fake it */
1875 tf.command = ATA_DRDY; /* really, this is Status reg */
1879 ata_tf_to_fis(&tf, 0, 1, &pbuf[36]); /* TODO: PMP? */
1880 pbuf[36] = 0x34; /* force D2H Reg FIS (34h) */
1882 pbuf[56] = ATA_CMD_ID_ATA;
1884 i = min(buflen, 60U);
1885 memcpy(rbuf, &pbuf[0], i);
1891 memcpy(&rbuf[60], &args->id[0], min(buflen, 512U));
1896 * ata_scsiop_noop - Command handler that simply returns success.
1897 * @args: device IDENTIFY data / SCSI command of interest.
1898 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1899 * @buflen: Response buffer length.
1901 * No operation. Simply returns success to caller, to indicate
1902 * that the caller should successfully complete this SCSI command.
1905 * spin_lock_irqsave(host lock)
1908 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1909 unsigned int buflen)
1916 * ata_msense_push - Push data onto MODE SENSE data output buffer
1917 * @ptr_io: (input/output) Location to store more output data
1918 * @last: End of output data buffer
1919 * @buf: Pointer to BLOB being added to output buffer
1920 * @buflen: Length of BLOB
1922 * Store MODE SENSE data on an output buffer.
1928 static void ata_msense_push(u8 **ptr_io, const u8 *last,
1929 const u8 *buf, unsigned int buflen)
1933 if ((ptr + buflen - 1) > last)
1936 memcpy(ptr, buf, buflen);
1944 * ata_msense_caching - Simulate MODE SENSE caching info page
1945 * @id: device IDENTIFY data
1946 * @ptr_io: (input/output) Location to store more output data
1947 * @last: End of output data buffer
1949 * Generate a caching info page, which conditionally indicates
1950 * write caching to the SCSI layer, depending on device
1957 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1960 u8 page[CACHE_MPAGE_LEN];
1962 memcpy(page, def_cache_mpage, sizeof(page));
1963 if (ata_id_wcache_enabled(id))
1964 page[2] |= (1 << 2); /* write cache enable */
1965 if (!ata_id_rahead_enabled(id))
1966 page[12] |= (1 << 5); /* disable read ahead */
1968 ata_msense_push(ptr_io, last, page, sizeof(page));
1969 return sizeof(page);
1973 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1974 * @dev: Device associated with this MODE SENSE command
1975 * @ptr_io: (input/output) Location to store more output data
1976 * @last: End of output data buffer
1978 * Generate a generic MODE SENSE control mode page.
1984 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1986 ata_msense_push(ptr_io, last, def_control_mpage,
1987 sizeof(def_control_mpage));
1988 return sizeof(def_control_mpage);
1992 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1993 * @dev: Device associated with this MODE SENSE command
1994 * @ptr_io: (input/output) Location to store more output data
1995 * @last: End of output data buffer
1997 * Generate a generic MODE SENSE r/w error recovery page.
2003 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
2006 ata_msense_push(ptr_io, last, def_rw_recovery_mpage,
2007 sizeof(def_rw_recovery_mpage));
2008 return sizeof(def_rw_recovery_mpage);
2012 * We can turn this into a real blacklist if it's needed, for now just
2013 * blacklist any Maxtor BANC1G10 revision firmware
2015 static int ata_dev_supports_fua(u16 *id)
2017 unsigned char model[ATA_ID_PROD_LEN + 1], fw[ATA_ID_FW_REV_LEN + 1];
2021 if (!ata_id_has_fua(id))
2024 ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
2025 ata_id_c_string(id, fw, ATA_ID_FW_REV, sizeof(fw));
2027 if (strcmp(model, "Maxtor"))
2029 if (strcmp(fw, "BANC1G10"))
2032 return 0; /* blacklisted */
2036 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
2037 * @args: device IDENTIFY data / SCSI command of interest.
2038 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2039 * @buflen: Response buffer length.
2041 * Simulate MODE SENSE commands. Assume this is invoked for direct
2042 * access devices (e.g. disks) only. There should be no block
2043 * descriptor for other device types.
2046 * spin_lock_irqsave(host lock)
2049 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
2050 unsigned int buflen)
2052 struct ata_device *dev = args->dev;
2053 u8 *scsicmd = args->cmd->cmnd, *p, *last;
2054 const u8 sat_blk_desc[] = {
2055 0, 0, 0, 0, /* number of blocks: sat unspecified */
2057 0, 0x2, 0x0 /* block length: 512 bytes */
2060 unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
2065 six_byte = (scsicmd[0] == MODE_SENSE);
2066 ebd = !(scsicmd[1] & 0x8); /* dbd bit inverted == edb */
2068 * LLBA bit in msense(10) ignored (compliant)
2071 page_control = scsicmd[2] >> 6;
2072 switch (page_control) {
2073 case 0: /* current */
2074 break; /* supported */
2076 goto saving_not_supp;
2077 case 1: /* changeable */
2078 case 2: /* defaults */
2084 output_len = 4 + (ebd ? 8 : 0);
2085 alloc_len = scsicmd[4];
2087 output_len = 8 + (ebd ? 8 : 0);
2088 alloc_len = (scsicmd[7] << 8) + scsicmd[8];
2090 minlen = (alloc_len < buflen) ? alloc_len : buflen;
2092 p = rbuf + output_len;
2093 last = rbuf + minlen - 1;
2095 pg = scsicmd[2] & 0x3f;
2098 * No mode subpages supported (yet) but asking for _all_
2099 * subpages may be valid
2101 if (spg && (spg != ALL_SUB_MPAGES))
2105 case RW_RECOVERY_MPAGE:
2106 output_len += ata_msense_rw_recovery(&p, last);
2110 output_len += ata_msense_caching(args->id, &p, last);
2113 case CONTROL_MPAGE: {
2114 output_len += ata_msense_ctl_mode(&p, last);
2119 output_len += ata_msense_rw_recovery(&p, last);
2120 output_len += ata_msense_caching(args->id, &p, last);
2121 output_len += ata_msense_ctl_mode(&p, last);
2124 default: /* invalid page code */
2132 if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
2133 (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
2138 rbuf[0] = output_len;
2143 rbuf[3] = sizeof(sat_blk_desc);
2145 memcpy(rbuf + 4, sat_blk_desc,
2146 sizeof(sat_blk_desc));
2150 rbuf[0] = output_len >> 8;
2152 rbuf[1] = output_len;
2157 rbuf[7] = sizeof(sat_blk_desc);
2159 memcpy(rbuf + 8, sat_blk_desc,
2160 sizeof(sat_blk_desc));
2166 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
2167 /* "Invalid field in cbd" */
2171 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
2172 /* "Saving parameters not supported" */
2177 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
2178 * @args: device IDENTIFY data / SCSI command of interest.
2179 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2180 * @buflen: Response buffer length.
2182 * Simulate READ CAPACITY commands.
2187 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
2188 unsigned int buflen)
2190 u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */
2194 if (args->cmd->cmnd[0] == READ_CAPACITY) {
2195 if (last_lba >= 0xffffffffULL)
2196 last_lba = 0xffffffff;
2198 /* sector count, 32-bit */
2199 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 3));
2200 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 2));
2201 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 1));
2202 ATA_SCSI_RBUF_SET(3, last_lba);
2205 ATA_SCSI_RBUF_SET(6, ATA_SECT_SIZE >> 8);
2206 ATA_SCSI_RBUF_SET(7, ATA_SECT_SIZE);
2208 /* sector count, 64-bit */
2209 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 7));
2210 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 6));
2211 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 5));
2212 ATA_SCSI_RBUF_SET(3, last_lba >> (8 * 4));
2213 ATA_SCSI_RBUF_SET(4, last_lba >> (8 * 3));
2214 ATA_SCSI_RBUF_SET(5, last_lba >> (8 * 2));
2215 ATA_SCSI_RBUF_SET(6, last_lba >> (8 * 1));
2216 ATA_SCSI_RBUF_SET(7, last_lba);
2219 ATA_SCSI_RBUF_SET(10, ATA_SECT_SIZE >> 8);
2220 ATA_SCSI_RBUF_SET(11, ATA_SECT_SIZE);
2227 * ata_scsiop_report_luns - Simulate REPORT LUNS command
2228 * @args: device IDENTIFY data / SCSI command of interest.
2229 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2230 * @buflen: Response buffer length.
2232 * Simulate REPORT LUNS command.
2235 * spin_lock_irqsave(host lock)
2238 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
2239 unsigned int buflen)
2242 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
2248 * ata_scsi_set_sense - Set SCSI sense data and status
2249 * @cmd: SCSI request to be handled
2250 * @sk: SCSI-defined sense key
2251 * @asc: SCSI-defined additional sense code
2252 * @ascq: SCSI-defined additional sense code qualifier
2254 * Helper function that builds a valid fixed format, current
2255 * response code and the given sense key (sk), additional sense
2256 * code (asc) and additional sense code qualifier (ascq) with
2257 * a SCSI command status of %SAM_STAT_CHECK_CONDITION and
2258 * DRIVER_SENSE set in the upper bits of scsi_cmnd::result .
2264 void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
2266 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
2268 cmd->sense_buffer[0] = 0x70; /* fixed format, current */
2269 cmd->sense_buffer[2] = sk;
2270 cmd->sense_buffer[7] = 18 - 8; /* additional sense length */
2271 cmd->sense_buffer[12] = asc;
2272 cmd->sense_buffer[13] = ascq;
2276 * ata_scsi_badcmd - End a SCSI request with an error
2277 * @cmd: SCSI request to be handled
2278 * @done: SCSI command completion function
2279 * @asc: SCSI-defined additional sense code
2280 * @ascq: SCSI-defined additional sense code qualifier
2282 * Helper function that completes a SCSI command with
2283 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
2284 * and the specified additional sense codes.
2287 * spin_lock_irqsave(host lock)
2290 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
2293 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, asc, ascq);
2298 static void atapi_sense_complete(struct ata_queued_cmd *qc)
2300 if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
2301 /* FIXME: not quite right; we don't want the
2302 * translation of taskfile registers into
2303 * a sense descriptors, since that's only
2304 * correct for ATA, not ATAPI
2306 ata_gen_passthru_sense(qc);
2309 qc->scsidone(qc->scsicmd);
2313 /* is it pointless to prefer PIO for "safety reasons"? */
2314 static inline int ata_pio_use_silly(struct ata_port *ap)
2316 return (ap->flags & ATA_FLAG_PIO_DMA);
2319 static void atapi_request_sense(struct ata_queued_cmd *qc)
2321 struct ata_port *ap = qc->ap;
2322 struct scsi_cmnd *cmd = qc->scsicmd;
2324 DPRINTK("ATAPI request sense\n");
2326 /* FIXME: is this needed? */
2327 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2329 ap->ops->tf_read(ap, &qc->tf);
2331 /* fill these in, for the case where they are -not- overwritten */
2332 cmd->sense_buffer[0] = 0x70;
2333 cmd->sense_buffer[2] = qc->tf.feature >> 4;
2337 ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2338 qc->dma_dir = DMA_FROM_DEVICE;
2340 memset(&qc->cdb, 0, qc->dev->cdb_len);
2341 qc->cdb[0] = REQUEST_SENSE;
2342 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2344 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2345 qc->tf.command = ATA_CMD_PACKET;
2347 if (ata_pio_use_silly(ap)) {
2348 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2349 qc->tf.feature |= ATAPI_PKT_DMA;
2351 qc->tf.protocol = ATA_PROT_ATAPI;
2352 qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
2355 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2357 qc->complete_fn = atapi_sense_complete;
2364 static void atapi_qc_complete(struct ata_queued_cmd *qc)
2366 struct scsi_cmnd *cmd = qc->scsicmd;
2367 unsigned int err_mask = qc->err_mask;
2369 VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
2371 /* handle completion from new EH */
2372 if (unlikely(qc->ap->ops->error_handler &&
2373 (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
2375 if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
2376 /* FIXME: not quite right; we don't want the
2377 * translation of taskfile registers into a
2378 * sense descriptors, since that's only
2379 * correct for ATA, not ATAPI
2381 ata_gen_passthru_sense(qc);
2384 /* SCSI EH automatically locks door if sdev->locked is
2385 * set. Sometimes door lock request continues to
2386 * fail, for example, when no media is present. This
2387 * creates a loop - SCSI EH issues door lock which
2388 * fails and gets invoked again to acquire sense data
2389 * for the failed command.
2391 * If door lock fails, always clear sdev->locked to
2392 * avoid this infinite loop.
2394 if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL)
2395 qc->dev->sdev->locked = 0;
2397 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
2403 /* successful completion or old EH failure path */
2404 if (unlikely(err_mask & AC_ERR_DEV)) {
2405 cmd->result = SAM_STAT_CHECK_CONDITION;
2406 atapi_request_sense(qc);
2408 } else if (unlikely(err_mask)) {
2409 /* FIXME: not quite right; we don't want the
2410 * translation of taskfile registers into
2411 * a sense descriptors, since that's only
2412 * correct for ATA, not ATAPI
2414 ata_gen_passthru_sense(qc);
2416 u8 *scsicmd = cmd->cmnd;
2418 if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
2420 unsigned int buflen;
2422 buflen = ata_scsi_rbuf_get(cmd, &buf);
2424 /* ATAPI devices typically report zero for their SCSI version,
2425 * and sometimes deviate from the spec WRT response data
2426 * format. If SCSI version is reported as zero like normal,
2427 * then we make the following fixups: 1) Fake MMC-5 version,
2428 * to indicate to the Linux scsi midlayer this is a modern
2429 * device. 2) Ensure response data format / ATAPI information
2430 * are always correct.
2437 ata_scsi_rbuf_put(cmd, buf);
2440 cmd->result = SAM_STAT_GOOD;
2447 * atapi_xlat - Initialize PACKET taskfile
2448 * @qc: command structure to be initialized
2451 * spin_lock_irqsave(host lock)
2454 * Zero on success, non-zero on failure.
2456 static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
2458 struct scsi_cmnd *scmd = qc->scsicmd;
2459 struct ata_device *dev = qc->dev;
2460 int using_pio = (dev->flags & ATA_DFLAG_PIO);
2461 int nodata = (scmd->sc_data_direction == DMA_NONE);
2462 unsigned int nbytes;
2464 memset(qc->cdb, 0, dev->cdb_len);
2465 memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
2467 qc->complete_fn = atapi_qc_complete;
2469 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2470 if (scmd->sc_data_direction == DMA_TO_DEVICE) {
2471 qc->tf.flags |= ATA_TFLAG_WRITE;
2472 DPRINTK("direction: write\n");
2475 qc->tf.command = ATA_CMD_PACKET;
2476 qc->nbytes = scsi_bufflen(scmd);
2478 /* check whether ATAPI DMA is safe */
2479 if (!using_pio && ata_check_atapi_dma(qc))
2482 /* Some controller variants snoop this value for Packet transfers
2483 to do state machine and FIFO management. Thus we want to set it
2484 properly, and for DMA where it is effectively meaningless */
2485 nbytes = min(qc->nbytes, (unsigned int)63 * 1024);
2487 qc->tf.lbam = (nbytes & 0xFF);
2488 qc->tf.lbah = (nbytes >> 8);
2490 if (using_pio || nodata) {
2491 /* no data, or PIO data xfer */
2493 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
2495 qc->tf.protocol = ATA_PROT_ATAPI;
2498 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2499 qc->tf.feature |= ATAPI_PKT_DMA;
2501 if (atapi_dmadir && (scmd->sc_data_direction != DMA_TO_DEVICE))
2502 /* some SATA bridges need us to indicate data xfer direction */
2503 qc->tf.feature |= ATAPI_DMADIR;
2507 /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
2508 as ATAPI tape drives don't get this right otherwise */
2512 static struct ata_device *ata_find_dev(struct ata_port *ap, int devno)
2514 if (ap->nr_pmp_links == 0) {
2515 if (likely(devno < ata_link_max_devices(&ap->link)))
2516 return &ap->link.device[devno];
2518 if (likely(devno < ap->nr_pmp_links))
2519 return &ap->pmp_link[devno].device[0];
2525 static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
2526 const struct scsi_device *scsidev)
2530 /* skip commands not addressed to targets we simulate */
2531 if (ap->nr_pmp_links == 0) {
2532 if (unlikely(scsidev->channel || scsidev->lun))
2534 devno = scsidev->id;
2536 if (unlikely(scsidev->id || scsidev->lun))
2538 devno = scsidev->channel;
2541 return ata_find_dev(ap, devno);
2545 * ata_scsi_dev_enabled - determine if device is enabled
2548 * Determine if commands should be sent to the specified device.
2551 * spin_lock_irqsave(host lock)
2554 * 0 if commands are not allowed / 1 if commands are allowed
2557 static int ata_scsi_dev_enabled(struct ata_device *dev)
2559 if (unlikely(!ata_dev_enabled(dev)))
2562 if (!atapi_enabled || (dev->link->ap->flags & ATA_FLAG_NO_ATAPI)) {
2563 if (unlikely(dev->class == ATA_DEV_ATAPI)) {
2564 ata_dev_printk(dev, KERN_WARNING,
2565 "WARNING: ATAPI is %s, device ignored.\n",
2566 atapi_enabled ? "not supported with this driver" : "disabled");
2575 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
2576 * @ap: ATA port to which the device is attached
2577 * @scsidev: SCSI device from which we derive the ATA device
2579 * Given various information provided in struct scsi_cmnd,
2580 * map that onto an ATA bus, and using that mapping
2581 * determine which ata_device is associated with the
2582 * SCSI command to be sent.
2585 * spin_lock_irqsave(host lock)
2588 * Associated ATA device, or %NULL if not found.
2590 static struct ata_device *
2591 ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
2593 struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
2595 if (unlikely(!dev || !ata_scsi_dev_enabled(dev)))
2602 * ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
2603 * @byte1: Byte 1 from pass-thru CDB.
2606 * ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
2609 ata_scsi_map_proto(u8 byte1)
2611 switch((byte1 & 0x1e) >> 1) {
2612 case 3: /* Non-data */
2613 return ATA_PROT_NODATA;
2616 case 10: /* UDMA Data-in */
2617 case 11: /* UDMA Data-Out */
2618 return ATA_PROT_DMA;
2620 case 4: /* PIO Data-in */
2621 case 5: /* PIO Data-out */
2622 return ATA_PROT_PIO;
2624 case 0: /* Hard Reset */
2626 case 8: /* Device Diagnostic */
2627 case 9: /* Device Reset */
2628 case 7: /* DMA Queued */
2629 case 12: /* FPDMA */
2630 case 15: /* Return Response Info */
2631 default: /* Reserved */
2635 return ATA_PROT_UNKNOWN;
2639 * ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
2640 * @qc: command structure to be initialized
2642 * Handles either 12 or 16-byte versions of the CDB.
2645 * Zero on success, non-zero on failure.
2647 static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
2649 struct ata_taskfile *tf = &(qc->tf);
2650 struct scsi_cmnd *scmd = qc->scsicmd;
2651 struct ata_device *dev = qc->dev;
2652 const u8 *cdb = scmd->cmnd;
2654 if ((tf->protocol = ata_scsi_map_proto(cdb[1])) == ATA_PROT_UNKNOWN)
2657 /* We may not issue DMA commands if no DMA mode is set */
2658 if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
2662 * 12 and 16 byte CDBs use different offsets to
2663 * provide the various register values.
2665 if (cdb[0] == ATA_16) {
2667 * 16-byte CDB - may contain extended commands.
2669 * If that is the case, copy the upper byte register values.
2671 if (cdb[1] & 0x01) {
2672 tf->hob_feature = cdb[3];
2673 tf->hob_nsect = cdb[5];
2674 tf->hob_lbal = cdb[7];
2675 tf->hob_lbam = cdb[9];
2676 tf->hob_lbah = cdb[11];
2677 tf->flags |= ATA_TFLAG_LBA48;
2679 tf->flags &= ~ATA_TFLAG_LBA48;
2682 * Always copy low byte, device and command registers.
2684 tf->feature = cdb[4];
2689 tf->device = cdb[13];
2690 tf->command = cdb[14];
2693 * 12-byte CDB - incapable of extended commands.
2695 tf->flags &= ~ATA_TFLAG_LBA48;
2697 tf->feature = cdb[3];
2702 tf->device = cdb[8];
2703 tf->command = cdb[9];
2706 /* enforce correct master/slave bit */
2707 tf->device = dev->devno ?
2708 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
2710 /* sanity check for pio multi commands */
2711 if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf))
2714 if (is_multi_taskfile(tf)) {
2715 unsigned int multi_count = 1 << (cdb[1] >> 5);
2717 /* compare the passed through multi_count
2718 * with the cached multi_count of libata
2720 if (multi_count != dev->multi_count)
2721 ata_dev_printk(dev, KERN_WARNING,
2722 "invalid multi_count %u ignored\n",
2726 /* READ/WRITE LONG use a non-standard sect_size */
2727 qc->sect_size = ATA_SECT_SIZE;
2728 switch (tf->command) {
2729 case ATA_CMD_READ_LONG:
2730 case ATA_CMD_READ_LONG_ONCE:
2731 case ATA_CMD_WRITE_LONG:
2732 case ATA_CMD_WRITE_LONG_ONCE:
2733 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
2735 qc->sect_size = scsi_bufflen(scmd);
2739 * Filter SET_FEATURES - XFER MODE command -- otherwise,
2740 * SET_FEATURES - XFER MODE must be preceded/succeeded
2741 * by an update to hardware-specific registers for each
2742 * controller (i.e. the reason for ->set_piomode(),
2743 * ->set_dmamode(), and ->post_set_mode() hooks).
2745 if ((tf->command == ATA_CMD_SET_FEATURES)
2746 && (tf->feature == SETFEATURES_XFER))
2750 * Set flags so that all registers will be written,
2751 * and pass on write indication (used for PIO/DMA
2754 tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
2756 if (scmd->sc_data_direction == DMA_TO_DEVICE)
2757 tf->flags |= ATA_TFLAG_WRITE;
2760 * Set transfer length.
2762 * TODO: find out if we need to do more here to
2763 * cover scatter/gather case.
2765 qc->nbytes = scsi_bufflen(scmd);
2767 /* request result TF */
2768 qc->flags |= ATA_QCFLAG_RESULT_TF;
2773 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
2774 /* "Invalid field in cdb" */
2779 * ata_get_xlat_func - check if SCSI to ATA translation is possible
2781 * @cmd: SCSI command opcode to consider
2783 * Look up the SCSI command given, and determine whether the
2784 * SCSI command is to be translated or simulated.
2787 * Pointer to translation function if possible, %NULL if not.
2790 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
2800 return ata_scsi_rw_xlat;
2802 case SYNCHRONIZE_CACHE:
2803 if (ata_try_flush_cache(dev))
2804 return ata_scsi_flush_xlat;
2809 return ata_scsi_verify_xlat;
2813 return ata_scsi_pass_thru;
2816 return ata_scsi_start_stop_xlat;
2823 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
2824 * @ap: ATA port to which the command was being sent
2825 * @cmd: SCSI command to dump
2827 * Prints the contents of a SCSI command via printk().
2830 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
2831 struct scsi_cmnd *cmd)
2834 struct scsi_device *scsidev = cmd->device;
2835 u8 *scsicmd = cmd->cmnd;
2837 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
2839 scsidev->channel, scsidev->id, scsidev->lun,
2840 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
2841 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
2846 static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
2847 void (*done)(struct scsi_cmnd *),
2848 struct ata_device *dev)
2850 u8 scsi_op = scmd->cmnd[0];
2851 ata_xlat_func_t xlat_func;
2854 if (dev->class == ATA_DEV_ATA) {
2855 if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
2858 xlat_func = ata_get_xlat_func(dev, scsi_op);
2860 if (unlikely(!scmd->cmd_len))
2864 if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
2865 /* relay SCSI command to ATAPI device */
2866 if (unlikely(scmd->cmd_len > dev->cdb_len))
2869 xlat_func = atapi_xlat;
2871 /* ATA_16 passthru, treat as an ATA command */
2872 if (unlikely(scmd->cmd_len > 16))
2875 xlat_func = ata_get_xlat_func(dev, scsi_op);
2880 rc = ata_scsi_translate(dev, scmd, done, xlat_func);
2882 ata_scsi_simulate(dev, scmd, done);
2887 DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
2888 scmd->cmd_len, scsi_op, dev->cdb_len);
2889 scmd->result = DID_ERROR << 16;
2895 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
2896 * @cmd: SCSI command to be sent
2897 * @done: Completion function, called when command is complete
2899 * In some cases, this function translates SCSI commands into
2900 * ATA taskfiles, and queues the taskfiles to be sent to
2901 * hardware. In other cases, this function simulates a
2902 * SCSI device by evaluating and responding to certain
2903 * SCSI commands. This creates the overall effect of
2904 * ATA and ATAPI devices appearing as SCSI devices.
2907 * Releases scsi-layer-held lock, and obtains host lock.
2910 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
2913 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
2915 struct ata_port *ap;
2916 struct ata_device *dev;
2917 struct scsi_device *scsidev = cmd->device;
2918 struct Scsi_Host *shost = scsidev->host;
2921 ap = ata_shost_to_port(shost);
2923 spin_unlock(shost->host_lock);
2924 spin_lock(ap->lock);
2926 ata_scsi_dump_cdb(ap, cmd);
2928 dev = ata_scsi_find_dev(ap, scsidev);
2930 rc = __ata_scsi_queuecmd(cmd, done, dev);
2932 cmd->result = (DID_BAD_TARGET << 16);
2936 spin_unlock(ap->lock);
2937 spin_lock(shost->host_lock);
2942 * ata_scsi_simulate - simulate SCSI command on ATA device
2943 * @dev: the target device
2944 * @cmd: SCSI command being sent to device.
2945 * @done: SCSI command completion function.
2947 * Interprets and directly executes a select list of SCSI commands
2948 * that can be handled internally.
2951 * spin_lock_irqsave(host lock)
2954 void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
2955 void (*done)(struct scsi_cmnd *))
2957 struct ata_scsi_args args;
2958 const u8 *scsicmd = cmd->cmnd;
2966 switch(scsicmd[0]) {
2967 /* TODO: worth improving? */
2969 ata_scsi_invalid_field(cmd, done);
2973 if (scsicmd[1] & 2) /* is CmdDt set? */
2974 ata_scsi_invalid_field(cmd, done);
2975 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
2976 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
2977 else switch (scsicmd[2]) {
2979 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
2982 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
2985 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
2988 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
2991 ata_scsi_invalid_field(cmd, done);
2998 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
3001 case MODE_SELECT: /* unconditionally return */
3002 case MODE_SELECT_10: /* bad-field-in-cdb */
3003 ata_scsi_invalid_field(cmd, done);
3007 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3010 case SERVICE_ACTION_IN:
3011 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
3012 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3014 ata_scsi_invalid_field(cmd, done);
3018 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
3022 ata_scsi_set_sense(cmd, 0, 0, 0);
3023 cmd->result = (DRIVER_SENSE << 24);
3027 /* if we reach this, then writeback caching is disabled,
3028 * turning this into a no-op.
3030 case SYNCHRONIZE_CACHE:
3033 /* no-op's, complete with success */
3037 case TEST_UNIT_READY:
3038 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3041 case SEND_DIAGNOSTIC:
3042 tmp8 = scsicmd[1] & ~(1 << 3);
3043 if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
3044 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3046 ata_scsi_invalid_field(cmd, done);
3049 /* all other commands */
3051 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
3052 /* "Invalid command operation code" */
3058 int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
3062 for (i = 0; i < host->n_ports; i++) {
3063 struct ata_port *ap = host->ports[i];
3064 struct Scsi_Host *shost;
3067 shost = scsi_host_alloc(sht, sizeof(struct ata_port *));
3071 *(struct ata_port **)&shost->hostdata[0] = ap;
3072 ap->scsi_host = shost;
3074 shost->transportt = &ata_scsi_transport_template;
3075 shost->unique_id = ap->print_id;
3078 shost->max_channel = 1;
3079 shost->max_cmd_len = 16;
3081 /* Schedule policy is determined by ->qc_defer()
3082 * callback and it needs to see every deferred qc.
3083 * Set host_blocked to 1 to prevent SCSI midlayer from
3084 * automatically deferring requests.
3086 shost->max_host_blocked = 1;
3088 rc = scsi_add_host(ap->scsi_host, ap->host->dev);
3096 scsi_host_put(host->ports[i]->scsi_host);
3099 struct Scsi_Host *shost = host->ports[i]->scsi_host;
3101 scsi_remove_host(shost);
3102 scsi_host_put(shost);
3107 void ata_scsi_scan_host(struct ata_port *ap, int sync)
3110 struct ata_device *last_failed_dev = NULL;
3111 struct ata_link *link;
3112 struct ata_device *dev;
3114 if (ap->flags & ATA_FLAG_DISABLED)
3118 ata_port_for_each_link(link, ap) {
3119 ata_link_for_each_dev(dev, link) {
3120 struct scsi_device *sdev;
3121 int channel = 0, id = 0;
3123 if (!ata_dev_enabled(dev) || dev->sdev)
3126 if (ata_is_host_link(link))
3129 channel = link->pmp;
3131 sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
3133 if (!IS_ERR(sdev)) {
3135 scsi_device_put(sdev);
3140 /* If we scanned while EH was in progress or allocation
3141 * failure occurred, scan would have failed silently. Check
3142 * whether all devices are attached.
3144 ata_port_for_each_link(link, ap) {
3145 ata_link_for_each_dev(dev, link) {
3146 if (ata_dev_enabled(dev) && !dev->sdev)
3154 /* we're missing some SCSI devices */
3156 /* If caller requested synchrnous scan && we've made
3157 * any progress, sleep briefly and repeat.
3159 if (dev != last_failed_dev) {
3161 last_failed_dev = dev;
3165 /* We might be failing to detect boot device, give it
3166 * a few more chances.
3173 ata_port_printk(ap, KERN_ERR, "WARNING: synchronous SCSI scan "
3174 "failed without making any progress,\n"
3175 " switching to async\n");
3178 queue_delayed_work(ata_aux_wq, &ap->hotplug_task,
3179 round_jiffies_relative(HZ));
3183 * ata_scsi_offline_dev - offline attached SCSI device
3184 * @dev: ATA device to offline attached SCSI device for
3186 * This function is called from ata_eh_hotplug() and responsible
3187 * for taking the SCSI device attached to @dev offline. This
3188 * function is called with host lock which protects dev->sdev
3192 * spin_lock_irqsave(host lock)
3195 * 1 if attached SCSI device exists, 0 otherwise.
3197 int ata_scsi_offline_dev(struct ata_device *dev)
3200 scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
3207 * ata_scsi_remove_dev - remove attached SCSI device
3208 * @dev: ATA device to remove attached SCSI device for
3210 * This function is called from ata_eh_scsi_hotplug() and
3211 * responsible for removing the SCSI device attached to @dev.
3214 * Kernel thread context (may sleep).
3216 static void ata_scsi_remove_dev(struct ata_device *dev)
3218 struct ata_port *ap = dev->link->ap;
3219 struct scsi_device *sdev;
3220 unsigned long flags;
3222 /* Alas, we need to grab scan_mutex to ensure SCSI device
3223 * state doesn't change underneath us and thus
3224 * scsi_device_get() always succeeds. The mutex locking can
3225 * be removed if there is __scsi_device_get() interface which
3226 * increments reference counts regardless of device state.
3228 mutex_lock(&ap->scsi_host->scan_mutex);
3229 spin_lock_irqsave(ap->lock, flags);
3231 /* clearing dev->sdev is protected by host lock */
3236 /* If user initiated unplug races with us, sdev can go
3237 * away underneath us after the host lock and
3238 * scan_mutex are released. Hold onto it.
3240 if (scsi_device_get(sdev) == 0) {
3241 /* The following ensures the attached sdev is
3242 * offline on return from ata_scsi_offline_dev()
3243 * regardless it wins or loses the race
3244 * against this function.
3246 scsi_device_set_state(sdev, SDEV_OFFLINE);
3253 spin_unlock_irqrestore(ap->lock, flags);
3254 mutex_unlock(&ap->scsi_host->scan_mutex);
3257 ata_dev_printk(dev, KERN_INFO, "detaching (SCSI %s)\n",
3258 sdev->sdev_gendev.bus_id);
3260 scsi_remove_device(sdev);
3261 scsi_device_put(sdev);
3265 static void ata_scsi_handle_link_detach(struct ata_link *link)
3267 struct ata_port *ap = link->ap;
3268 struct ata_device *dev;
3270 ata_link_for_each_dev(dev, link) {
3271 unsigned long flags;
3273 if (!(dev->flags & ATA_DFLAG_DETACHED))
3276 spin_lock_irqsave(ap->lock, flags);
3277 dev->flags &= ~ATA_DFLAG_DETACHED;
3278 spin_unlock_irqrestore(ap->lock, flags);
3280 ata_scsi_remove_dev(dev);
3285 * ata_scsi_media_change_notify - send media change event
3286 * @dev: Pointer to the disk device with media change event
3288 * Tell the block layer to send a media change notification
3292 * spin_lock_irqsave(host lock)
3294 void ata_scsi_media_change_notify(struct ata_device *dev)
3296 #ifdef OTHER_AN_PATCHES_HAVE_BEEN_APPLIED
3298 scsi_device_event_notify(dev->sdev, SDEV_MEDIA_CHANGE);
3303 * ata_scsi_hotplug - SCSI part of hotplug
3304 * @work: Pointer to ATA port to perform SCSI hotplug on
3306 * Perform SCSI part of hotplug. It's executed from a separate
3307 * workqueue after EH completes. This is necessary because SCSI
3308 * hot plugging requires working EH and hot unplugging is
3309 * synchronized with hot plugging with a mutex.
3312 * Kernel thread context (may sleep).
3314 void ata_scsi_hotplug(struct work_struct *work)
3316 struct ata_port *ap =
3317 container_of(work, struct ata_port, hotplug_task.work);
3320 if (ap->pflags & ATA_PFLAG_UNLOADING) {
3321 DPRINTK("ENTER/EXIT - unloading\n");
3327 /* Unplug detached devices. We cannot use link iterator here
3328 * because PMP links have to be scanned even if PMP is
3329 * currently not attached. Iterate manually.
3331 ata_scsi_handle_link_detach(&ap->link);
3333 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
3334 ata_scsi_handle_link_detach(&ap->pmp_link[i]);
3336 /* scan for new ones */
3337 ata_scsi_scan_host(ap, 0);
3343 * ata_scsi_user_scan - indication for user-initiated bus scan
3344 * @shost: SCSI host to scan
3345 * @channel: Channel to scan
3349 * This function is called when user explicitly requests bus
3350 * scan. Set probe pending flag and invoke EH.
3353 * SCSI layer (we don't care)
3358 static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
3359 unsigned int id, unsigned int lun)
3361 struct ata_port *ap = ata_shost_to_port(shost);
3362 unsigned long flags;
3365 if (!ap->ops->error_handler)
3368 if (lun != SCAN_WILD_CARD && lun)
3371 if (ap->nr_pmp_links == 0) {
3372 if (channel != SCAN_WILD_CARD && channel)
3376 if (id != SCAN_WILD_CARD && id)
3381 spin_lock_irqsave(ap->lock, flags);
3383 if (devno == SCAN_WILD_CARD) {
3384 struct ata_link *link;
3386 ata_port_for_each_link(link, ap) {
3387 struct ata_eh_info *ehi = &link->eh_info;
3388 ehi->probe_mask |= (1 << ata_link_max_devices(link)) - 1;
3389 ehi->action |= ATA_EH_SOFTRESET;
3392 struct ata_device *dev = ata_find_dev(ap, devno);
3395 struct ata_eh_info *ehi = &dev->link->eh_info;
3396 ehi->probe_mask |= 1 << dev->devno;
3397 ehi->action |= ATA_EH_SOFTRESET;
3398 ehi->flags |= ATA_EHI_RESUME_LINK;
3404 ata_port_schedule_eh(ap);
3405 spin_unlock_irqrestore(ap->lock, flags);
3406 ata_port_wait_eh(ap);
3408 spin_unlock_irqrestore(ap->lock, flags);
3414 * ata_scsi_dev_rescan - initiate scsi_rescan_device()
3415 * @work: Pointer to ATA port to perform scsi_rescan_device()
3417 * After ATA pass thru (SAT) commands are executed successfully,
3418 * libata need to propagate the changes to SCSI layer. This
3419 * function must be executed from ata_aux_wq such that sdev
3420 * attach/detach don't race with rescan.
3423 * Kernel thread context (may sleep).
3425 void ata_scsi_dev_rescan(struct work_struct *work)
3427 struct ata_port *ap =
3428 container_of(work, struct ata_port, scsi_rescan_task);
3429 struct ata_link *link;
3430 struct ata_device *dev;
3431 unsigned long flags;
3433 spin_lock_irqsave(ap->lock, flags);
3435 ata_port_for_each_link(link, ap) {
3436 ata_link_for_each_dev(dev, link) {
3437 struct scsi_device *sdev = dev->sdev;
3439 if (!ata_dev_enabled(dev) || !sdev)
3441 if (scsi_device_get(sdev))
3444 spin_unlock_irqrestore(ap->lock, flags);
3445 scsi_rescan_device(&(sdev->sdev_gendev));
3446 scsi_device_put(sdev);
3447 spin_lock_irqsave(ap->lock, flags);
3451 spin_unlock_irqrestore(ap->lock, flags);
3455 * ata_sas_port_alloc - Allocate port for a SAS attached SATA device
3456 * @host: ATA host container for all SAS ports
3457 * @port_info: Information from low-level host driver
3458 * @shost: SCSI host that the scsi device is attached to
3461 * PCI/etc. bus probe sem.
3464 * ata_port pointer on success / NULL on failure.
3467 struct ata_port *ata_sas_port_alloc(struct ata_host *host,
3468 struct ata_port_info *port_info,
3469 struct Scsi_Host *shost)
3471 struct ata_port *ap;
3473 ap = ata_port_alloc(host);
3478 ap->lock = shost->host_lock;
3479 ap->pio_mask = port_info->pio_mask;
3480 ap->mwdma_mask = port_info->mwdma_mask;
3481 ap->udma_mask = port_info->udma_mask;
3482 ap->flags |= port_info->flags;
3483 ap->ops = port_info->port_ops;
3484 ap->cbl = ATA_CBL_SATA;
3488 EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
3491 * ata_sas_port_start - Set port up for dma.
3492 * @ap: Port to initialize
3494 * Called just after data structures for each port are
3495 * initialized. Allocates DMA pad.
3497 * May be used as the port_start() entry in ata_port_operations.
3500 * Inherited from caller.
3502 int ata_sas_port_start(struct ata_port *ap)
3504 return ata_pad_alloc(ap, ap->dev);
3506 EXPORT_SYMBOL_GPL(ata_sas_port_start);
3509 * ata_port_stop - Undo ata_sas_port_start()
3510 * @ap: Port to shut down
3512 * Frees the DMA pad.
3514 * May be used as the port_stop() entry in ata_port_operations.
3517 * Inherited from caller.
3520 void ata_sas_port_stop(struct ata_port *ap)
3522 ata_pad_free(ap, ap->dev);
3524 EXPORT_SYMBOL_GPL(ata_sas_port_stop);
3527 * ata_sas_port_init - Initialize a SATA device
3528 * @ap: SATA port to initialize
3531 * PCI/etc. bus probe sem.
3534 * Zero on success, non-zero on error.
3537 int ata_sas_port_init(struct ata_port *ap)
3539 int rc = ap->ops->port_start(ap);
3542 ap->print_id = ata_print_id++;
3543 rc = ata_bus_probe(ap);
3548 EXPORT_SYMBOL_GPL(ata_sas_port_init);
3551 * ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc
3552 * @ap: SATA port to destroy
3556 void ata_sas_port_destroy(struct ata_port *ap)
3558 if (ap->ops->port_stop)
3559 ap->ops->port_stop(ap);
3562 EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
3565 * ata_sas_slave_configure - Default slave_config routine for libata devices
3566 * @sdev: SCSI device to configure
3567 * @ap: ATA port to which SCSI device is attached
3573 int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
3575 ata_scsi_sdev_config(sdev);
3576 ata_scsi_dev_config(sdev, ap->link.device);
3579 EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
3582 * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
3583 * @cmd: SCSI command to be sent
3584 * @done: Completion function, called when command is complete
3585 * @ap: ATA port to which the command is being sent
3588 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
3592 int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
3593 struct ata_port *ap)
3597 ata_scsi_dump_cdb(ap, cmd);
3599 if (likely(ata_scsi_dev_enabled(ap->link.device)))
3600 rc = __ata_scsi_queuecmd(cmd, done, ap->link.device);
3602 cmd->result = (DID_BAD_TARGET << 16);
3607 EXPORT_SYMBOL_GPL(ata_sas_queuecmd);