1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * libata-scsi.c - helper library for ATA
5 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
6 * Copyright 2003-2004 Jeff Garzik
8 * libata documentation is available via 'make {ps|pdf}docs',
9 * as Documentation/driver-api/libata.rst
11 * Hardware documentation available from
12 * - http://www.t10.org/
13 * - http://www.t13.org/
16 #include <linux/compat.h>
17 #include <linux/slab.h>
18 #include <linux/kernel.h>
19 #include <linux/blkdev.h>
20 #include <linux/spinlock.h>
21 #include <linux/export.h>
22 #include <scsi/scsi.h>
23 #include <scsi/scsi_host.h>
24 #include <scsi/scsi_cmnd.h>
25 #include <scsi/scsi_eh.h>
26 #include <scsi/scsi_device.h>
27 #include <scsi/scsi_tcq.h>
28 #include <scsi/scsi_transport.h>
29 #include <linux/libata.h>
30 #include <linux/hdreg.h>
31 #include <linux/uaccess.h>
32 #include <linux/suspend.h>
33 #include <asm/unaligned.h>
34 #include <linux/ioprio.h>
38 #include "libata-transport.h"
40 #define ATA_SCSI_RBUF_SIZE 576
42 static DEFINE_SPINLOCK(ata_scsi_rbuf_lock
);
43 static u8 ata_scsi_rbuf
[ATA_SCSI_RBUF_SIZE
];
45 typedef unsigned int (*ata_xlat_func_t
)(struct ata_queued_cmd
*qc
);
47 static struct ata_device
*__ata_scsi_find_dev(struct ata_port
*ap
,
48 const struct scsi_device
*scsidev
);
50 #define RW_RECOVERY_MPAGE 0x1
51 #define RW_RECOVERY_MPAGE_LEN 12
52 #define CACHE_MPAGE 0x8
53 #define CACHE_MPAGE_LEN 20
54 #define CONTROL_MPAGE 0xa
55 #define CONTROL_MPAGE_LEN 12
56 #define ALL_MPAGES 0x3f
57 #define ALL_SUB_MPAGES 0xff
60 static const u8 def_rw_recovery_mpage
[RW_RECOVERY_MPAGE_LEN
] = {
62 RW_RECOVERY_MPAGE_LEN
- 2,
64 0, /* read retry count */
66 0, /* write retry count */
70 static const u8 def_cache_mpage
[CACHE_MPAGE_LEN
] = {
73 0, /* contains WCE, needs to be 0 for logic */
74 0, 0, 0, 0, 0, 0, 0, 0, 0,
75 0, /* contains DRA, needs to be 0 for logic */
79 static const u8 def_control_mpage
[CONTROL_MPAGE_LEN
] = {
81 CONTROL_MPAGE_LEN
- 2,
82 2, /* DSENSE=0, GLTSD=1 */
83 0, /* [QAM+QERR may be 1, see 05-359r1] */
84 0, 0, 0, 0, 0xff, 0xff,
85 0, 30 /* extended self test time, see 05-359r1 */
88 static ssize_t
ata_scsi_park_show(struct device
*device
,
89 struct device_attribute
*attr
, char *buf
)
91 struct scsi_device
*sdev
= to_scsi_device(device
);
93 struct ata_link
*link
;
94 struct ata_device
*dev
;
99 ap
= ata_shost_to_port(sdev
->host
);
101 spin_lock_irq(ap
->lock
);
102 dev
= ata_scsi_find_dev(ap
, sdev
);
107 if (dev
->flags
& ATA_DFLAG_NO_UNLOAD
) {
114 if (ap
->pflags
& ATA_PFLAG_EH_IN_PROGRESS
&&
115 link
->eh_context
.unloaded_mask
& (1 << dev
->devno
) &&
116 time_after(dev
->unpark_deadline
, now
))
117 msecs
= jiffies_to_msecs(dev
->unpark_deadline
- now
);
122 spin_unlock_irq(ap
->lock
);
124 return rc
? rc
: snprintf(buf
, 20, "%u\n", msecs
);
127 static ssize_t
ata_scsi_park_store(struct device
*device
,
128 struct device_attribute
*attr
,
129 const char *buf
, size_t len
)
131 struct scsi_device
*sdev
= to_scsi_device(device
);
133 struct ata_device
*dev
;
138 rc
= kstrtol(buf
, 10, &input
);
143 if (input
> ATA_TMOUT_MAX_PARK
) {
145 input
= ATA_TMOUT_MAX_PARK
;
148 ap
= ata_shost_to_port(sdev
->host
);
150 spin_lock_irqsave(ap
->lock
, flags
);
151 dev
= ata_scsi_find_dev(ap
, sdev
);
152 if (unlikely(!dev
)) {
156 if (dev
->class != ATA_DEV_ATA
&&
157 dev
->class != ATA_DEV_ZAC
) {
163 if (dev
->flags
& ATA_DFLAG_NO_UNLOAD
) {
168 dev
->unpark_deadline
= ata_deadline(jiffies
, input
);
169 dev
->link
->eh_info
.dev_action
[dev
->devno
] |= ATA_EH_PARK
;
170 ata_port_schedule_eh(ap
);
171 complete(&ap
->park_req_pending
);
175 dev
->flags
&= ~ATA_DFLAG_NO_UNLOAD
;
178 dev
->flags
|= ATA_DFLAG_NO_UNLOAD
;
183 spin_unlock_irqrestore(ap
->lock
, flags
);
185 return rc
? rc
: len
;
187 DEVICE_ATTR(unload_heads
, S_IRUGO
| S_IWUSR
,
188 ata_scsi_park_show
, ata_scsi_park_store
);
189 EXPORT_SYMBOL_GPL(dev_attr_unload_heads
);
191 void ata_scsi_set_sense(struct ata_device
*dev
, struct scsi_cmnd
*cmd
,
192 u8 sk
, u8 asc
, u8 ascq
)
194 bool d_sense
= (dev
->flags
& ATA_DFLAG_D_SENSE
);
199 cmd
->result
= (DRIVER_SENSE
<< 24) | SAM_STAT_CHECK_CONDITION
;
201 scsi_build_sense_buffer(d_sense
, cmd
->sense_buffer
, sk
, asc
, ascq
);
204 void ata_scsi_set_sense_information(struct ata_device
*dev
,
205 struct scsi_cmnd
*cmd
,
206 const struct ata_taskfile
*tf
)
213 information
= ata_tf_read_block(tf
, dev
);
214 if (information
== U64_MAX
)
217 scsi_set_sense_information(cmd
->sense_buffer
,
218 SCSI_SENSE_BUFFERSIZE
, information
);
221 static void ata_scsi_set_invalid_field(struct ata_device
*dev
,
222 struct scsi_cmnd
*cmd
, u16 field
, u8 bit
)
224 ata_scsi_set_sense(dev
, cmd
, ILLEGAL_REQUEST
, 0x24, 0x0);
225 /* "Invalid field in CDB" */
226 scsi_set_sense_field_pointer(cmd
->sense_buffer
, SCSI_SENSE_BUFFERSIZE
,
230 static void ata_scsi_set_invalid_parameter(struct ata_device
*dev
,
231 struct scsi_cmnd
*cmd
, u16 field
)
233 /* "Invalid field in parameter list" */
234 ata_scsi_set_sense(dev
, cmd
, ILLEGAL_REQUEST
, 0x26, 0x0);
235 scsi_set_sense_field_pointer(cmd
->sense_buffer
, SCSI_SENSE_BUFFERSIZE
,
239 struct device_attribute
*ata_common_sdev_attrs
[] = {
240 &dev_attr_unload_heads
,
243 EXPORT_SYMBOL_GPL(ata_common_sdev_attrs
);
246 * ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
247 * @sdev: SCSI device for which BIOS geometry is to be determined
248 * @bdev: block device associated with @sdev
249 * @capacity: capacity of SCSI device
250 * @geom: location to which geometry will be output
252 * Generic bios head/sector/cylinder calculator
253 * used by sd. Most BIOSes nowadays expect a XXX/255/16 (CHS)
254 * mapping. Some situations may arise where the disk is not
255 * bootable if this is not used.
258 * Defined by the SCSI layer. We don't really care.
263 int ata_std_bios_param(struct scsi_device
*sdev
, struct block_device
*bdev
,
264 sector_t capacity
, int geom
[])
268 sector_div(capacity
, 255*63);
273 EXPORT_SYMBOL_GPL(ata_std_bios_param
);
276 * ata_scsi_unlock_native_capacity - unlock native capacity
277 * @sdev: SCSI device to adjust device capacity for
279 * This function is called if a partition on @sdev extends beyond
280 * the end of the device. It requests EH to unlock HPA.
283 * Defined by the SCSI layer. Might sleep.
285 void ata_scsi_unlock_native_capacity(struct scsi_device
*sdev
)
287 struct ata_port
*ap
= ata_shost_to_port(sdev
->host
);
288 struct ata_device
*dev
;
291 spin_lock_irqsave(ap
->lock
, flags
);
293 dev
= ata_scsi_find_dev(ap
, sdev
);
294 if (dev
&& dev
->n_sectors
< dev
->n_native_sectors
) {
295 dev
->flags
|= ATA_DFLAG_UNLOCK_HPA
;
296 dev
->link
->eh_info
.action
|= ATA_EH_RESET
;
297 ata_port_schedule_eh(ap
);
300 spin_unlock_irqrestore(ap
->lock
, flags
);
301 ata_port_wait_eh(ap
);
303 EXPORT_SYMBOL_GPL(ata_scsi_unlock_native_capacity
);
306 * ata_get_identity - Handler for HDIO_GET_IDENTITY ioctl
308 * @sdev: SCSI device to get identify data for
309 * @arg: User buffer area for identify data
312 * Defined by the SCSI layer. We don't really care.
315 * Zero on success, negative errno on error.
317 static int ata_get_identity(struct ata_port
*ap
, struct scsi_device
*sdev
,
320 struct ata_device
*dev
= ata_scsi_find_dev(ap
, sdev
);
321 u16 __user
*dst
= arg
;
327 if (copy_to_user(dst
, dev
->id
, ATA_ID_WORDS
* sizeof(u16
)))
330 ata_id_string(dev
->id
, buf
, ATA_ID_PROD
, ATA_ID_PROD_LEN
);
331 if (copy_to_user(dst
+ ATA_ID_PROD
, buf
, ATA_ID_PROD_LEN
))
334 ata_id_string(dev
->id
, buf
, ATA_ID_FW_REV
, ATA_ID_FW_REV_LEN
);
335 if (copy_to_user(dst
+ ATA_ID_FW_REV
, buf
, ATA_ID_FW_REV_LEN
))
338 ata_id_string(dev
->id
, buf
, ATA_ID_SERNO
, ATA_ID_SERNO_LEN
);
339 if (copy_to_user(dst
+ ATA_ID_SERNO
, buf
, ATA_ID_SERNO_LEN
))
346 * ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
347 * @scsidev: Device to which we are issuing command
348 * @arg: User provided data for issuing command
351 * Defined by the SCSI layer. We don't really care.
354 * Zero on success, negative errno on error.
356 int ata_cmd_ioctl(struct scsi_device
*scsidev
, void __user
*arg
)
359 u8 sensebuf
[SCSI_SENSE_BUFFERSIZE
];
360 u8 scsi_cmd
[MAX_COMMAND_SIZE
];
361 u8 args
[4], *argbuf
= NULL
;
363 enum dma_data_direction data_dir
;
364 struct scsi_sense_hdr sshdr
;
370 if (copy_from_user(args
, arg
, sizeof(args
)))
373 memset(sensebuf
, 0, sizeof(sensebuf
));
374 memset(scsi_cmd
, 0, sizeof(scsi_cmd
));
377 argsize
= ATA_SECT_SIZE
* args
[3];
378 argbuf
= kmalloc(argsize
, GFP_KERNEL
);
379 if (argbuf
== NULL
) {
384 scsi_cmd
[1] = (4 << 1); /* PIO Data-in */
385 scsi_cmd
[2] = 0x0e; /* no off.line or cc, read from dev,
386 block count in sector count field */
387 data_dir
= DMA_FROM_DEVICE
;
389 scsi_cmd
[1] = (3 << 1); /* Non-data */
390 scsi_cmd
[2] = 0x20; /* cc but no off.line or data xfer */
394 scsi_cmd
[0] = ATA_16
;
396 scsi_cmd
[4] = args
[2];
397 if (args
[0] == ATA_CMD_SMART
) { /* hack -- ide driver does this too */
398 scsi_cmd
[6] = args
[3];
399 scsi_cmd
[8] = args
[1];
400 scsi_cmd
[10] = ATA_SMART_LBAM_PASS
;
401 scsi_cmd
[12] = ATA_SMART_LBAH_PASS
;
403 scsi_cmd
[6] = args
[1];
405 scsi_cmd
[14] = args
[0];
407 /* Good values for timeout and retries? Values below
408 from scsi_ioctl_send_command() for default case... */
409 cmd_result
= scsi_execute(scsidev
, scsi_cmd
, data_dir
, argbuf
, argsize
,
410 sensebuf
, &sshdr
, (10*HZ
), 5, 0, 0, NULL
);
412 if (driver_byte(cmd_result
) == DRIVER_SENSE
) {/* sense data available */
413 u8
*desc
= sensebuf
+ 8;
414 cmd_result
&= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
416 /* If we set cc then ATA pass-through will cause a
417 * check condition even if no error. Filter that. */
418 if (cmd_result
& SAM_STAT_CHECK_CONDITION
) {
419 if (sshdr
.sense_key
== RECOVERED_ERROR
&&
420 sshdr
.asc
== 0 && sshdr
.ascq
== 0x1d)
421 cmd_result
&= ~SAM_STAT_CHECK_CONDITION
;
424 /* Send userspace a few ATA registers (same as drivers/ide) */
425 if (sensebuf
[0] == 0x72 && /* format is "descriptor" */
426 desc
[0] == 0x09) { /* code is "ATA Descriptor" */
427 args
[0] = desc
[13]; /* status */
428 args
[1] = desc
[3]; /* error */
429 args
[2] = desc
[5]; /* sector count (0:7) */
430 if (copy_to_user(arg
, args
, sizeof(args
)))
442 && copy_to_user(arg
+ sizeof(args
), argbuf
, argsize
))
450 * ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
451 * @scsidev: Device to which we are issuing command
452 * @arg: User provided data for issuing command
455 * Defined by the SCSI layer. We don't really care.
458 * Zero on success, negative errno on error.
460 int ata_task_ioctl(struct scsi_device
*scsidev
, void __user
*arg
)
463 u8 sensebuf
[SCSI_SENSE_BUFFERSIZE
];
464 u8 scsi_cmd
[MAX_COMMAND_SIZE
];
466 struct scsi_sense_hdr sshdr
;
472 if (copy_from_user(args
, arg
, sizeof(args
)))
475 memset(sensebuf
, 0, sizeof(sensebuf
));
476 memset(scsi_cmd
, 0, sizeof(scsi_cmd
));
477 scsi_cmd
[0] = ATA_16
;
478 scsi_cmd
[1] = (3 << 1); /* Non-data */
479 scsi_cmd
[2] = 0x20; /* cc but no off.line or data xfer */
480 scsi_cmd
[4] = args
[1];
481 scsi_cmd
[6] = args
[2];
482 scsi_cmd
[8] = args
[3];
483 scsi_cmd
[10] = args
[4];
484 scsi_cmd
[12] = args
[5];
485 scsi_cmd
[13] = args
[6] & 0x4f;
486 scsi_cmd
[14] = args
[0];
488 /* Good values for timeout and retries? Values below
489 from scsi_ioctl_send_command() for default case... */
490 cmd_result
= scsi_execute(scsidev
, scsi_cmd
, DMA_NONE
, NULL
, 0,
491 sensebuf
, &sshdr
, (10*HZ
), 5, 0, 0, NULL
);
493 if (driver_byte(cmd_result
) == DRIVER_SENSE
) {/* sense data available */
494 u8
*desc
= sensebuf
+ 8;
495 cmd_result
&= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
497 /* If we set cc then ATA pass-through will cause a
498 * check condition even if no error. Filter that. */
499 if (cmd_result
& SAM_STAT_CHECK_CONDITION
) {
500 if (sshdr
.sense_key
== RECOVERED_ERROR
&&
501 sshdr
.asc
== 0 && sshdr
.ascq
== 0x1d)
502 cmd_result
&= ~SAM_STAT_CHECK_CONDITION
;
505 /* Send userspace ATA registers */
506 if (sensebuf
[0] == 0x72 && /* format is "descriptor" */
507 desc
[0] == 0x09) {/* code is "ATA Descriptor" */
508 args
[0] = desc
[13]; /* status */
509 args
[1] = desc
[3]; /* error */
510 args
[2] = desc
[5]; /* sector count (0:7) */
511 args
[3] = desc
[7]; /* lbal */
512 args
[4] = desc
[9]; /* lbam */
513 args
[5] = desc
[11]; /* lbah */
514 args
[6] = desc
[12]; /* select */
515 if (copy_to_user(arg
, args
, sizeof(args
)))
529 static int ata_ioc32(struct ata_port
*ap
)
531 if (ap
->flags
& ATA_FLAG_PIO_DMA
)
533 if (ap
->pflags
& ATA_PFLAG_PIO32
)
539 * This handles both native and compat commands, so anything added
540 * here must have a compatible argument, or check in_compat_syscall()
542 int ata_sas_scsi_ioctl(struct ata_port
*ap
, struct scsi_device
*scsidev
,
543 unsigned int cmd
, void __user
*arg
)
551 spin_lock_irqsave(ap
->lock
, flags
);
553 spin_unlock_irqrestore(ap
->lock
, flags
);
555 if (in_compat_syscall())
556 return put_user(val
, (compat_ulong_t __user
*)arg
);
558 return put_user(val
, (unsigned long __user
*)arg
);
561 val
= (unsigned long) arg
;
563 spin_lock_irqsave(ap
->lock
, flags
);
564 if (ap
->pflags
& ATA_PFLAG_PIO32CHANGE
) {
566 ap
->pflags
|= ATA_PFLAG_PIO32
;
568 ap
->pflags
&= ~ATA_PFLAG_PIO32
;
570 if (val
!= ata_ioc32(ap
))
573 spin_unlock_irqrestore(ap
->lock
, flags
);
576 case HDIO_GET_IDENTITY
:
577 return ata_get_identity(ap
, scsidev
, arg
);
580 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
582 return ata_cmd_ioctl(scsidev
, arg
);
584 case HDIO_DRIVE_TASK
:
585 if (!capable(CAP_SYS_ADMIN
) || !capable(CAP_SYS_RAWIO
))
587 return ata_task_ioctl(scsidev
, arg
);
596 EXPORT_SYMBOL_GPL(ata_sas_scsi_ioctl
);
598 int ata_scsi_ioctl(struct scsi_device
*scsidev
, unsigned int cmd
,
601 return ata_sas_scsi_ioctl(ata_shost_to_port(scsidev
->host
),
604 EXPORT_SYMBOL_GPL(ata_scsi_ioctl
);
607 * ata_scsi_qc_new - acquire new ata_queued_cmd reference
608 * @dev: ATA device to which the new command is attached
609 * @cmd: SCSI command that originated this ATA command
611 * Obtain a reference to an unused ata_queued_cmd structure,
612 * which is the basic libata structure representing a single
613 * ATA command sent to the hardware.
615 * If a command was available, fill in the SCSI-specific
616 * portions of the structure with information on the
620 * spin_lock_irqsave(host lock)
623 * Command allocated, or %NULL if none available.
625 static struct ata_queued_cmd
*ata_scsi_qc_new(struct ata_device
*dev
,
626 struct scsi_cmnd
*cmd
)
628 struct ata_queued_cmd
*qc
;
630 qc
= ata_qc_new_init(dev
, cmd
->request
->tag
);
633 qc
->scsidone
= cmd
->scsi_done
;
635 qc
->sg
= scsi_sglist(cmd
);
636 qc
->n_elem
= scsi_sg_count(cmd
);
638 if (cmd
->request
->rq_flags
& RQF_QUIET
)
639 qc
->flags
|= ATA_QCFLAG_QUIET
;
641 cmd
->result
= (DID_OK
<< 16) | (QUEUE_FULL
<< 1);
648 static void ata_qc_set_pc_nbytes(struct ata_queued_cmd
*qc
)
650 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
652 qc
->extrabytes
= scmd
->extra_len
;
653 qc
->nbytes
= scsi_bufflen(scmd
) + qc
->extrabytes
;
657 * ata_dump_status - user friendly display of error info
658 * @id: id of the port in question
659 * @tf: ptr to filled out taskfile
661 * Decode and dump the ATA error/status registers for the user so
662 * that they have some idea what really happened at the non
663 * make-believe layer.
666 * inherited from caller
668 static void ata_dump_status(unsigned id
, struct ata_taskfile
*tf
)
670 u8 stat
= tf
->command
, err
= tf
->feature
;
672 pr_warn("ata%u: status=0x%02x { ", id
, stat
);
673 if (stat
& ATA_BUSY
) {
674 pr_cont("Busy }\n"); /* Data is not valid in this case */
676 if (stat
& ATA_DRDY
) pr_cont("DriveReady ");
677 if (stat
& ATA_DF
) pr_cont("DeviceFault ");
678 if (stat
& ATA_DSC
) pr_cont("SeekComplete ");
679 if (stat
& ATA_DRQ
) pr_cont("DataRequest ");
680 if (stat
& ATA_CORR
) pr_cont("CorrectedError ");
681 if (stat
& ATA_SENSE
) pr_cont("Sense ");
682 if (stat
& ATA_ERR
) pr_cont("Error ");
686 pr_warn("ata%u: error=0x%02x { ", id
, err
);
687 if (err
& ATA_ABORTED
) pr_cont("DriveStatusError ");
688 if (err
& ATA_ICRC
) {
689 if (err
& ATA_ABORTED
)
691 else pr_cont("Sector ");
693 if (err
& ATA_UNC
) pr_cont("UncorrectableError ");
694 if (err
& ATA_IDNF
) pr_cont("SectorIdNotFound ");
695 if (err
& ATA_TRK0NF
) pr_cont("TrackZeroNotFound ");
696 if (err
& ATA_AMNF
) pr_cont("AddrMarkNotFound ");
703 * ata_to_sense_error - convert ATA error to SCSI error
704 * @id: ATA device number
705 * @drv_stat: value contained in ATA status register
706 * @drv_err: value contained in ATA error register
707 * @sk: the sense key we'll fill out
708 * @asc: the additional sense code we'll fill out
709 * @ascq: the additional sense code qualifier we'll fill out
710 * @verbose: be verbose
712 * Converts an ATA error into a SCSI error. Fill out pointers to
713 * SK, ASC, and ASCQ bytes for later use in fixed or descriptor
714 * format sense blocks.
717 * spin_lock_irqsave(host lock)
719 static void ata_to_sense_error(unsigned id
, u8 drv_stat
, u8 drv_err
, u8
*sk
,
720 u8
*asc
, u8
*ascq
, int verbose
)
724 /* Based on the 3ware driver translation table */
725 static const unsigned char sense_table
[][4] = {
727 {0xd1, ABORTED_COMMAND
, 0x00, 0x00},
728 // Device busy Aborted command
730 {0xd0, ABORTED_COMMAND
, 0x00, 0x00},
731 // Device busy Aborted command
733 {0x61, HARDWARE_ERROR
, 0x00, 0x00},
734 // Device fault Hardware error
735 /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
736 {0x84, ABORTED_COMMAND
, 0x47, 0x00},
737 // Data CRC error SCSI parity error
738 /* MC|ID|ABRT|TRK0|MARK */
739 {0x37, NOT_READY
, 0x04, 0x00},
740 // Unit offline Not ready
742 {0x09, NOT_READY
, 0x04, 0x00},
743 // Unrecovered disk error Not ready
744 /* Bad address mark */
745 {0x01, MEDIUM_ERROR
, 0x13, 0x00},
746 // Address mark not found for data field
747 /* TRK0 - Track 0 not found */
748 {0x02, HARDWARE_ERROR
, 0x00, 0x00},
750 /* Abort: 0x04 is not translated here, see below */
751 /* Media change request */
752 {0x08, NOT_READY
, 0x04, 0x00},
753 // FIXME: faking offline
754 /* SRV/IDNF - ID not found */
755 {0x10, ILLEGAL_REQUEST
, 0x21, 0x00},
756 // Logical address out of range
757 /* MC - Media Changed */
758 {0x20, UNIT_ATTENTION
, 0x28, 0x00},
759 // Not ready to ready change, medium may have changed
760 /* ECC - Uncorrectable ECC error */
761 {0x40, MEDIUM_ERROR
, 0x11, 0x04},
762 // Unrecovered read error
763 /* BBD - block marked bad */
764 {0x80, MEDIUM_ERROR
, 0x11, 0x04},
765 // Block marked bad Medium error, unrecovered read error
766 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
768 static const unsigned char stat_table
[][4] = {
769 /* Must be first because BUSY means no other bits valid */
770 {0x80, ABORTED_COMMAND
, 0x47, 0x00},
771 // Busy, fake parity for now
772 {0x40, ILLEGAL_REQUEST
, 0x21, 0x04},
773 // Device ready, unaligned write command
774 {0x20, HARDWARE_ERROR
, 0x44, 0x00},
775 // Device fault, internal target failure
776 {0x08, ABORTED_COMMAND
, 0x47, 0x00},
777 // Timed out in xfer, fake parity for now
778 {0x04, RECOVERED_ERROR
, 0x11, 0x00},
779 // Recovered ECC error Medium error, recovered
780 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
784 * Is this an error we can process/parse
786 if (drv_stat
& ATA_BUSY
) {
787 drv_err
= 0; /* Ignore the err bits, they're invalid */
791 /* Look for drv_err */
792 for (i
= 0; sense_table
[i
][0] != 0xFF; i
++) {
793 /* Look for best matches first */
794 if ((sense_table
[i
][0] & drv_err
) ==
796 *sk
= sense_table
[i
][1];
797 *asc
= sense_table
[i
][2];
798 *ascq
= sense_table
[i
][3];
805 * Fall back to interpreting status bits. Note that if the drv_err
806 * has only the ABRT bit set, we decode drv_stat. ABRT by itself
807 * is not descriptive enough.
809 for (i
= 0; stat_table
[i
][0] != 0xFF; i
++) {
810 if (stat_table
[i
][0] & drv_stat
) {
811 *sk
= stat_table
[i
][1];
812 *asc
= stat_table
[i
][2];
813 *ascq
= stat_table
[i
][3];
819 * We need a sensible error return here, which is tricky, and one
820 * that won't cause people to do things like return a disk wrongly.
822 *sk
= ABORTED_COMMAND
;
828 pr_err("ata%u: translated ATA stat/err 0x%02x/%02x to SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n",
829 id
, drv_stat
, drv_err
, *sk
, *asc
, *ascq
);
834 * ata_gen_passthru_sense - Generate check condition sense block.
835 * @qc: Command that completed.
837 * This function is specific to the ATA descriptor format sense
838 * block specified for the ATA pass through commands. Regardless
839 * of whether the command errored or not, return a sense
840 * block. Copy all controller registers into the sense
841 * block. If there was no error, we get the request from an ATA
842 * passthrough command, so we use the following sense data:
843 * sk = RECOVERED ERROR
844 * asc,ascq = ATA PASS-THROUGH INFORMATION AVAILABLE
850 static void ata_gen_passthru_sense(struct ata_queued_cmd
*qc
)
852 struct scsi_cmnd
*cmd
= qc
->scsicmd
;
853 struct ata_taskfile
*tf
= &qc
->result_tf
;
854 unsigned char *sb
= cmd
->sense_buffer
;
855 unsigned char *desc
= sb
+ 8;
856 int verbose
= qc
->ap
->ops
->error_handler
== NULL
;
857 u8 sense_key
, asc
, ascq
;
859 memset(sb
, 0, SCSI_SENSE_BUFFERSIZE
);
861 cmd
->result
= (DRIVER_SENSE
<< 24) | SAM_STAT_CHECK_CONDITION
;
864 * Use ata_to_sense_error() to map status register bits
865 * onto sense key, asc & ascq.
868 tf
->command
& (ATA_BUSY
| ATA_DF
| ATA_ERR
| ATA_DRQ
)) {
869 ata_to_sense_error(qc
->ap
->print_id
, tf
->command
, tf
->feature
,
870 &sense_key
, &asc
, &ascq
, verbose
);
871 ata_scsi_set_sense(qc
->dev
, cmd
, sense_key
, asc
, ascq
);
874 * ATA PASS-THROUGH INFORMATION AVAILABLE
875 * Always in descriptor format sense.
877 scsi_build_sense_buffer(1, cmd
->sense_buffer
,
878 RECOVERED_ERROR
, 0, 0x1D);
881 if ((cmd
->sense_buffer
[0] & 0x7f) >= 0x72) {
884 /* descriptor format */
886 desc
= (char *)scsi_sense_desc_find(sb
, len
+ 8, 9);
888 if (SCSI_SENSE_BUFFERSIZE
< len
+ 14)
896 * Copy registers into sense buffer.
899 desc
[3] = tf
->feature
; /* == error reg */
904 desc
[12] = tf
->device
;
905 desc
[13] = tf
->command
; /* == status reg */
908 * Fill in Extend bit, and the high order bytes
911 if (tf
->flags
& ATA_TFLAG_LBA48
) {
913 desc
[4] = tf
->hob_nsect
;
914 desc
[6] = tf
->hob_lbal
;
915 desc
[8] = tf
->hob_lbam
;
916 desc
[10] = tf
->hob_lbah
;
919 /* Fixed sense format */
920 desc
[0] = tf
->feature
;
921 desc
[1] = tf
->command
; /* status */
922 desc
[2] = tf
->device
;
925 if (tf
->flags
& ATA_TFLAG_LBA48
) {
929 if (tf
->hob_lbal
|| tf
->hob_lbam
|| tf
->hob_lbah
)
939 * ata_gen_ata_sense - generate a SCSI fixed sense block
940 * @qc: Command that we are erroring out
942 * Generate sense block for a failed ATA command @qc. Descriptor
943 * format is used to accommodate LBA48 block address.
948 static void ata_gen_ata_sense(struct ata_queued_cmd
*qc
)
950 struct ata_device
*dev
= qc
->dev
;
951 struct scsi_cmnd
*cmd
= qc
->scsicmd
;
952 struct ata_taskfile
*tf
= &qc
->result_tf
;
953 unsigned char *sb
= cmd
->sense_buffer
;
954 int verbose
= qc
->ap
->ops
->error_handler
== NULL
;
956 u8 sense_key
, asc
, ascq
;
958 memset(sb
, 0, SCSI_SENSE_BUFFERSIZE
);
960 cmd
->result
= (DRIVER_SENSE
<< 24) | SAM_STAT_CHECK_CONDITION
;
962 if (ata_dev_disabled(dev
)) {
963 /* Device disabled after error recovery */
964 /* LOGICAL UNIT NOT READY, HARD RESET REQUIRED */
965 ata_scsi_set_sense(dev
, cmd
, NOT_READY
, 0x04, 0x21);
968 /* Use ata_to_sense_error() to map status register bits
969 * onto sense key, asc & ascq.
972 tf
->command
& (ATA_BUSY
| ATA_DF
| ATA_ERR
| ATA_DRQ
)) {
973 ata_to_sense_error(qc
->ap
->print_id
, tf
->command
, tf
->feature
,
974 &sense_key
, &asc
, &ascq
, verbose
);
975 ata_scsi_set_sense(dev
, cmd
, sense_key
, asc
, ascq
);
977 /* Could not decode error */
978 ata_dev_warn(dev
, "could not decode error status 0x%x err_mask 0x%x\n",
979 tf
->command
, qc
->err_mask
);
980 ata_scsi_set_sense(dev
, cmd
, ABORTED_COMMAND
, 0, 0);
984 block
= ata_tf_read_block(&qc
->result_tf
, dev
);
985 if (block
== U64_MAX
)
988 scsi_set_sense_information(sb
, SCSI_SENSE_BUFFERSIZE
, block
);
991 void ata_scsi_sdev_config(struct scsi_device
*sdev
)
993 sdev
->use_10_for_rw
= 1;
994 sdev
->use_10_for_ms
= 1;
995 sdev
->no_write_same
= 1;
997 /* Schedule policy is determined by ->qc_defer() callback and
998 * it needs to see every deferred qc. Set dev_blocked to 1 to
999 * prevent SCSI midlayer from automatically deferring
1002 sdev
->max_device_blocked
= 1;
1006 * ata_scsi_dma_need_drain - Check whether data transfer may overflow
1007 * @rq: request to be checked
1009 * ATAPI commands which transfer variable length data to host
1010 * might overflow due to application error or hardware bug. This
1011 * function checks whether overflow should be drained and ignored
1018 * 1 if ; otherwise, 0.
1020 bool ata_scsi_dma_need_drain(struct request
*rq
)
1022 return atapi_cmd_type(scsi_req(rq
)->cmd
[0]) == ATAPI_MISC
;
1024 EXPORT_SYMBOL_GPL(ata_scsi_dma_need_drain
);
1026 int ata_scsi_dev_config(struct scsi_device
*sdev
, struct ata_device
*dev
)
1028 struct request_queue
*q
= sdev
->request_queue
;
1030 if (!ata_id_has_unload(dev
->id
))
1031 dev
->flags
|= ATA_DFLAG_NO_UNLOAD
;
1033 /* configure max sectors */
1034 blk_queue_max_hw_sectors(q
, dev
->max_sectors
);
1036 if (dev
->class == ATA_DEV_ATAPI
) {
1037 sdev
->sector_size
= ATA_SECT_SIZE
;
1039 /* set DMA padding */
1040 blk_queue_update_dma_pad(q
, ATA_DMA_PAD_SZ
- 1);
1042 /* make room for appending the drain */
1043 blk_queue_max_segments(q
, queue_max_segments(q
) - 1);
1045 sdev
->dma_drain_len
= ATAPI_MAX_DRAIN
;
1046 sdev
->dma_drain_buf
= kmalloc(sdev
->dma_drain_len
,
1047 q
->bounce_gfp
| GFP_KERNEL
);
1048 if (!sdev
->dma_drain_buf
) {
1049 ata_dev_err(dev
, "drain buffer allocation failed\n");
1053 sdev
->sector_size
= ata_id_logical_sector_size(dev
->id
);
1054 sdev
->manage_start_stop
= 1;
1058 * ata_pio_sectors() expects buffer for each sector to not cross
1059 * page boundary. Enforce it by requiring buffers to be sector
1060 * aligned, which works iff sector_size is not larger than
1061 * PAGE_SIZE. ATAPI devices also need the alignment as
1062 * IDENTIFY_PACKET is executed as ATA_PROT_PIO.
1064 if (sdev
->sector_size
> PAGE_SIZE
)
1066 "sector_size=%u > PAGE_SIZE, PIO may malfunction\n",
1069 blk_queue_update_dma_alignment(q
, sdev
->sector_size
- 1);
1071 if (dev
->flags
& ATA_DFLAG_AN
)
1072 set_bit(SDEV_EVT_MEDIA_CHANGE
, sdev
->supported_events
);
1074 if (dev
->flags
& ATA_DFLAG_NCQ
) {
1077 depth
= min(sdev
->host
->can_queue
, ata_id_queue_depth(dev
->id
));
1078 depth
= min(ATA_MAX_QUEUE
, depth
);
1079 scsi_change_queue_depth(sdev
, depth
);
1082 if (dev
->flags
& ATA_DFLAG_TRUSTED
)
1083 sdev
->security_supported
= 1;
1090 * ata_scsi_slave_config - Set SCSI device attributes
1091 * @sdev: SCSI device to examine
1093 * This is called before we actually start reading
1094 * and writing to the device, to configure certain
1095 * SCSI mid-layer behaviors.
1098 * Defined by SCSI layer. We don't really care.
1101 int ata_scsi_slave_config(struct scsi_device
*sdev
)
1103 struct ata_port
*ap
= ata_shost_to_port(sdev
->host
);
1104 struct ata_device
*dev
= __ata_scsi_find_dev(ap
, sdev
);
1107 ata_scsi_sdev_config(sdev
);
1110 rc
= ata_scsi_dev_config(sdev
, dev
);
1114 EXPORT_SYMBOL_GPL(ata_scsi_slave_config
);
1117 * ata_scsi_slave_destroy - SCSI device is about to be destroyed
1118 * @sdev: SCSI device to be destroyed
1120 * @sdev is about to be destroyed for hot/warm unplugging. If
1121 * this unplugging was initiated by libata as indicated by NULL
1122 * dev->sdev, this function doesn't have to do anything.
1123 * Otherwise, SCSI layer initiated warm-unplug is in progress.
1124 * Clear dev->sdev, schedule the device for ATA detach and invoke
1128 * Defined by SCSI layer. We don't really care.
1130 void ata_scsi_slave_destroy(struct scsi_device
*sdev
)
1132 struct ata_port
*ap
= ata_shost_to_port(sdev
->host
);
1133 unsigned long flags
;
1134 struct ata_device
*dev
;
1136 if (!ap
->ops
->error_handler
)
1139 spin_lock_irqsave(ap
->lock
, flags
);
1140 dev
= __ata_scsi_find_dev(ap
, sdev
);
1141 if (dev
&& dev
->sdev
) {
1142 /* SCSI device already in CANCEL state, no need to offline it */
1144 dev
->flags
|= ATA_DFLAG_DETACH
;
1145 ata_port_schedule_eh(ap
);
1147 spin_unlock_irqrestore(ap
->lock
, flags
);
1149 kfree(sdev
->dma_drain_buf
);
1151 EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy
);
1154 * ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
1155 * @qc: Storage for translated ATA taskfile
1157 * Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
1158 * (to start). Perhaps these commands should be preceded by
1159 * CHECK POWER MODE to see what power mode the device is already in.
1160 * [See SAT revision 5 at www.t10.org]
1163 * spin_lock_irqsave(host lock)
1166 * Zero on success, non-zero on error.
1168 static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd
*qc
)
1170 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
1171 struct ata_taskfile
*tf
= &qc
->tf
;
1172 const u8
*cdb
= scmd
->cmnd
;
1176 if (scmd
->cmd_len
< 5) {
1181 tf
->flags
|= ATA_TFLAG_DEVICE
| ATA_TFLAG_ISADDR
;
1182 tf
->protocol
= ATA_PROT_NODATA
;
1184 ; /* ignore IMMED bit, violates sat-r05 */
1189 goto invalid_fld
; /* LOEJ bit set not supported */
1191 if (((cdb
[4] >> 4) & 0xf) != 0) {
1194 goto invalid_fld
; /* power conditions not supported */
1198 tf
->nsect
= 1; /* 1 sector, lba=0 */
1200 if (qc
->dev
->flags
& ATA_DFLAG_LBA
) {
1201 tf
->flags
|= ATA_TFLAG_LBA
;
1206 tf
->device
|= ATA_LBA
;
1209 tf
->lbal
= 0x1; /* sect */
1210 tf
->lbam
= 0x0; /* cyl low */
1211 tf
->lbah
= 0x0; /* cyl high */
1214 tf
->command
= ATA_CMD_VERIFY
; /* READ VERIFY */
1216 /* Some odd clown BIOSen issue spindown on power off (ACPI S4
1217 * or S5) causing some drives to spin up and down again.
1219 if ((qc
->ap
->flags
& ATA_FLAG_NO_POWEROFF_SPINDOWN
) &&
1220 system_state
== SYSTEM_POWER_OFF
)
1223 if ((qc
->ap
->flags
& ATA_FLAG_NO_HIBERNATE_SPINDOWN
) &&
1224 system_entering_hibernation())
1227 /* Issue ATA STANDBY IMMEDIATE command */
1228 tf
->command
= ATA_CMD_STANDBYNOW1
;
1232 * Standby and Idle condition timers could be implemented but that
1233 * would require libata to implement the Power condition mode page
1234 * and allow the user to change it. Changing mode pages requires
1235 * MODE SELECT to be implemented.
1241 ata_scsi_set_invalid_field(qc
->dev
, scmd
, fp
, bp
);
1244 scmd
->result
= SAM_STAT_GOOD
;
1250 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
1251 * @qc: Storage for translated ATA taskfile
1253 * Sets up an ATA taskfile to issue FLUSH CACHE or
1257 * spin_lock_irqsave(host lock)
1260 * Zero on success, non-zero on error.
1262 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd
*qc
)
1264 struct ata_taskfile
*tf
= &qc
->tf
;
1266 tf
->flags
|= ATA_TFLAG_DEVICE
;
1267 tf
->protocol
= ATA_PROT_NODATA
;
1269 if (qc
->dev
->flags
& ATA_DFLAG_FLUSH_EXT
)
1270 tf
->command
= ATA_CMD_FLUSH_EXT
;
1272 tf
->command
= ATA_CMD_FLUSH
;
1274 /* flush is critical for IO integrity, consider it an IO command */
1275 qc
->flags
|= ATA_QCFLAG_IO
;
1281 * scsi_6_lba_len - Get LBA and transfer length
1282 * @cdb: SCSI command to translate
1284 * Calculate LBA and transfer length for 6-byte commands.
1288 * @plen: the transfer length
1290 static void scsi_6_lba_len(const u8
*cdb
, u64
*plba
, u32
*plen
)
1295 VPRINTK("six-byte command\n");
1297 lba
|= ((u64
)(cdb
[1] & 0x1f)) << 16;
1298 lba
|= ((u64
)cdb
[2]) << 8;
1299 lba
|= ((u64
)cdb
[3]);
1308 * scsi_10_lba_len - Get LBA and transfer length
1309 * @cdb: SCSI command to translate
1311 * Calculate LBA and transfer length for 10-byte commands.
1315 * @plen: the transfer length
1317 static void scsi_10_lba_len(const u8
*cdb
, u64
*plba
, u32
*plen
)
1322 VPRINTK("ten-byte command\n");
1324 lba
|= ((u64
)cdb
[2]) << 24;
1325 lba
|= ((u64
)cdb
[3]) << 16;
1326 lba
|= ((u64
)cdb
[4]) << 8;
1327 lba
|= ((u64
)cdb
[5]);
1329 len
|= ((u32
)cdb
[7]) << 8;
1330 len
|= ((u32
)cdb
[8]);
1337 * scsi_16_lba_len - Get LBA and transfer length
1338 * @cdb: SCSI command to translate
1340 * Calculate LBA and transfer length for 16-byte commands.
1344 * @plen: the transfer length
1346 static void scsi_16_lba_len(const u8
*cdb
, u64
*plba
, u32
*plen
)
1351 VPRINTK("sixteen-byte command\n");
1353 lba
|= ((u64
)cdb
[2]) << 56;
1354 lba
|= ((u64
)cdb
[3]) << 48;
1355 lba
|= ((u64
)cdb
[4]) << 40;
1356 lba
|= ((u64
)cdb
[5]) << 32;
1357 lba
|= ((u64
)cdb
[6]) << 24;
1358 lba
|= ((u64
)cdb
[7]) << 16;
1359 lba
|= ((u64
)cdb
[8]) << 8;
1360 lba
|= ((u64
)cdb
[9]);
1362 len
|= ((u32
)cdb
[10]) << 24;
1363 len
|= ((u32
)cdb
[11]) << 16;
1364 len
|= ((u32
)cdb
[12]) << 8;
1365 len
|= ((u32
)cdb
[13]);
1372 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
1373 * @qc: Storage for translated ATA taskfile
1375 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
1378 * spin_lock_irqsave(host lock)
1381 * Zero on success, non-zero on error.
1383 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd
*qc
)
1385 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
1386 struct ata_taskfile
*tf
= &qc
->tf
;
1387 struct ata_device
*dev
= qc
->dev
;
1388 u64 dev_sectors
= qc
->dev
->n_sectors
;
1389 const u8
*cdb
= scmd
->cmnd
;
1394 tf
->flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
;
1395 tf
->protocol
= ATA_PROT_NODATA
;
1397 if (cdb
[0] == VERIFY
) {
1398 if (scmd
->cmd_len
< 10) {
1402 scsi_10_lba_len(cdb
, &block
, &n_block
);
1403 } else if (cdb
[0] == VERIFY_16
) {
1404 if (scmd
->cmd_len
< 16) {
1408 scsi_16_lba_len(cdb
, &block
, &n_block
);
1416 if (block
>= dev_sectors
)
1418 if ((block
+ n_block
) > dev_sectors
)
1421 if (dev
->flags
& ATA_DFLAG_LBA
) {
1422 tf
->flags
|= ATA_TFLAG_LBA
;
1424 if (lba_28_ok(block
, n_block
)) {
1426 tf
->command
= ATA_CMD_VERIFY
;
1427 tf
->device
|= (block
>> 24) & 0xf;
1428 } else if (lba_48_ok(block
, n_block
)) {
1429 if (!(dev
->flags
& ATA_DFLAG_LBA48
))
1433 tf
->flags
|= ATA_TFLAG_LBA48
;
1434 tf
->command
= ATA_CMD_VERIFY_EXT
;
1436 tf
->hob_nsect
= (n_block
>> 8) & 0xff;
1438 tf
->hob_lbah
= (block
>> 40) & 0xff;
1439 tf
->hob_lbam
= (block
>> 32) & 0xff;
1440 tf
->hob_lbal
= (block
>> 24) & 0xff;
1442 /* request too large even for LBA48 */
1445 tf
->nsect
= n_block
& 0xff;
1447 tf
->lbah
= (block
>> 16) & 0xff;
1448 tf
->lbam
= (block
>> 8) & 0xff;
1449 tf
->lbal
= block
& 0xff;
1451 tf
->device
|= ATA_LBA
;
1454 u32 sect
, head
, cyl
, track
;
1456 if (!lba_28_ok(block
, n_block
))
1459 /* Convert LBA to CHS */
1460 track
= (u32
)block
/ dev
->sectors
;
1461 cyl
= track
/ dev
->heads
;
1462 head
= track
% dev
->heads
;
1463 sect
= (u32
)block
% dev
->sectors
+ 1;
1465 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1466 (u32
)block
, track
, cyl
, head
, sect
);
1468 /* Check whether the converted CHS can fit.
1472 if ((cyl
>> 16) || (head
>> 4) || (sect
>> 8) || (!sect
))
1475 tf
->command
= ATA_CMD_VERIFY
;
1476 tf
->nsect
= n_block
& 0xff; /* Sector count 0 means 256 sectors */
1479 tf
->lbah
= cyl
>> 8;
1486 ata_scsi_set_invalid_field(qc
->dev
, scmd
, fp
, 0xff);
1490 ata_scsi_set_sense(qc
->dev
, scmd
, ILLEGAL_REQUEST
, 0x21, 0x0);
1491 /* "Logical Block Address out of range" */
1495 scmd
->result
= SAM_STAT_GOOD
;
1499 static bool ata_check_nblocks(struct scsi_cmnd
*scmd
, u32 n_blocks
)
1501 struct request
*rq
= scmd
->request
;
1504 if (!blk_rq_is_passthrough(rq
))
1507 req_blocks
= blk_rq_bytes(rq
) / scmd
->device
->sector_size
;
1508 if (n_blocks
> req_blocks
)
1515 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
1516 * @qc: Storage for translated ATA taskfile
1518 * Converts any of six SCSI read/write commands into the
1519 * ATA counterpart, including starting sector (LBA),
1520 * sector count, and taking into account the device's LBA48
1523 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
1524 * %WRITE_16 are currently supported.
1527 * spin_lock_irqsave(host lock)
1530 * Zero on success, non-zero on error.
1532 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd
*qc
)
1534 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
1535 const u8
*cdb
= scmd
->cmnd
;
1536 struct request
*rq
= scmd
->request
;
1537 int class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq
));
1538 unsigned int tf_flags
= 0;
1544 if (cdb
[0] == WRITE_10
|| cdb
[0] == WRITE_6
|| cdb
[0] == WRITE_16
)
1545 tf_flags
|= ATA_TFLAG_WRITE
;
1547 /* Calculate the SCSI LBA, transfer length and FUA. */
1551 if (unlikely(scmd
->cmd_len
< 10)) {
1555 scsi_10_lba_len(cdb
, &block
, &n_block
);
1556 if (cdb
[1] & (1 << 3))
1557 tf_flags
|= ATA_TFLAG_FUA
;
1558 if (!ata_check_nblocks(scmd
, n_block
))
1563 if (unlikely(scmd
->cmd_len
< 6)) {
1567 scsi_6_lba_len(cdb
, &block
, &n_block
);
1569 /* for 6-byte r/w commands, transfer length 0
1570 * means 256 blocks of data, not 0 block.
1574 if (!ata_check_nblocks(scmd
, n_block
))
1579 if (unlikely(scmd
->cmd_len
< 16)) {
1583 scsi_16_lba_len(cdb
, &block
, &n_block
);
1584 if (cdb
[1] & (1 << 3))
1585 tf_flags
|= ATA_TFLAG_FUA
;
1586 if (!ata_check_nblocks(scmd
, n_block
))
1590 DPRINTK("no-byte command\n");
1595 /* Check and compose ATA command */
1597 /* For 10-byte and 16-byte SCSI R/W commands, transfer
1598 * length 0 means transfer 0 block of data.
1599 * However, for ATA R/W commands, sector count 0 means
1600 * 256 or 65536 sectors, not 0 sectors as in SCSI.
1602 * WARNING: one or two older ATA drives treat 0 as 0...
1606 qc
->flags
|= ATA_QCFLAG_IO
;
1607 qc
->nbytes
= n_block
* scmd
->device
->sector_size
;
1609 rc
= ata_build_rw_tf(&qc
->tf
, qc
->dev
, block
, n_block
, tf_flags
,
1612 if (likely(rc
== 0))
1617 /* treat all other errors as -EINVAL, fall through */
1619 ata_scsi_set_invalid_field(qc
->dev
, scmd
, fp
, 0xff);
1623 ata_scsi_set_sense(qc
->dev
, scmd
, ILLEGAL_REQUEST
, 0x21, 0x0);
1624 /* "Logical Block Address out of range" */
1628 scmd
->result
= SAM_STAT_GOOD
;
1632 static void ata_qc_done(struct ata_queued_cmd
*qc
)
1634 struct scsi_cmnd
*cmd
= qc
->scsicmd
;
1635 void (*done
)(struct scsi_cmnd
*) = qc
->scsidone
;
1641 static void ata_scsi_qc_complete(struct ata_queued_cmd
*qc
)
1643 struct ata_port
*ap
= qc
->ap
;
1644 struct scsi_cmnd
*cmd
= qc
->scsicmd
;
1645 u8
*cdb
= cmd
->cmnd
;
1646 int need_sense
= (qc
->err_mask
!= 0);
1648 /* For ATA pass thru (SAT) commands, generate a sense block if
1649 * user mandated it or if there's an error. Note that if we
1650 * generate because the user forced us to [CK_COND =1], a check
1651 * condition is generated and the ATA register values are returned
1652 * whether the command completed successfully or not. If there
1653 * was no error, we use the following sense data:
1654 * sk = RECOVERED ERROR
1655 * asc,ascq = ATA PASS-THROUGH INFORMATION AVAILABLE
1657 if (((cdb
[0] == ATA_16
) || (cdb
[0] == ATA_12
)) &&
1658 ((cdb
[2] & 0x20) || need_sense
))
1659 ata_gen_passthru_sense(qc
);
1660 else if (qc
->flags
& ATA_QCFLAG_SENSE_VALID
)
1661 cmd
->result
= SAM_STAT_CHECK_CONDITION
;
1662 else if (need_sense
)
1663 ata_gen_ata_sense(qc
);
1665 cmd
->result
= SAM_STAT_GOOD
;
1667 if (need_sense
&& !ap
->ops
->error_handler
)
1668 ata_dump_status(ap
->print_id
, &qc
->result_tf
);
1674 * ata_scsi_translate - Translate then issue SCSI command to ATA device
1675 * @dev: ATA device to which the command is addressed
1676 * @cmd: SCSI command to execute
1677 * @xlat_func: Actor which translates @cmd to an ATA taskfile
1679 * Our ->queuecommand() function has decided that the SCSI
1680 * command issued can be directly translated into an ATA
1681 * command, rather than handled internally.
1683 * This function sets up an ata_queued_cmd structure for the
1684 * SCSI command, and sends that ata_queued_cmd to the hardware.
1686 * The xlat_func argument (actor) returns 0 if ready to execute
1687 * ATA command, else 1 to finish translation. If 1 is returned
1688 * then cmd->result (and possibly cmd->sense_buffer) are assumed
1689 * to be set reflecting an error condition or clean (early)
1693 * spin_lock_irqsave(host lock)
1696 * 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
1697 * needs to be deferred.
1699 static int ata_scsi_translate(struct ata_device
*dev
, struct scsi_cmnd
*cmd
,
1700 ata_xlat_func_t xlat_func
)
1702 struct ata_port
*ap
= dev
->link
->ap
;
1703 struct ata_queued_cmd
*qc
;
1708 qc
= ata_scsi_qc_new(dev
, cmd
);
1712 /* data is present; dma-map it */
1713 if (cmd
->sc_data_direction
== DMA_FROM_DEVICE
||
1714 cmd
->sc_data_direction
== DMA_TO_DEVICE
) {
1715 if (unlikely(scsi_bufflen(cmd
) < 1)) {
1716 ata_dev_warn(dev
, "WARNING: zero len r/w req\n");
1720 ata_sg_init(qc
, scsi_sglist(cmd
), scsi_sg_count(cmd
));
1722 qc
->dma_dir
= cmd
->sc_data_direction
;
1725 qc
->complete_fn
= ata_scsi_qc_complete
;
1730 if (ap
->ops
->qc_defer
) {
1731 if ((rc
= ap
->ops
->qc_defer(qc
)))
1735 /* select device, send command to hardware */
1743 cmd
->scsi_done(cmd
);
1744 DPRINTK("EXIT - early finish (good or error)\n");
1749 cmd
->result
= (DID_ERROR
<< 16);
1750 cmd
->scsi_done(cmd
);
1752 DPRINTK("EXIT - internal\n");
1757 DPRINTK("EXIT - defer\n");
1758 if (rc
== ATA_DEFER_LINK
)
1759 return SCSI_MLQUEUE_DEVICE_BUSY
;
1761 return SCSI_MLQUEUE_HOST_BUSY
;
1764 struct ata_scsi_args
{
1765 struct ata_device
*dev
;
1767 struct scsi_cmnd
*cmd
;
1771 * ata_scsi_rbuf_get - Map response buffer.
1772 * @cmd: SCSI command containing buffer to be mapped.
1773 * @flags: unsigned long variable to store irq enable status
1774 * @copy_in: copy in from user buffer
1776 * Prepare buffer for simulated SCSI commands.
1779 * spin_lock_irqsave(ata_scsi_rbuf_lock) on success
1782 * Pointer to response buffer.
1784 static void *ata_scsi_rbuf_get(struct scsi_cmnd
*cmd
, bool copy_in
,
1785 unsigned long *flags
)
1787 spin_lock_irqsave(&ata_scsi_rbuf_lock
, *flags
);
1789 memset(ata_scsi_rbuf
, 0, ATA_SCSI_RBUF_SIZE
);
1791 sg_copy_to_buffer(scsi_sglist(cmd
), scsi_sg_count(cmd
),
1792 ata_scsi_rbuf
, ATA_SCSI_RBUF_SIZE
);
1793 return ata_scsi_rbuf
;
1797 * ata_scsi_rbuf_put - Unmap response buffer.
1798 * @cmd: SCSI command containing buffer to be unmapped.
1799 * @copy_out: copy out result
1800 * @flags: @flags passed to ata_scsi_rbuf_get()
1802 * Returns rbuf buffer. The result is copied to @cmd's buffer if
1803 * @copy_back is true.
1806 * Unlocks ata_scsi_rbuf_lock.
1808 static inline void ata_scsi_rbuf_put(struct scsi_cmnd
*cmd
, bool copy_out
,
1809 unsigned long *flags
)
1812 sg_copy_from_buffer(scsi_sglist(cmd
), scsi_sg_count(cmd
),
1813 ata_scsi_rbuf
, ATA_SCSI_RBUF_SIZE
);
1814 spin_unlock_irqrestore(&ata_scsi_rbuf_lock
, *flags
);
1818 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1819 * @args: device IDENTIFY data / SCSI command of interest.
1820 * @actor: Callback hook for desired SCSI command simulator
1822 * Takes care of the hard work of simulating a SCSI command...
1823 * Mapping the response buffer, calling the command's handler,
1824 * and handling the handler's return value. This return value
1825 * indicates whether the handler wishes the SCSI command to be
1826 * completed successfully (0), or not (in which case cmd->result
1827 * and sense buffer are assumed to be set).
1830 * spin_lock_irqsave(host lock)
1832 static void ata_scsi_rbuf_fill(struct ata_scsi_args
*args
,
1833 unsigned int (*actor
)(struct ata_scsi_args
*args
, u8
*rbuf
))
1837 struct scsi_cmnd
*cmd
= args
->cmd
;
1838 unsigned long flags
;
1840 rbuf
= ata_scsi_rbuf_get(cmd
, false, &flags
);
1841 rc
= actor(args
, rbuf
);
1842 ata_scsi_rbuf_put(cmd
, rc
== 0, &flags
);
1845 cmd
->result
= SAM_STAT_GOOD
;
1849 * ata_scsiop_inq_std - Simulate INQUIRY command
1850 * @args: device IDENTIFY data / SCSI command of interest.
1851 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1853 * Returns standard device identification data associated
1854 * with non-VPD INQUIRY command output.
1857 * spin_lock_irqsave(host lock)
1859 static unsigned int ata_scsiop_inq_std(struct ata_scsi_args
*args
, u8
*rbuf
)
1861 static const u8 versions
[] = {
1863 0x60, /* SAM-3 (no version claimed) */
1866 0x20, /* SBC-2 (no version claimed) */
1869 0x00 /* SPC-3 (no version claimed) */
1871 static const u8 versions_zbc
[] = {
1873 0xA0, /* SAM-5 (no version claimed) */
1876 0x00, /* SBC-4 (no version claimed) */
1879 0xC0, /* SPC-5 (no version claimed) */
1888 0x5, /* claim SPC-3 version compatibility */
1898 /* set scsi removable (RMB) bit per ata bit, or if the
1899 * AHCI port says it's external (Hotplug-capable, eSATA).
1901 if (ata_id_removable(args
->id
) ||
1902 (args
->dev
->link
->ap
->pflags
& ATA_PFLAG_EXTERNAL
))
1905 if (args
->dev
->class == ATA_DEV_ZAC
) {
1907 hdr
[2] = 0x7; /* claim SPC-5 version compatibility */
1910 memcpy(rbuf
, hdr
, sizeof(hdr
));
1911 memcpy(&rbuf
[8], "ATA ", 8);
1912 ata_id_string(args
->id
, &rbuf
[16], ATA_ID_PROD
, 16);
1914 /* From SAT, use last 2 words from fw rev unless they are spaces */
1915 ata_id_string(args
->id
, &rbuf
[32], ATA_ID_FW_REV
+ 2, 4);
1916 if (strncmp(&rbuf
[32], " ", 4) == 0)
1917 ata_id_string(args
->id
, &rbuf
[32], ATA_ID_FW_REV
, 4);
1919 if (rbuf
[32] == 0 || rbuf
[32] == ' ')
1920 memcpy(&rbuf
[32], "n/a ", 4);
1922 if (ata_id_zoned_cap(args
->id
) || args
->dev
->class == ATA_DEV_ZAC
)
1923 memcpy(rbuf
+ 58, versions_zbc
, sizeof(versions_zbc
));
1925 memcpy(rbuf
+ 58, versions
, sizeof(versions
));
1931 * ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
1932 * @args: device IDENTIFY data / SCSI command of interest.
1933 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1935 * Returns list of inquiry VPD pages available.
1938 * spin_lock_irqsave(host lock)
1940 static unsigned int ata_scsiop_inq_00(struct ata_scsi_args
*args
, u8
*rbuf
)
1943 static const u8 pages
[] = {
1944 0x00, /* page 0x00, this page */
1945 0x80, /* page 0x80, unit serial no page */
1946 0x83, /* page 0x83, device ident page */
1947 0x89, /* page 0x89, ata info page */
1948 0xb0, /* page 0xb0, block limits page */
1949 0xb1, /* page 0xb1, block device characteristics page */
1950 0xb2, /* page 0xb2, thin provisioning page */
1951 0xb6, /* page 0xb6, zoned block device characteristics */
1954 num_pages
= sizeof(pages
);
1955 if (!(args
->dev
->flags
& ATA_DFLAG_ZAC
))
1957 rbuf
[3] = num_pages
; /* number of supported VPD pages */
1958 memcpy(rbuf
+ 4, pages
, num_pages
);
1963 * ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
1964 * @args: device IDENTIFY data / SCSI command of interest.
1965 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1967 * Returns ATA device serial number.
1970 * spin_lock_irqsave(host lock)
1972 static unsigned int ata_scsiop_inq_80(struct ata_scsi_args
*args
, u8
*rbuf
)
1974 static const u8 hdr
[] = {
1976 0x80, /* this page code */
1978 ATA_ID_SERNO_LEN
, /* page len */
1981 memcpy(rbuf
, hdr
, sizeof(hdr
));
1982 ata_id_string(args
->id
, (unsigned char *) &rbuf
[4],
1983 ATA_ID_SERNO
, ATA_ID_SERNO_LEN
);
1988 * ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
1989 * @args: device IDENTIFY data / SCSI command of interest.
1990 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1992 * Yields two logical unit device identification designators:
1993 * - vendor specific ASCII containing the ATA serial number
1994 * - SAT defined "t10 vendor id based" containing ASCII vendor
1995 * name ("ATA "), model and serial numbers.
1998 * spin_lock_irqsave(host lock)
2000 static unsigned int ata_scsiop_inq_83(struct ata_scsi_args
*args
, u8
*rbuf
)
2002 const int sat_model_serial_desc_len
= 68;
2005 rbuf
[1] = 0x83; /* this page code */
2008 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
2010 rbuf
[num
+ 3] = ATA_ID_SERNO_LEN
;
2012 ata_id_string(args
->id
, (unsigned char *) rbuf
+ num
,
2013 ATA_ID_SERNO
, ATA_ID_SERNO_LEN
);
2014 num
+= ATA_ID_SERNO_LEN
;
2016 /* SAT defined lu model and serial numbers descriptor */
2017 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
2020 rbuf
[num
+ 3] = sat_model_serial_desc_len
;
2022 memcpy(rbuf
+ num
, "ATA ", 8);
2024 ata_id_string(args
->id
, (unsigned char *) rbuf
+ num
, ATA_ID_PROD
,
2026 num
+= ATA_ID_PROD_LEN
;
2027 ata_id_string(args
->id
, (unsigned char *) rbuf
+ num
, ATA_ID_SERNO
,
2029 num
+= ATA_ID_SERNO_LEN
;
2031 if (ata_id_has_wwn(args
->id
)) {
2032 /* SAT defined lu world wide name */
2033 /* piv=0, assoc=lu, code_set=binary, designator=NAA */
2036 rbuf
[num
+ 3] = ATA_ID_WWN_LEN
;
2038 ata_id_string(args
->id
, (unsigned char *) rbuf
+ num
,
2039 ATA_ID_WWN
, ATA_ID_WWN_LEN
);
2040 num
+= ATA_ID_WWN_LEN
;
2042 rbuf
[3] = num
- 4; /* page len (assume less than 256 bytes) */
2047 * ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
2048 * @args: device IDENTIFY data / SCSI command of interest.
2049 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2051 * Yields SAT-specified ATA VPD page.
2054 * spin_lock_irqsave(host lock)
2056 static unsigned int ata_scsiop_inq_89(struct ata_scsi_args
*args
, u8
*rbuf
)
2058 rbuf
[1] = 0x89; /* our page code */
2059 rbuf
[2] = (0x238 >> 8); /* page size fixed at 238h */
2060 rbuf
[3] = (0x238 & 0xff);
2062 memcpy(&rbuf
[8], "linux ", 8);
2063 memcpy(&rbuf
[16], "libata ", 16);
2064 memcpy(&rbuf
[32], DRV_VERSION
, 4);
2066 rbuf
[36] = 0x34; /* force D2H Reg FIS (34h) */
2067 rbuf
[37] = (1 << 7); /* bit 7 indicates Command FIS */
2070 /* we don't store the ATA device signature, so we fake it */
2071 rbuf
[38] = ATA_DRDY
; /* really, this is Status reg */
2075 rbuf
[56] = ATA_CMD_ID_ATA
;
2077 memcpy(&rbuf
[60], &args
->id
[0], 512);
2081 static unsigned int ata_scsiop_inq_b0(struct ata_scsi_args
*args
, u8
*rbuf
)
2083 struct ata_device
*dev
= args
->dev
;
2087 rbuf
[3] = 0x3c; /* required VPD size with unmap support */
2090 * Optimal transfer length granularity.
2092 * This is always one physical block, but for disks with a smaller
2093 * logical than physical sector size we need to figure out what the
2096 min_io_sectors
= 1 << ata_id_log2_per_physical_sector(args
->id
);
2097 put_unaligned_be16(min_io_sectors
, &rbuf
[6]);
2100 * Optimal unmap granularity.
2102 * The ATA spec doesn't even know about a granularity or alignment
2103 * for the TRIM command. We can leave away most of the unmap related
2104 * VPD page entries, but we have specifify a granularity to signal
2105 * that we support some form of unmap - in thise case via WRITE SAME
2106 * with the unmap bit set.
2108 if (ata_id_has_trim(args
->id
)) {
2109 u64 max_blocks
= 65535 * ATA_MAX_TRIM_RNUM
;
2111 if (dev
->horkage
& ATA_HORKAGE_MAX_TRIM_128M
)
2112 max_blocks
= 128 << (20 - SECTOR_SHIFT
);
2114 put_unaligned_be64(max_blocks
, &rbuf
[36]);
2115 put_unaligned_be32(1, &rbuf
[28]);
2121 static unsigned int ata_scsiop_inq_b1(struct ata_scsi_args
*args
, u8
*rbuf
)
2123 int form_factor
= ata_id_form_factor(args
->id
);
2124 int media_rotation_rate
= ata_id_rotation_rate(args
->id
);
2125 u8 zoned
= ata_id_zoned_cap(args
->id
);
2129 rbuf
[4] = media_rotation_rate
>> 8;
2130 rbuf
[5] = media_rotation_rate
;
2131 rbuf
[7] = form_factor
;
2133 rbuf
[8] = (zoned
<< 4);
2138 static unsigned int ata_scsiop_inq_b2(struct ata_scsi_args
*args
, u8
*rbuf
)
2140 /* SCSI Thin Provisioning VPD page: SBC-3 rev 22 or later */
2143 rbuf
[5] = 1 << 6; /* TPWS */
2148 static unsigned int ata_scsiop_inq_b6(struct ata_scsi_args
*args
, u8
*rbuf
)
2151 * zbc-r05 SCSI Zoned Block device characteristics VPD page
2157 * URSWRZ bit is only meaningful for host-managed ZAC drives
2159 if (args
->dev
->zac_zoned_cap
& 1)
2161 put_unaligned_be32(args
->dev
->zac_zones_optimal_open
, &rbuf
[8]);
2162 put_unaligned_be32(args
->dev
->zac_zones_optimal_nonseq
, &rbuf
[12]);
2163 put_unaligned_be32(args
->dev
->zac_zones_max_open
, &rbuf
[16]);
2169 * modecpy - Prepare response for MODE SENSE
2170 * @dest: output buffer
2171 * @src: data being copied
2172 * @n: length of mode page
2173 * @changeable: whether changeable parameters are requested
2175 * Generate a generic MODE SENSE page for either current or changeable
2181 static void modecpy(u8
*dest
, const u8
*src
, int n
, bool changeable
)
2184 memcpy(dest
, src
, 2);
2185 memset(dest
+ 2, 0, n
- 2);
2187 memcpy(dest
, src
, n
);
2192 * ata_msense_caching - Simulate MODE SENSE caching info page
2193 * @id: device IDENTIFY data
2194 * @buf: output buffer
2195 * @changeable: whether changeable parameters are requested
2197 * Generate a caching info page, which conditionally indicates
2198 * write caching to the SCSI layer, depending on device
2204 static unsigned int ata_msense_caching(u16
*id
, u8
*buf
, bool changeable
)
2206 modecpy(buf
, def_cache_mpage
, sizeof(def_cache_mpage
), changeable
);
2208 buf
[2] |= (1 << 2); /* ata_mselect_caching() */
2210 buf
[2] |= (ata_id_wcache_enabled(id
) << 2); /* write cache enable */
2211 buf
[12] |= (!ata_id_rahead_enabled(id
) << 5); /* disable read ahead */
2213 return sizeof(def_cache_mpage
);
2217 * ata_msense_control - Simulate MODE SENSE control mode page
2218 * @dev: ATA device of interest
2219 * @buf: output buffer
2220 * @changeable: whether changeable parameters are requested
2222 * Generate a generic MODE SENSE control mode page.
2227 static unsigned int ata_msense_control(struct ata_device
*dev
, u8
*buf
,
2230 modecpy(buf
, def_control_mpage
, sizeof(def_control_mpage
), changeable
);
2232 buf
[2] |= (1 << 2); /* ata_mselect_control() */
2234 bool d_sense
= (dev
->flags
& ATA_DFLAG_D_SENSE
);
2236 buf
[2] |= (d_sense
<< 2); /* descriptor format sense data */
2238 return sizeof(def_control_mpage
);
2242 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
2243 * @buf: output buffer
2244 * @changeable: whether changeable parameters are requested
2246 * Generate a generic MODE SENSE r/w error recovery page.
2251 static unsigned int ata_msense_rw_recovery(u8
*buf
, bool changeable
)
2253 modecpy(buf
, def_rw_recovery_mpage
, sizeof(def_rw_recovery_mpage
),
2255 return sizeof(def_rw_recovery_mpage
);
2259 * We can turn this into a real blacklist if it's needed, for now just
2260 * blacklist any Maxtor BANC1G10 revision firmware
2262 static int ata_dev_supports_fua(u16
*id
)
2264 unsigned char model
[ATA_ID_PROD_LEN
+ 1], fw
[ATA_ID_FW_REV_LEN
+ 1];
2268 if (!ata_id_has_fua(id
))
2271 ata_id_c_string(id
, model
, ATA_ID_PROD
, sizeof(model
));
2272 ata_id_c_string(id
, fw
, ATA_ID_FW_REV
, sizeof(fw
));
2274 if (strcmp(model
, "Maxtor"))
2276 if (strcmp(fw
, "BANC1G10"))
2279 return 0; /* blacklisted */
2283 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
2284 * @args: device IDENTIFY data / SCSI command of interest.
2285 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2287 * Simulate MODE SENSE commands. Assume this is invoked for direct
2288 * access devices (e.g. disks) only. There should be no block
2289 * descriptor for other device types.
2292 * spin_lock_irqsave(host lock)
2294 static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args
*args
, u8
*rbuf
)
2296 struct ata_device
*dev
= args
->dev
;
2297 u8
*scsicmd
= args
->cmd
->cmnd
, *p
= rbuf
;
2298 static const u8 sat_blk_desc
[] = {
2299 0, 0, 0, 0, /* number of blocks: sat unspecified */
2301 0, 0x2, 0x0 /* block length: 512 bytes */
2304 unsigned int ebd
, page_control
, six_byte
;
2305 u8 dpofua
, bp
= 0xff;
2310 six_byte
= (scsicmd
[0] == MODE_SENSE
);
2311 ebd
= !(scsicmd
[1] & 0x8); /* dbd bit inverted == edb */
2313 * LLBA bit in msense(10) ignored (compliant)
2316 page_control
= scsicmd
[2] >> 6;
2317 switch (page_control
) {
2318 case 0: /* current */
2319 case 1: /* changeable */
2320 case 2: /* defaults */
2321 break; /* supported */
2323 goto saving_not_supp
;
2331 p
+= 4 + (ebd
? 8 : 0);
2333 p
+= 8 + (ebd
? 8 : 0);
2335 pg
= scsicmd
[2] & 0x3f;
2338 * No mode subpages supported (yet) but asking for _all_
2339 * subpages may be valid
2341 if (spg
&& (spg
!= ALL_SUB_MPAGES
)) {
2347 case RW_RECOVERY_MPAGE
:
2348 p
+= ata_msense_rw_recovery(p
, page_control
== 1);
2352 p
+= ata_msense_caching(args
->id
, p
, page_control
== 1);
2356 p
+= ata_msense_control(args
->dev
, p
, page_control
== 1);
2360 p
+= ata_msense_rw_recovery(p
, page_control
== 1);
2361 p
+= ata_msense_caching(args
->id
, p
, page_control
== 1);
2362 p
+= ata_msense_control(args
->dev
, p
, page_control
== 1);
2365 default: /* invalid page code */
2371 if (ata_dev_supports_fua(args
->id
) && (dev
->flags
& ATA_DFLAG_LBA48
) &&
2372 (!(dev
->flags
& ATA_DFLAG_PIO
) || dev
->multi_count
))
2376 rbuf
[0] = p
- rbuf
- 1;
2379 rbuf
[3] = sizeof(sat_blk_desc
);
2380 memcpy(rbuf
+ 4, sat_blk_desc
, sizeof(sat_blk_desc
));
2383 unsigned int output_len
= p
- rbuf
- 2;
2385 rbuf
[0] = output_len
>> 8;
2386 rbuf
[1] = output_len
;
2389 rbuf
[7] = sizeof(sat_blk_desc
);
2390 memcpy(rbuf
+ 8, sat_blk_desc
, sizeof(sat_blk_desc
));
2396 ata_scsi_set_invalid_field(dev
, args
->cmd
, fp
, bp
);
2400 ata_scsi_set_sense(dev
, args
->cmd
, ILLEGAL_REQUEST
, 0x39, 0x0);
2401 /* "Saving parameters not supported" */
2406 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
2407 * @args: device IDENTIFY data / SCSI command of interest.
2408 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2410 * Simulate READ CAPACITY commands.
2415 static unsigned int ata_scsiop_read_cap(struct ata_scsi_args
*args
, u8
*rbuf
)
2417 struct ata_device
*dev
= args
->dev
;
2418 u64 last_lba
= dev
->n_sectors
- 1; /* LBA of the last block */
2419 u32 sector_size
; /* physical sector size in bytes */
2423 sector_size
= ata_id_logical_sector_size(dev
->id
);
2424 log2_per_phys
= ata_id_log2_per_physical_sector(dev
->id
);
2425 lowest_aligned
= ata_id_logical_sector_offset(dev
->id
, log2_per_phys
);
2429 if (args
->cmd
->cmnd
[0] == READ_CAPACITY
) {
2430 if (last_lba
>= 0xffffffffULL
)
2431 last_lba
= 0xffffffff;
2433 /* sector count, 32-bit */
2434 rbuf
[0] = last_lba
>> (8 * 3);
2435 rbuf
[1] = last_lba
>> (8 * 2);
2436 rbuf
[2] = last_lba
>> (8 * 1);
2440 rbuf
[4] = sector_size
>> (8 * 3);
2441 rbuf
[5] = sector_size
>> (8 * 2);
2442 rbuf
[6] = sector_size
>> (8 * 1);
2443 rbuf
[7] = sector_size
;
2445 /* sector count, 64-bit */
2446 rbuf
[0] = last_lba
>> (8 * 7);
2447 rbuf
[1] = last_lba
>> (8 * 6);
2448 rbuf
[2] = last_lba
>> (8 * 5);
2449 rbuf
[3] = last_lba
>> (8 * 4);
2450 rbuf
[4] = last_lba
>> (8 * 3);
2451 rbuf
[5] = last_lba
>> (8 * 2);
2452 rbuf
[6] = last_lba
>> (8 * 1);
2456 rbuf
[ 8] = sector_size
>> (8 * 3);
2457 rbuf
[ 9] = sector_size
>> (8 * 2);
2458 rbuf
[10] = sector_size
>> (8 * 1);
2459 rbuf
[11] = sector_size
;
2462 rbuf
[13] = log2_per_phys
;
2463 rbuf
[14] = (lowest_aligned
>> 8) & 0x3f;
2464 rbuf
[15] = lowest_aligned
;
2466 if (ata_id_has_trim(args
->id
) &&
2467 !(dev
->horkage
& ATA_HORKAGE_NOTRIM
)) {
2468 rbuf
[14] |= 0x80; /* LBPME */
2470 if (ata_id_has_zero_after_trim(args
->id
) &&
2471 dev
->horkage
& ATA_HORKAGE_ZERO_AFTER_TRIM
) {
2472 ata_dev_info(dev
, "Enabling discard_zeroes_data\n");
2473 rbuf
[14] |= 0x40; /* LBPRZ */
2476 if (ata_id_zoned_cap(args
->id
) ||
2477 args
->dev
->class == ATA_DEV_ZAC
)
2478 rbuf
[12] = (1 << 4); /* RC_BASIS */
2484 * ata_scsiop_report_luns - Simulate REPORT LUNS command
2485 * @args: device IDENTIFY data / SCSI command of interest.
2486 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2488 * Simulate REPORT LUNS command.
2491 * spin_lock_irqsave(host lock)
2493 static unsigned int ata_scsiop_report_luns(struct ata_scsi_args
*args
, u8
*rbuf
)
2496 rbuf
[3] = 8; /* just one lun, LUN 0, size 8 bytes */
2501 static void atapi_sense_complete(struct ata_queued_cmd
*qc
)
2503 if (qc
->err_mask
&& ((qc
->err_mask
& AC_ERR_DEV
) == 0)) {
2504 /* FIXME: not quite right; we don't want the
2505 * translation of taskfile registers into
2506 * a sense descriptors, since that's only
2507 * correct for ATA, not ATAPI
2509 ata_gen_passthru_sense(qc
);
2515 /* is it pointless to prefer PIO for "safety reasons"? */
2516 static inline int ata_pio_use_silly(struct ata_port
*ap
)
2518 return (ap
->flags
& ATA_FLAG_PIO_DMA
);
2521 static void atapi_request_sense(struct ata_queued_cmd
*qc
)
2523 struct ata_port
*ap
= qc
->ap
;
2524 struct scsi_cmnd
*cmd
= qc
->scsicmd
;
2526 DPRINTK("ATAPI request sense\n");
2528 memset(cmd
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
2530 #ifdef CONFIG_ATA_SFF
2531 if (ap
->ops
->sff_tf_read
)
2532 ap
->ops
->sff_tf_read(ap
, &qc
->tf
);
2535 /* fill these in, for the case where they are -not- overwritten */
2536 cmd
->sense_buffer
[0] = 0x70;
2537 cmd
->sense_buffer
[2] = qc
->tf
.feature
>> 4;
2541 /* setup sg table and init transfer direction */
2542 sg_init_one(&qc
->sgent
, cmd
->sense_buffer
, SCSI_SENSE_BUFFERSIZE
);
2543 ata_sg_init(qc
, &qc
->sgent
, 1);
2544 qc
->dma_dir
= DMA_FROM_DEVICE
;
2546 memset(&qc
->cdb
, 0, qc
->dev
->cdb_len
);
2547 qc
->cdb
[0] = REQUEST_SENSE
;
2548 qc
->cdb
[4] = SCSI_SENSE_BUFFERSIZE
;
2550 qc
->tf
.flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
;
2551 qc
->tf
.command
= ATA_CMD_PACKET
;
2553 if (ata_pio_use_silly(ap
)) {
2554 qc
->tf
.protocol
= ATAPI_PROT_DMA
;
2555 qc
->tf
.feature
|= ATAPI_PKT_DMA
;
2557 qc
->tf
.protocol
= ATAPI_PROT_PIO
;
2558 qc
->tf
.lbam
= SCSI_SENSE_BUFFERSIZE
;
2561 qc
->nbytes
= SCSI_SENSE_BUFFERSIZE
;
2563 qc
->complete_fn
= atapi_sense_complete
;
2571 * ATAPI devices typically report zero for their SCSI version, and sometimes
2572 * deviate from the spec WRT response data format. If SCSI version is
2573 * reported as zero like normal, then we make the following fixups:
2574 * 1) Fake MMC-5 version, to indicate to the Linux scsi midlayer this is a
2576 * 2) Ensure response data format / ATAPI information are always correct.
2578 static void atapi_fixup_inquiry(struct scsi_cmnd
*cmd
)
2582 sg_copy_to_buffer(scsi_sglist(cmd
), scsi_sg_count(cmd
), buf
, 4);
2587 sg_copy_from_buffer(scsi_sglist(cmd
), scsi_sg_count(cmd
), buf
, 4);
2590 static void atapi_qc_complete(struct ata_queued_cmd
*qc
)
2592 struct scsi_cmnd
*cmd
= qc
->scsicmd
;
2593 unsigned int err_mask
= qc
->err_mask
;
2595 VPRINTK("ENTER, err_mask 0x%X\n", err_mask
);
2597 /* handle completion from new EH */
2598 if (unlikely(qc
->ap
->ops
->error_handler
&&
2599 (err_mask
|| qc
->flags
& ATA_QCFLAG_SENSE_VALID
))) {
2601 if (!(qc
->flags
& ATA_QCFLAG_SENSE_VALID
)) {
2602 /* FIXME: not quite right; we don't want the
2603 * translation of taskfile registers into a
2604 * sense descriptors, since that's only
2605 * correct for ATA, not ATAPI
2607 ata_gen_passthru_sense(qc
);
2610 /* SCSI EH automatically locks door if sdev->locked is
2611 * set. Sometimes door lock request continues to
2612 * fail, for example, when no media is present. This
2613 * creates a loop - SCSI EH issues door lock which
2614 * fails and gets invoked again to acquire sense data
2615 * for the failed command.
2617 * If door lock fails, always clear sdev->locked to
2618 * avoid this infinite loop.
2620 * This may happen before SCSI scan is complete. Make
2621 * sure qc->dev->sdev isn't NULL before dereferencing.
2623 if (qc
->cdb
[0] == ALLOW_MEDIUM_REMOVAL
&& qc
->dev
->sdev
)
2624 qc
->dev
->sdev
->locked
= 0;
2626 qc
->scsicmd
->result
= SAM_STAT_CHECK_CONDITION
;
2631 /* successful completion or old EH failure path */
2632 if (unlikely(err_mask
& AC_ERR_DEV
)) {
2633 cmd
->result
= SAM_STAT_CHECK_CONDITION
;
2634 atapi_request_sense(qc
);
2636 } else if (unlikely(err_mask
)) {
2637 /* FIXME: not quite right; we don't want the
2638 * translation of taskfile registers into
2639 * a sense descriptors, since that's only
2640 * correct for ATA, not ATAPI
2642 ata_gen_passthru_sense(qc
);
2644 if (cmd
->cmnd
[0] == INQUIRY
&& (cmd
->cmnd
[1] & 0x03) == 0)
2645 atapi_fixup_inquiry(cmd
);
2646 cmd
->result
= SAM_STAT_GOOD
;
2652 * atapi_xlat - Initialize PACKET taskfile
2653 * @qc: command structure to be initialized
2656 * spin_lock_irqsave(host lock)
2659 * Zero on success, non-zero on failure.
2661 static unsigned int atapi_xlat(struct ata_queued_cmd
*qc
)
2663 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
2664 struct ata_device
*dev
= qc
->dev
;
2665 int nodata
= (scmd
->sc_data_direction
== DMA_NONE
);
2666 int using_pio
= !nodata
&& (dev
->flags
& ATA_DFLAG_PIO
);
2667 unsigned int nbytes
;
2669 memset(qc
->cdb
, 0, dev
->cdb_len
);
2670 memcpy(qc
->cdb
, scmd
->cmnd
, scmd
->cmd_len
);
2672 qc
->complete_fn
= atapi_qc_complete
;
2674 qc
->tf
.flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
;
2675 if (scmd
->sc_data_direction
== DMA_TO_DEVICE
) {
2676 qc
->tf
.flags
|= ATA_TFLAG_WRITE
;
2677 DPRINTK("direction: write\n");
2680 qc
->tf
.command
= ATA_CMD_PACKET
;
2681 ata_qc_set_pc_nbytes(qc
);
2683 /* check whether ATAPI DMA is safe */
2684 if (!nodata
&& !using_pio
&& atapi_check_dma(qc
))
2687 /* Some controller variants snoop this value for Packet
2688 * transfers to do state machine and FIFO management. Thus we
2689 * want to set it properly, and for DMA where it is
2690 * effectively meaningless.
2692 nbytes
= min(ata_qc_raw_nbytes(qc
), (unsigned int)63 * 1024);
2694 /* Most ATAPI devices which honor transfer chunk size don't
2695 * behave according to the spec when odd chunk size which
2696 * matches the transfer length is specified. If the number of
2697 * bytes to transfer is 2n+1. According to the spec, what
2698 * should happen is to indicate that 2n+1 is going to be
2699 * transferred and transfer 2n+2 bytes where the last byte is
2702 * In practice, this doesn't happen. ATAPI devices first
2703 * indicate and transfer 2n bytes and then indicate and
2704 * transfer 2 bytes where the last byte is padding.
2706 * This inconsistency confuses several controllers which
2707 * perform PIO using DMA such as Intel AHCIs and sil3124/32.
2708 * These controllers use actual number of transferred bytes to
2709 * update DMA pointer and transfer of 4n+2 bytes make those
2710 * controller push DMA pointer by 4n+4 bytes because SATA data
2711 * FISes are aligned to 4 bytes. This causes data corruption
2712 * and buffer overrun.
2714 * Always setting nbytes to even number solves this problem
2715 * because then ATAPI devices don't have to split data at 2n
2721 qc
->tf
.lbam
= (nbytes
& 0xFF);
2722 qc
->tf
.lbah
= (nbytes
>> 8);
2725 qc
->tf
.protocol
= ATAPI_PROT_NODATA
;
2727 qc
->tf
.protocol
= ATAPI_PROT_PIO
;
2730 qc
->tf
.protocol
= ATAPI_PROT_DMA
;
2731 qc
->tf
.feature
|= ATAPI_PKT_DMA
;
2733 if ((dev
->flags
& ATA_DFLAG_DMADIR
) &&
2734 (scmd
->sc_data_direction
!= DMA_TO_DEVICE
))
2735 /* some SATA bridges need us to indicate data xfer direction */
2736 qc
->tf
.feature
|= ATAPI_DMADIR
;
2740 /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
2741 as ATAPI tape drives don't get this right otherwise */
2745 static struct ata_device
*ata_find_dev(struct ata_port
*ap
, int devno
)
2747 if (!sata_pmp_attached(ap
)) {
2748 if (likely(devno
>= 0 &&
2749 devno
< ata_link_max_devices(&ap
->link
)))
2750 return &ap
->link
.device
[devno
];
2752 if (likely(devno
>= 0 &&
2753 devno
< ap
->nr_pmp_links
))
2754 return &ap
->pmp_link
[devno
].device
[0];
2760 static struct ata_device
*__ata_scsi_find_dev(struct ata_port
*ap
,
2761 const struct scsi_device
*scsidev
)
2765 /* skip commands not addressed to targets we simulate */
2766 if (!sata_pmp_attached(ap
)) {
2767 if (unlikely(scsidev
->channel
|| scsidev
->lun
))
2769 devno
= scsidev
->id
;
2771 if (unlikely(scsidev
->id
|| scsidev
->lun
))
2773 devno
= scsidev
->channel
;
2776 return ata_find_dev(ap
, devno
);
2780 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
2781 * @ap: ATA port to which the device is attached
2782 * @scsidev: SCSI device from which we derive the ATA device
2784 * Given various information provided in struct scsi_cmnd,
2785 * map that onto an ATA bus, and using that mapping
2786 * determine which ata_device is associated with the
2787 * SCSI command to be sent.
2790 * spin_lock_irqsave(host lock)
2793 * Associated ATA device, or %NULL if not found.
2796 ata_scsi_find_dev(struct ata_port
*ap
, const struct scsi_device
*scsidev
)
2798 struct ata_device
*dev
= __ata_scsi_find_dev(ap
, scsidev
);
2800 if (unlikely(!dev
|| !ata_dev_enabled(dev
)))
2807 * ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
2808 * @byte1: Byte 1 from pass-thru CDB.
2811 * ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
2814 ata_scsi_map_proto(u8 byte1
)
2816 switch((byte1
& 0x1e) >> 1) {
2817 case 3: /* Non-data */
2818 return ATA_PROT_NODATA
;
2821 case 10: /* UDMA Data-in */
2822 case 11: /* UDMA Data-Out */
2823 return ATA_PROT_DMA
;
2825 case 4: /* PIO Data-in */
2826 case 5: /* PIO Data-out */
2827 return ATA_PROT_PIO
;
2829 case 12: /* FPDMA */
2830 return ATA_PROT_NCQ
;
2832 case 0: /* Hard Reset */
2834 case 8: /* Device Diagnostic */
2835 case 9: /* Device Reset */
2836 case 7: /* DMA Queued */
2837 case 15: /* Return Response Info */
2838 default: /* Reserved */
2842 return ATA_PROT_UNKNOWN
;
2846 * ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
2847 * @qc: command structure to be initialized
2849 * Handles either 12, 16, or 32-byte versions of the CDB.
2852 * Zero on success, non-zero on failure.
2854 static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd
*qc
)
2856 struct ata_taskfile
*tf
= &(qc
->tf
);
2857 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
2858 struct ata_device
*dev
= qc
->dev
;
2859 const u8
*cdb
= scmd
->cmnd
;
2863 /* 7Fh variable length cmd means a ata pass-thru(32) */
2864 if (cdb
[0] == VARIABLE_LENGTH_CMD
)
2867 tf
->protocol
= ata_scsi_map_proto(cdb
[1 + cdb_offset
]);
2868 if (tf
->protocol
== ATA_PROT_UNKNOWN
) {
2873 if (ata_is_ncq(tf
->protocol
) && (cdb
[2 + cdb_offset
] & 0x3) == 0)
2874 tf
->protocol
= ATA_PROT_NCQ_NODATA
;
2877 tf
->flags
|= ATA_TFLAG_LBA
;
2880 * 12 and 16 byte CDBs use different offsets to
2881 * provide the various register values.
2883 if (cdb
[0] == ATA_16
) {
2885 * 16-byte CDB - may contain extended commands.
2887 * If that is the case, copy the upper byte register values.
2889 if (cdb
[1] & 0x01) {
2890 tf
->hob_feature
= cdb
[3];
2891 tf
->hob_nsect
= cdb
[5];
2892 tf
->hob_lbal
= cdb
[7];
2893 tf
->hob_lbam
= cdb
[9];
2894 tf
->hob_lbah
= cdb
[11];
2895 tf
->flags
|= ATA_TFLAG_LBA48
;
2897 tf
->flags
&= ~ATA_TFLAG_LBA48
;
2900 * Always copy low byte, device and command registers.
2902 tf
->feature
= cdb
[4];
2907 tf
->device
= cdb
[13];
2908 tf
->command
= cdb
[14];
2909 } else if (cdb
[0] == ATA_12
) {
2911 * 12-byte CDB - incapable of extended commands.
2913 tf
->flags
&= ~ATA_TFLAG_LBA48
;
2915 tf
->feature
= cdb
[3];
2920 tf
->device
= cdb
[8];
2921 tf
->command
= cdb
[9];
2924 * 32-byte CDB - may contain extended command fields.
2926 * If that is the case, copy the upper byte register values.
2928 if (cdb
[10] & 0x01) {
2929 tf
->hob_feature
= cdb
[20];
2930 tf
->hob_nsect
= cdb
[22];
2931 tf
->hob_lbal
= cdb
[16];
2932 tf
->hob_lbam
= cdb
[15];
2933 tf
->hob_lbah
= cdb
[14];
2934 tf
->flags
|= ATA_TFLAG_LBA48
;
2936 tf
->flags
&= ~ATA_TFLAG_LBA48
;
2938 tf
->feature
= cdb
[21];
2939 tf
->nsect
= cdb
[23];
2943 tf
->device
= cdb
[24];
2944 tf
->command
= cdb
[25];
2945 tf
->auxiliary
= get_unaligned_be32(&cdb
[28]);
2948 /* For NCQ commands copy the tag value */
2949 if (ata_is_ncq(tf
->protocol
))
2950 tf
->nsect
= qc
->hw_tag
<< 3;
2952 /* enforce correct master/slave bit */
2953 tf
->device
= dev
->devno
?
2954 tf
->device
| ATA_DEV1
: tf
->device
& ~ATA_DEV1
;
2956 switch (tf
->command
) {
2957 /* READ/WRITE LONG use a non-standard sect_size */
2958 case ATA_CMD_READ_LONG
:
2959 case ATA_CMD_READ_LONG_ONCE
:
2960 case ATA_CMD_WRITE_LONG
:
2961 case ATA_CMD_WRITE_LONG_ONCE
:
2962 if (tf
->protocol
!= ATA_PROT_PIO
|| tf
->nsect
!= 1) {
2966 qc
->sect_size
= scsi_bufflen(scmd
);
2969 /* commands using reported Logical Block size (e.g. 512 or 4K) */
2970 case ATA_CMD_CFA_WRITE_NE
:
2971 case ATA_CMD_CFA_TRANS_SECT
:
2972 case ATA_CMD_CFA_WRITE_MULT_NE
:
2973 /* XXX: case ATA_CMD_CFA_WRITE_SECTORS_WITHOUT_ERASE: */
2975 case ATA_CMD_READ_EXT
:
2976 case ATA_CMD_READ_QUEUED
:
2977 /* XXX: case ATA_CMD_READ_QUEUED_EXT: */
2978 case ATA_CMD_FPDMA_READ
:
2979 case ATA_CMD_READ_MULTI
:
2980 case ATA_CMD_READ_MULTI_EXT
:
2981 case ATA_CMD_PIO_READ
:
2982 case ATA_CMD_PIO_READ_EXT
:
2983 case ATA_CMD_READ_STREAM_DMA_EXT
:
2984 case ATA_CMD_READ_STREAM_EXT
:
2985 case ATA_CMD_VERIFY
:
2986 case ATA_CMD_VERIFY_EXT
:
2988 case ATA_CMD_WRITE_EXT
:
2989 case ATA_CMD_WRITE_FUA_EXT
:
2990 case ATA_CMD_WRITE_QUEUED
:
2991 case ATA_CMD_WRITE_QUEUED_FUA_EXT
:
2992 case ATA_CMD_FPDMA_WRITE
:
2993 case ATA_CMD_WRITE_MULTI
:
2994 case ATA_CMD_WRITE_MULTI_EXT
:
2995 case ATA_CMD_WRITE_MULTI_FUA_EXT
:
2996 case ATA_CMD_PIO_WRITE
:
2997 case ATA_CMD_PIO_WRITE_EXT
:
2998 case ATA_CMD_WRITE_STREAM_DMA_EXT
:
2999 case ATA_CMD_WRITE_STREAM_EXT
:
3000 qc
->sect_size
= scmd
->device
->sector_size
;
3003 /* Everything else uses 512 byte "sectors" */
3005 qc
->sect_size
= ATA_SECT_SIZE
;
3009 * Set flags so that all registers will be written, pass on
3010 * write indication (used for PIO/DMA setup), result TF is
3011 * copied back and we don't whine too much about its failure.
3013 tf
->flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
;
3014 if (scmd
->sc_data_direction
== DMA_TO_DEVICE
)
3015 tf
->flags
|= ATA_TFLAG_WRITE
;
3017 qc
->flags
|= ATA_QCFLAG_RESULT_TF
| ATA_QCFLAG_QUIET
;
3020 * Set transfer length.
3022 * TODO: find out if we need to do more here to
3023 * cover scatter/gather case.
3025 ata_qc_set_pc_nbytes(qc
);
3027 /* We may not issue DMA commands if no DMA mode is set */
3028 if (tf
->protocol
== ATA_PROT_DMA
&& dev
->dma_mode
== 0) {
3033 /* We may not issue NCQ commands to devices not supporting NCQ */
3034 if (ata_is_ncq(tf
->protocol
) && !ata_ncq_enabled(dev
)) {
3039 /* sanity check for pio multi commands */
3040 if ((cdb
[1] & 0xe0) && !is_multi_taskfile(tf
)) {
3045 if (is_multi_taskfile(tf
)) {
3046 unsigned int multi_count
= 1 << (cdb
[1] >> 5);
3048 /* compare the passed through multi_count
3049 * with the cached multi_count of libata
3051 if (multi_count
!= dev
->multi_count
)
3052 ata_dev_warn(dev
, "invalid multi_count %u ignored\n",
3057 * Filter SET_FEATURES - XFER MODE command -- otherwise,
3058 * SET_FEATURES - XFER MODE must be preceded/succeeded
3059 * by an update to hardware-specific registers for each
3060 * controller (i.e. the reason for ->set_piomode(),
3061 * ->set_dmamode(), and ->post_set_mode() hooks).
3063 if (tf
->command
== ATA_CMD_SET_FEATURES
&&
3064 tf
->feature
== SETFEATURES_XFER
) {
3065 fp
= (cdb
[0] == ATA_16
) ? 4 : 3;
3070 * Filter TPM commands by default. These provide an
3071 * essentially uncontrolled encrypted "back door" between
3072 * applications and the disk. Set libata.allow_tpm=1 if you
3073 * have a real reason for wanting to use them. This ensures
3074 * that installed software cannot easily mess stuff up without
3075 * user intent. DVR type users will probably ship with this enabled
3076 * for movie content management.
3078 * Note that for ATA8 we can issue a DCS change and DCS freeze lock
3079 * for this and should do in future but that it is not sufficient as
3080 * DCS is an optional feature set. Thus we also do the software filter
3081 * so that we comply with the TC consortium stated goal that the user
3082 * can turn off TC features of their system.
3084 if (tf
->command
>= 0x5C && tf
->command
<= 0x5F && !libata_allow_tpm
) {
3085 fp
= (cdb
[0] == ATA_16
) ? 14 : 9;
3092 ata_scsi_set_invalid_field(dev
, scmd
, fp
, 0xff);
3097 * ata_format_dsm_trim_descr() - SATL Write Same to DSM Trim
3098 * @cmd: SCSI command being translated
3099 * @trmax: Maximum number of entries that will fit in sector_size bytes.
3100 * @sector: Starting sector
3101 * @count: Total Range of request in logical sectors
3103 * Rewrite the WRITE SAME descriptor to be a DSM TRIM little-endian formatted
3106 * Upto 64 entries of the format:
3107 * 63:48 Range Length
3110 * Range Length of 0 is ignored.
3111 * LBA's should be sorted order and not overlap.
3113 * NOTE: this is the same format as ADD LBA(S) TO NV CACHE PINNED SET
3115 * Return: Number of bytes copied into sglist.
3117 static size_t ata_format_dsm_trim_descr(struct scsi_cmnd
*cmd
, u32 trmax
,
3118 u64 sector
, u32 count
)
3120 struct scsi_device
*sdp
= cmd
->device
;
3121 size_t len
= sdp
->sector_size
;
3125 unsigned long flags
;
3127 WARN_ON(len
> ATA_SCSI_RBUF_SIZE
);
3129 if (len
> ATA_SCSI_RBUF_SIZE
)
3130 len
= ATA_SCSI_RBUF_SIZE
;
3132 spin_lock_irqsave(&ata_scsi_rbuf_lock
, flags
);
3133 buf
= ((void *)ata_scsi_rbuf
);
3134 memset(buf
, 0, len
);
3136 u64 entry
= sector
|
3137 ((u64
)(count
> 0xffff ? 0xffff : count
) << 48);
3138 buf
[i
++] = __cpu_to_le64(entry
);
3139 if (count
<= 0xffff)
3144 r
= sg_copy_from_buffer(scsi_sglist(cmd
), scsi_sg_count(cmd
), buf
, len
);
3145 spin_unlock_irqrestore(&ata_scsi_rbuf_lock
, flags
);
3151 * ata_scsi_write_same_xlat() - SATL Write Same to ATA SCT Write Same
3152 * @qc: Command to be translated
3154 * Translate a SCSI WRITE SAME command to be either a DSM TRIM command or
3155 * an SCT Write Same command.
3156 * Based on WRITE SAME has the UNMAP flag:
3158 * - When set translate to DSM TRIM
3159 * - When clear translate to SCT Write Same
3161 static unsigned int ata_scsi_write_same_xlat(struct ata_queued_cmd
*qc
)
3163 struct ata_taskfile
*tf
= &qc
->tf
;
3164 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
3165 struct scsi_device
*sdp
= scmd
->device
;
3166 size_t len
= sdp
->sector_size
;
3167 struct ata_device
*dev
= qc
->dev
;
3168 const u8
*cdb
= scmd
->cmnd
;
3171 const u32 trmax
= len
>> 3;
3175 u8 unmap
= cdb
[1] & 0x8;
3177 /* we may not issue DMA commands if no DMA mode is set */
3178 if (unlikely(!dev
->dma_mode
))
3179 goto invalid_opcode
;
3182 * We only allow sending this command through the block layer,
3183 * as it modifies the DATA OUT buffer, which would corrupt user
3184 * memory for SG_IO commands.
3186 if (unlikely(blk_rq_is_passthrough(scmd
->request
)))
3187 goto invalid_opcode
;
3189 if (unlikely(scmd
->cmd_len
< 16)) {
3193 scsi_16_lba_len(cdb
, &block
, &n_block
);
3196 (dev
->horkage
& ATA_HORKAGE_NOTRIM
) ||
3197 !ata_id_has_trim(dev
->id
)) {
3202 /* If the request is too large the cmd is invalid */
3203 if (n_block
> 0xffff * trmax
) {
3209 * WRITE SAME always has a sector sized buffer as payload, this
3210 * should never be a multiple entry S/G list.
3212 if (!scsi_sg_count(scmd
))
3213 goto invalid_param_len
;
3216 * size must match sector size in bytes
3217 * For DATA SET MANAGEMENT TRIM in ACS-2 nsect (aka count)
3218 * is defined as number of 512 byte blocks to be transferred.
3221 size
= ata_format_dsm_trim_descr(scmd
, trmax
, block
, n_block
);
3223 goto invalid_param_len
;
3225 if (ata_ncq_enabled(dev
) && ata_fpdma_dsm_supported(dev
)) {
3226 /* Newer devices support queued TRIM commands */
3227 tf
->protocol
= ATA_PROT_NCQ
;
3228 tf
->command
= ATA_CMD_FPDMA_SEND
;
3229 tf
->hob_nsect
= ATA_SUBCMD_FPDMA_SEND_DSM
& 0x1f;
3230 tf
->nsect
= qc
->hw_tag
<< 3;
3231 tf
->hob_feature
= (size
/ 512) >> 8;
3232 tf
->feature
= size
/ 512;
3236 tf
->protocol
= ATA_PROT_DMA
;
3237 tf
->hob_feature
= 0;
3238 tf
->feature
= ATA_DSM_TRIM
;
3239 tf
->hob_nsect
= (size
/ 512) >> 8;
3240 tf
->nsect
= size
/ 512;
3241 tf
->command
= ATA_CMD_DSM
;
3244 tf
->flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
| ATA_TFLAG_LBA48
|
3247 ata_qc_set_pc_nbytes(qc
);
3252 ata_scsi_set_invalid_field(dev
, scmd
, fp
, bp
);
3255 /* "Parameter list length error" */
3256 ata_scsi_set_sense(dev
, scmd
, ILLEGAL_REQUEST
, 0x1a, 0x0);
3259 /* "Invalid command operation code" */
3260 ata_scsi_set_sense(dev
, scmd
, ILLEGAL_REQUEST
, 0x20, 0x0);
3265 * ata_scsiop_maint_in - Simulate a subset of MAINTENANCE_IN
3266 * @args: device MAINTENANCE_IN data / SCSI command of interest.
3267 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
3269 * Yields a subset to satisfy scsi_report_opcode()
3272 * spin_lock_irqsave(host lock)
3274 static unsigned int ata_scsiop_maint_in(struct ata_scsi_args
*args
, u8
*rbuf
)
3276 struct ata_device
*dev
= args
->dev
;
3277 u8
*cdb
= args
->cmd
->cmnd
;
3279 unsigned int err
= 0;
3282 ata_dev_warn(dev
, "invalid command format %d\n", cdb
[2]);
3291 case SERVICE_ACTION_IN_16
:
3294 case SYNCHRONIZE_CACHE
:
3298 case TEST_UNIT_READY
:
3299 case SEND_DIAGNOSTIC
:
3300 case MAINTENANCE_IN
:
3312 case MODE_SELECT_10
:
3318 if (ata_id_zoned_cap(dev
->id
) ||
3319 dev
->class == ATA_DEV_ZAC
)
3322 case SECURITY_PROTOCOL_IN
:
3323 case SECURITY_PROTOCOL_OUT
:
3324 if (dev
->flags
& ATA_DFLAG_TRUSTED
)
3331 rbuf
[1] = supported
; /* supported */
3336 * ata_scsi_report_zones_complete - convert ATA output
3337 * @qc: command structure returning the data
3339 * Convert T-13 little-endian field representation into
3340 * T-10 big-endian field representation.
3343 static void ata_scsi_report_zones_complete(struct ata_queued_cmd
*qc
)
3345 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
3346 struct sg_mapping_iter miter
;
3347 unsigned long flags
;
3348 unsigned int bytes
= 0;
3350 sg_miter_start(&miter
, scsi_sglist(scmd
), scsi_sg_count(scmd
),
3351 SG_MITER_TO_SG
| SG_MITER_ATOMIC
);
3353 local_irq_save(flags
);
3354 while (sg_miter_next(&miter
)) {
3355 unsigned int offset
= 0;
3360 u64 max_lba
, opt_lba
;
3363 /* Swizzle header */
3365 list_length
= get_unaligned_le32(&hdr
[0]);
3366 same
= get_unaligned_le16(&hdr
[4]);
3367 max_lba
= get_unaligned_le64(&hdr
[8]);
3368 opt_lba
= get_unaligned_le64(&hdr
[16]);
3369 put_unaligned_be32(list_length
, &hdr
[0]);
3370 hdr
[4] = same
& 0xf;
3371 put_unaligned_be64(max_lba
, &hdr
[8]);
3372 put_unaligned_be64(opt_lba
, &hdr
[16]);
3376 while (offset
< miter
.length
) {
3378 u8 cond
, type
, non_seq
, reset
;
3379 u64 size
, start
, wp
;
3381 /* Swizzle zone descriptor */
3382 rec
= miter
.addr
+ offset
;
3383 type
= rec
[0] & 0xf;
3384 cond
= (rec
[1] >> 4) & 0xf;
3385 non_seq
= (rec
[1] & 2);
3386 reset
= (rec
[1] & 1);
3387 size
= get_unaligned_le64(&rec
[8]);
3388 start
= get_unaligned_le64(&rec
[16]);
3389 wp
= get_unaligned_le64(&rec
[24]);
3391 rec
[1] = (cond
<< 4) | non_seq
| reset
;
3392 put_unaligned_be64(size
, &rec
[8]);
3393 put_unaligned_be64(start
, &rec
[16]);
3394 put_unaligned_be64(wp
, &rec
[24]);
3395 WARN_ON(offset
+ 64 > miter
.length
);
3400 sg_miter_stop(&miter
);
3401 local_irq_restore(flags
);
3403 ata_scsi_qc_complete(qc
);
3406 static unsigned int ata_scsi_zbc_in_xlat(struct ata_queued_cmd
*qc
)
3408 struct ata_taskfile
*tf
= &qc
->tf
;
3409 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
3410 const u8
*cdb
= scmd
->cmnd
;
3411 u16 sect
, fp
= (u16
)-1;
3412 u8 sa
, options
, bp
= 0xff;
3416 if (unlikely(scmd
->cmd_len
< 16)) {
3417 ata_dev_warn(qc
->dev
, "invalid cdb length %d\n",
3422 scsi_16_lba_len(cdb
, &block
, &n_block
);
3423 if (n_block
!= scsi_bufflen(scmd
)) {
3424 ata_dev_warn(qc
->dev
, "non-matching transfer count (%d/%d)\n",
3425 n_block
, scsi_bufflen(scmd
));
3426 goto invalid_param_len
;
3429 if (sa
!= ZI_REPORT_ZONES
) {
3430 ata_dev_warn(qc
->dev
, "invalid service action %d\n", sa
);
3435 * ZAC allows only for transfers in 512 byte blocks,
3436 * and uses a 16 bit value for the transfer count.
3438 if ((n_block
/ 512) > 0xffff || n_block
< 512 || (n_block
% 512)) {
3439 ata_dev_warn(qc
->dev
, "invalid transfer count %d\n", n_block
);
3440 goto invalid_param_len
;
3442 sect
= n_block
/ 512;
3443 options
= cdb
[14] & 0xbf;
3445 if (ata_ncq_enabled(qc
->dev
) &&
3446 ata_fpdma_zac_mgmt_in_supported(qc
->dev
)) {
3447 tf
->protocol
= ATA_PROT_NCQ
;
3448 tf
->command
= ATA_CMD_FPDMA_RECV
;
3449 tf
->hob_nsect
= ATA_SUBCMD_FPDMA_RECV_ZAC_MGMT_IN
& 0x1f;
3450 tf
->nsect
= qc
->hw_tag
<< 3;
3451 tf
->feature
= sect
& 0xff;
3452 tf
->hob_feature
= (sect
>> 8) & 0xff;
3453 tf
->auxiliary
= ATA_SUBCMD_ZAC_MGMT_IN_REPORT_ZONES
| (options
<< 8);
3455 tf
->command
= ATA_CMD_ZAC_MGMT_IN
;
3456 tf
->feature
= ATA_SUBCMD_ZAC_MGMT_IN_REPORT_ZONES
;
3457 tf
->protocol
= ATA_PROT_DMA
;
3458 tf
->hob_feature
= options
;
3459 tf
->hob_nsect
= (sect
>> 8) & 0xff;
3460 tf
->nsect
= sect
& 0xff;
3462 tf
->device
= ATA_LBA
;
3463 tf
->lbah
= (block
>> 16) & 0xff;
3464 tf
->lbam
= (block
>> 8) & 0xff;
3465 tf
->lbal
= block
& 0xff;
3466 tf
->hob_lbah
= (block
>> 40) & 0xff;
3467 tf
->hob_lbam
= (block
>> 32) & 0xff;
3468 tf
->hob_lbal
= (block
>> 24) & 0xff;
3470 tf
->flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
| ATA_TFLAG_LBA48
;
3471 qc
->flags
|= ATA_QCFLAG_RESULT_TF
;
3473 ata_qc_set_pc_nbytes(qc
);
3475 qc
->complete_fn
= ata_scsi_report_zones_complete
;
3480 ata_scsi_set_invalid_field(qc
->dev
, scmd
, fp
, bp
);
3484 /* "Parameter list length error" */
3485 ata_scsi_set_sense(qc
->dev
, scmd
, ILLEGAL_REQUEST
, 0x1a, 0x0);
3489 static unsigned int ata_scsi_zbc_out_xlat(struct ata_queued_cmd
*qc
)
3491 struct ata_taskfile
*tf
= &qc
->tf
;
3492 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
3493 struct ata_device
*dev
= qc
->dev
;
3494 const u8
*cdb
= scmd
->cmnd
;
3500 if (unlikely(scmd
->cmd_len
< 16)) {
3506 if ((sa
!= ZO_CLOSE_ZONE
) && (sa
!= ZO_FINISH_ZONE
) &&
3507 (sa
!= ZO_OPEN_ZONE
) && (sa
!= ZO_RESET_WRITE_POINTER
)) {
3512 scsi_16_lba_len(cdb
, &block
, &n_block
);
3515 * ZAC MANAGEMENT OUT doesn't define any length
3517 goto invalid_param_len
;
3520 all
= cdb
[14] & 0x1;
3523 * Ignore the block address (zone ID) as defined by ZBC.
3526 } else if (block
>= dev
->n_sectors
) {
3528 * Block must be a valid zone ID (a zone start LBA).
3534 if (ata_ncq_enabled(qc
->dev
) &&
3535 ata_fpdma_zac_mgmt_out_supported(qc
->dev
)) {
3536 tf
->protocol
= ATA_PROT_NCQ_NODATA
;
3537 tf
->command
= ATA_CMD_NCQ_NON_DATA
;
3538 tf
->feature
= ATA_SUBCMD_NCQ_NON_DATA_ZAC_MGMT_OUT
;
3539 tf
->nsect
= qc
->hw_tag
<< 3;
3540 tf
->auxiliary
= sa
| ((u16
)all
<< 8);
3542 tf
->protocol
= ATA_PROT_NODATA
;
3543 tf
->command
= ATA_CMD_ZAC_MGMT_OUT
;
3545 tf
->hob_feature
= all
;
3547 tf
->lbah
= (block
>> 16) & 0xff;
3548 tf
->lbam
= (block
>> 8) & 0xff;
3549 tf
->lbal
= block
& 0xff;
3550 tf
->hob_lbah
= (block
>> 40) & 0xff;
3551 tf
->hob_lbam
= (block
>> 32) & 0xff;
3552 tf
->hob_lbal
= (block
>> 24) & 0xff;
3553 tf
->device
= ATA_LBA
;
3554 tf
->flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
| ATA_TFLAG_LBA48
;
3559 ata_scsi_set_invalid_field(qc
->dev
, scmd
, fp
, 0xff);
3562 /* "Parameter list length error" */
3563 ata_scsi_set_sense(qc
->dev
, scmd
, ILLEGAL_REQUEST
, 0x1a, 0x0);
3568 * ata_mselect_caching - Simulate MODE SELECT for caching info page
3569 * @qc: Storage for translated ATA taskfile
3570 * @buf: input buffer
3571 * @len: number of valid bytes in the input buffer
3572 * @fp: out parameter for the failed field on error
3574 * Prepare a taskfile to modify caching information for the device.
3579 static int ata_mselect_caching(struct ata_queued_cmd
*qc
,
3580 const u8
*buf
, int len
, u16
*fp
)
3582 struct ata_taskfile
*tf
= &qc
->tf
;
3583 struct ata_device
*dev
= qc
->dev
;
3584 u8 mpage
[CACHE_MPAGE_LEN
];
3589 * The first two bytes of def_cache_mpage are a header, so offsets
3590 * in mpage are off by 2 compared to buf. Same for len.
3593 if (len
!= CACHE_MPAGE_LEN
- 2) {
3594 if (len
< CACHE_MPAGE_LEN
- 2)
3597 *fp
= CACHE_MPAGE_LEN
- 2;
3601 wce
= buf
[0] & (1 << 2);
3604 * Check that read-only bits are not modified.
3606 ata_msense_caching(dev
->id
, mpage
, false);
3607 for (i
= 0; i
< CACHE_MPAGE_LEN
- 2; i
++) {
3610 if (mpage
[i
+ 2] != buf
[i
]) {
3616 tf
->flags
|= ATA_TFLAG_DEVICE
| ATA_TFLAG_ISADDR
;
3617 tf
->protocol
= ATA_PROT_NODATA
;
3619 tf
->command
= ATA_CMD_SET_FEATURES
;
3620 tf
->feature
= wce
? SETFEATURES_WC_ON
: SETFEATURES_WC_OFF
;
3625 * ata_mselect_control - Simulate MODE SELECT for control page
3626 * @qc: Storage for translated ATA taskfile
3627 * @buf: input buffer
3628 * @len: number of valid bytes in the input buffer
3629 * @fp: out parameter for the failed field on error
3631 * Prepare a taskfile to modify caching information for the device.
3636 static int ata_mselect_control(struct ata_queued_cmd
*qc
,
3637 const u8
*buf
, int len
, u16
*fp
)
3639 struct ata_device
*dev
= qc
->dev
;
3640 u8 mpage
[CONTROL_MPAGE_LEN
];
3645 * The first two bytes of def_control_mpage are a header, so offsets
3646 * in mpage are off by 2 compared to buf. Same for len.
3649 if (len
!= CONTROL_MPAGE_LEN
- 2) {
3650 if (len
< CONTROL_MPAGE_LEN
- 2)
3653 *fp
= CONTROL_MPAGE_LEN
- 2;
3657 d_sense
= buf
[0] & (1 << 2);
3660 * Check that read-only bits are not modified.
3662 ata_msense_control(dev
, mpage
, false);
3663 for (i
= 0; i
< CONTROL_MPAGE_LEN
- 2; i
++) {
3666 if (mpage
[2 + i
] != buf
[i
]) {
3671 if (d_sense
& (1 << 2))
3672 dev
->flags
|= ATA_DFLAG_D_SENSE
;
3674 dev
->flags
&= ~ATA_DFLAG_D_SENSE
;
3679 * ata_scsi_mode_select_xlat - Simulate MODE SELECT 6, 10 commands
3680 * @qc: Storage for translated ATA taskfile
3682 * Converts a MODE SELECT command to an ATA SET FEATURES taskfile.
3683 * Assume this is invoked for direct access devices (e.g. disks) only.
3684 * There should be no block descriptor for other device types.
3687 * spin_lock_irqsave(host lock)
3689 static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd
*qc
)
3691 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
3692 const u8
*cdb
= scmd
->cmnd
;
3694 unsigned six_byte
, pg_len
, hdr_len
, bd_len
;
3699 const u8
*p
= buffer
;
3703 six_byte
= (cdb
[0] == MODE_SELECT
);
3705 if (scmd
->cmd_len
< 5) {
3713 if (scmd
->cmd_len
< 9) {
3718 len
= (cdb
[7] << 8) + cdb
[8];
3722 /* We only support PF=1, SP=0. */
3723 if ((cdb
[1] & 0x11) != 0x10) {
3725 bp
= (cdb
[1] & 0x01) ? 1 : 5;
3729 /* Test early for possible overrun. */
3730 if (!scsi_sg_count(scmd
) || scsi_sglist(scmd
)->length
< len
)
3731 goto invalid_param_len
;
3733 /* Move past header and block descriptors. */
3735 goto invalid_param_len
;
3737 if (!sg_copy_to_buffer(scsi_sglist(scmd
), scsi_sg_count(scmd
),
3738 buffer
, sizeof(buffer
)))
3739 goto invalid_param_len
;
3744 bd_len
= (p
[6] << 8) + p
[7];
3749 goto invalid_param_len
;
3750 if (bd_len
!= 0 && bd_len
!= 8) {
3751 fp
= (six_byte
) ? 3 : 6;
3752 fp
+= bd_len
+ hdr_len
;
3761 /* Parse both possible formats for the mode page headers. */
3765 goto invalid_param_len
;
3768 pg_len
= (p
[2] << 8) | p
[3];
3773 goto invalid_param_len
;
3782 * No mode subpages supported (yet) but asking for _all_
3783 * subpages may be valid
3785 if (spg
&& (spg
!= ALL_SUB_MPAGES
)) {
3786 fp
= (p
[0] & 0x40) ? 1 : 0;
3787 fp
+= hdr_len
+ bd_len
;
3791 goto invalid_param_len
;
3795 if (ata_mselect_caching(qc
, p
, pg_len
, &fp
) < 0) {
3796 fp
+= hdr_len
+ bd_len
;
3801 if (ata_mselect_control(qc
, p
, pg_len
, &fp
) < 0) {
3802 fp
+= hdr_len
+ bd_len
;
3805 goto skip
; /* No ATA command to send */
3808 default: /* invalid page code */
3809 fp
= bd_len
+ hdr_len
;
3814 * Only one page has changeable data, so we only support setting one
3823 ata_scsi_set_invalid_field(qc
->dev
, scmd
, fp
, bp
);
3827 ata_scsi_set_invalid_parameter(qc
->dev
, scmd
, fp
);
3831 /* "Parameter list length error" */
3832 ata_scsi_set_sense(qc
->dev
, scmd
, ILLEGAL_REQUEST
, 0x1a, 0x0);
3836 scmd
->result
= SAM_STAT_GOOD
;
3840 static u8
ata_scsi_trusted_op(u32 len
, bool send
, bool dma
)
3843 return ATA_CMD_TRUSTED_NONDATA
;
3845 return dma
? ATA_CMD_TRUSTED_SND_DMA
: ATA_CMD_TRUSTED_SND
;
3847 return dma
? ATA_CMD_TRUSTED_RCV_DMA
: ATA_CMD_TRUSTED_RCV
;
3850 static unsigned int ata_scsi_security_inout_xlat(struct ata_queued_cmd
*qc
)
3852 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
3853 const u8
*cdb
= scmd
->cmnd
;
3854 struct ata_taskfile
*tf
= &qc
->tf
;
3856 bool send
= (cdb
[0] == SECURITY_PROTOCOL_OUT
);
3857 u16 spsp
= get_unaligned_be16(&cdb
[2]);
3858 u32 len
= get_unaligned_be32(&cdb
[6]);
3859 bool dma
= !(qc
->dev
->flags
& ATA_DFLAG_PIO
);
3862 * We don't support the ATA "security" protocol.
3865 ata_scsi_set_invalid_field(qc
->dev
, scmd
, 1, 0);
3869 if (cdb
[4] & 7) { /* INC_512 */
3871 ata_scsi_set_invalid_field(qc
->dev
, scmd
, 6, 0);
3875 if (len
> 0x01fffe00) {
3876 ata_scsi_set_invalid_field(qc
->dev
, scmd
, 6, 0);
3880 /* convert to the sector-based ATA addressing */
3881 len
= (len
+ 511) / 512;
3884 tf
->protocol
= dma
? ATA_PROT_DMA
: ATA_PROT_PIO
;
3885 tf
->flags
|= ATA_TFLAG_DEVICE
| ATA_TFLAG_ISADDR
| ATA_TFLAG_LBA
;
3887 tf
->flags
|= ATA_TFLAG_WRITE
;
3888 tf
->command
= ata_scsi_trusted_op(len
, send
, dma
);
3890 tf
->lbam
= spsp
& 0xff;
3891 tf
->lbah
= spsp
>> 8;
3894 tf
->nsect
= len
& 0xff;
3895 tf
->lbal
= len
>> 8;
3898 tf
->lbah
= (1 << 7);
3901 ata_qc_set_pc_nbytes(qc
);
3906 * ata_scsi_var_len_cdb_xlat - SATL variable length CDB to Handler
3907 * @qc: Command to be translated
3909 * Translate a SCSI variable length CDB to specified commands.
3910 * It checks a service action value in CDB to call corresponding handler.
3913 * Zero on success, non-zero on failure
3916 static unsigned int ata_scsi_var_len_cdb_xlat(struct ata_queued_cmd
*qc
)
3918 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
3919 const u8
*cdb
= scmd
->cmnd
;
3920 const u16 sa
= get_unaligned_be16(&cdb
[8]);
3923 * if service action represents a ata pass-thru(32) command,
3924 * then pass it to ata_scsi_pass_thru handler.
3927 return ata_scsi_pass_thru(qc
);
3929 /* unsupported service action */
3934 * ata_get_xlat_func - check if SCSI to ATA translation is possible
3936 * @cmd: SCSI command opcode to consider
3938 * Look up the SCSI command given, and determine whether the
3939 * SCSI command is to be translated or simulated.
3942 * Pointer to translation function if possible, %NULL if not.
3945 static inline ata_xlat_func_t
ata_get_xlat_func(struct ata_device
*dev
, u8 cmd
)
3955 return ata_scsi_rw_xlat
;
3958 return ata_scsi_write_same_xlat
;
3960 case SYNCHRONIZE_CACHE
:
3961 if (ata_try_flush_cache(dev
))
3962 return ata_scsi_flush_xlat
;
3967 return ata_scsi_verify_xlat
;
3971 return ata_scsi_pass_thru
;
3973 case VARIABLE_LENGTH_CMD
:
3974 return ata_scsi_var_len_cdb_xlat
;
3977 case MODE_SELECT_10
:
3978 return ata_scsi_mode_select_xlat
;
3982 return ata_scsi_zbc_in_xlat
;
3985 return ata_scsi_zbc_out_xlat
;
3987 case SECURITY_PROTOCOL_IN
:
3988 case SECURITY_PROTOCOL_OUT
:
3989 if (!(dev
->flags
& ATA_DFLAG_TRUSTED
))
3991 return ata_scsi_security_inout_xlat
;
3994 return ata_scsi_start_stop_xlat
;
4001 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
4002 * @ap: ATA port to which the command was being sent
4003 * @cmd: SCSI command to dump
4005 * Prints the contents of a SCSI command via printk().
4008 void ata_scsi_dump_cdb(struct ata_port
*ap
, struct scsi_cmnd
*cmd
)
4010 #ifdef ATA_VERBOSE_DEBUG
4011 struct scsi_device
*scsidev
= cmd
->device
;
4013 VPRINTK("CDB (%u:%d,%d,%lld) %9ph\n",
4015 scsidev
->channel
, scsidev
->id
, scsidev
->lun
,
4020 int __ata_scsi_queuecmd(struct scsi_cmnd
*scmd
, struct ata_device
*dev
)
4022 u8 scsi_op
= scmd
->cmnd
[0];
4023 ata_xlat_func_t xlat_func
;
4026 if (dev
->class == ATA_DEV_ATA
|| dev
->class == ATA_DEV_ZAC
) {
4027 if (unlikely(!scmd
->cmd_len
|| scmd
->cmd_len
> dev
->cdb_len
))
4030 xlat_func
= ata_get_xlat_func(dev
, scsi_op
);
4032 if (unlikely(!scmd
->cmd_len
))
4036 if (likely((scsi_op
!= ATA_16
) || !atapi_passthru16
)) {
4037 /* relay SCSI command to ATAPI device */
4038 int len
= COMMAND_SIZE(scsi_op
);
4039 if (unlikely(len
> scmd
->cmd_len
||
4040 len
> dev
->cdb_len
||
4041 scmd
->cmd_len
> ATAPI_CDB_LEN
))
4044 xlat_func
= atapi_xlat
;
4046 /* ATA_16 passthru, treat as an ATA command */
4047 if (unlikely(scmd
->cmd_len
> 16))
4050 xlat_func
= ata_get_xlat_func(dev
, scsi_op
);
4055 rc
= ata_scsi_translate(dev
, scmd
, xlat_func
);
4057 ata_scsi_simulate(dev
, scmd
);
4062 DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
4063 scmd
->cmd_len
, scsi_op
, dev
->cdb_len
);
4064 scmd
->result
= DID_ERROR
<< 16;
4065 scmd
->scsi_done(scmd
);
4070 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
4071 * @shost: SCSI host of command to be sent
4072 * @cmd: SCSI command to be sent
4074 * In some cases, this function translates SCSI commands into
4075 * ATA taskfiles, and queues the taskfiles to be sent to
4076 * hardware. In other cases, this function simulates a
4077 * SCSI device by evaluating and responding to certain
4078 * SCSI commands. This creates the overall effect of
4079 * ATA and ATAPI devices appearing as SCSI devices.
4085 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
4088 int ata_scsi_queuecmd(struct Scsi_Host
*shost
, struct scsi_cmnd
*cmd
)
4090 struct ata_port
*ap
;
4091 struct ata_device
*dev
;
4092 struct scsi_device
*scsidev
= cmd
->device
;
4094 unsigned long irq_flags
;
4096 ap
= ata_shost_to_port(shost
);
4098 spin_lock_irqsave(ap
->lock
, irq_flags
);
4100 ata_scsi_dump_cdb(ap
, cmd
);
4102 dev
= ata_scsi_find_dev(ap
, scsidev
);
4104 rc
= __ata_scsi_queuecmd(cmd
, dev
);
4106 cmd
->result
= (DID_BAD_TARGET
<< 16);
4107 cmd
->scsi_done(cmd
);
4110 spin_unlock_irqrestore(ap
->lock
, irq_flags
);
4114 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd
);
4117 * ata_scsi_simulate - simulate SCSI command on ATA device
4118 * @dev: the target device
4119 * @cmd: SCSI command being sent to device.
4121 * Interprets and directly executes a select list of SCSI commands
4122 * that can be handled internally.
4125 * spin_lock_irqsave(host lock)
4128 void ata_scsi_simulate(struct ata_device
*dev
, struct scsi_cmnd
*cmd
)
4130 struct ata_scsi_args args
;
4131 const u8
*scsicmd
= cmd
->cmnd
;
4138 switch(scsicmd
[0]) {
4140 if (scsicmd
[1] & 2) /* is CmdDt set? */
4141 ata_scsi_set_invalid_field(dev
, cmd
, 1, 0xff);
4142 else if ((scsicmd
[1] & 1) == 0) /* is EVPD clear? */
4143 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_std
);
4144 else switch (scsicmd
[2]) {
4146 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_00
);
4149 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_80
);
4152 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_83
);
4155 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_89
);
4158 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_b0
);
4161 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_b1
);
4164 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_b2
);
4167 if (dev
->flags
& ATA_DFLAG_ZAC
) {
4168 ata_scsi_rbuf_fill(&args
, ata_scsiop_inq_b6
);
4173 ata_scsi_set_invalid_field(dev
, cmd
, 2, 0xff);
4180 ata_scsi_rbuf_fill(&args
, ata_scsiop_mode_sense
);
4184 ata_scsi_rbuf_fill(&args
, ata_scsiop_read_cap
);
4187 case SERVICE_ACTION_IN_16
:
4188 if ((scsicmd
[1] & 0x1f) == SAI_READ_CAPACITY_16
)
4189 ata_scsi_rbuf_fill(&args
, ata_scsiop_read_cap
);
4191 ata_scsi_set_invalid_field(dev
, cmd
, 1, 0xff);
4195 ata_scsi_rbuf_fill(&args
, ata_scsiop_report_luns
);
4199 ata_scsi_set_sense(dev
, cmd
, 0, 0, 0);
4200 cmd
->result
= (DRIVER_SENSE
<< 24);
4203 /* if we reach this, then writeback caching is disabled,
4204 * turning this into a no-op.
4206 case SYNCHRONIZE_CACHE
:
4209 /* no-op's, complete with success */
4213 case TEST_UNIT_READY
:
4216 case SEND_DIAGNOSTIC
:
4217 tmp8
= scsicmd
[1] & ~(1 << 3);
4218 if (tmp8
!= 0x4 || scsicmd
[3] || scsicmd
[4])
4219 ata_scsi_set_invalid_field(dev
, cmd
, 1, 0xff);
4222 case MAINTENANCE_IN
:
4223 if (scsicmd
[1] == MI_REPORT_SUPPORTED_OPERATION_CODES
)
4224 ata_scsi_rbuf_fill(&args
, ata_scsiop_maint_in
);
4226 ata_scsi_set_invalid_field(dev
, cmd
, 1, 0xff);
4229 /* all other commands */
4231 ata_scsi_set_sense(dev
, cmd
, ILLEGAL_REQUEST
, 0x20, 0x0);
4232 /* "Invalid command operation code" */
4236 cmd
->scsi_done(cmd
);
4239 int ata_scsi_add_hosts(struct ata_host
*host
, struct scsi_host_template
*sht
)
4243 for (i
= 0; i
< host
->n_ports
; i
++) {
4244 struct ata_port
*ap
= host
->ports
[i
];
4245 struct Scsi_Host
*shost
;
4248 shost
= scsi_host_alloc(sht
, sizeof(struct ata_port
*));
4252 shost
->eh_noresume
= 1;
4253 *(struct ata_port
**)&shost
->hostdata
[0] = ap
;
4254 ap
->scsi_host
= shost
;
4256 shost
->transportt
= ata_scsi_transport_template
;
4257 shost
->unique_id
= ap
->print_id
;
4260 shost
->max_channel
= 1;
4261 shost
->max_cmd_len
= 32;
4263 /* Schedule policy is determined by ->qc_defer()
4264 * callback and it needs to see every deferred qc.
4265 * Set host_blocked to 1 to prevent SCSI midlayer from
4266 * automatically deferring requests.
4268 shost
->max_host_blocked
= 1;
4270 rc
= scsi_add_host_with_dma(shost
, &ap
->tdev
, ap
->host
->dev
);
4279 struct Scsi_Host
*shost
= host
->ports
[i
]->scsi_host
;
4281 /* scsi_host_put() is in ata_devres_release() */
4282 scsi_remove_host(shost
);
4288 static void ata_scsi_assign_ofnode(struct ata_device
*dev
, struct ata_port
*ap
)
4290 struct scsi_device
*sdev
= dev
->sdev
;
4291 struct device
*d
= ap
->host
->dev
;
4292 struct device_node
*np
= d
->of_node
;
4293 struct device_node
*child
;
4295 for_each_available_child_of_node(np
, child
) {
4299 ret
= of_property_read_u32(child
, "reg", &val
);
4302 if (val
== dev
->devno
) {
4303 dev_dbg(d
, "found matching device node\n");
4304 sdev
->sdev_gendev
.of_node
= child
;
4310 static void ata_scsi_assign_ofnode(struct ata_device
*dev
, struct ata_port
*ap
)
4315 void ata_scsi_scan_host(struct ata_port
*ap
, int sync
)
4318 struct ata_device
*last_failed_dev
= NULL
;
4319 struct ata_link
*link
;
4320 struct ata_device
*dev
;
4323 ata_for_each_link(link
, ap
, EDGE
) {
4324 ata_for_each_dev(dev
, link
, ENABLED
) {
4325 struct scsi_device
*sdev
;
4326 int channel
= 0, id
= 0;
4331 if (ata_is_host_link(link
))
4334 channel
= link
->pmp
;
4336 sdev
= __scsi_add_device(ap
->scsi_host
, channel
, id
, 0,
4338 if (!IS_ERR(sdev
)) {
4340 ata_scsi_assign_ofnode(dev
, ap
);
4341 scsi_device_put(sdev
);
4348 /* If we scanned while EH was in progress or allocation
4349 * failure occurred, scan would have failed silently. Check
4350 * whether all devices are attached.
4352 ata_for_each_link(link
, ap
, EDGE
) {
4353 ata_for_each_dev(dev
, link
, ENABLED
) {
4362 /* we're missing some SCSI devices */
4364 /* If caller requested synchrnous scan && we've made
4365 * any progress, sleep briefly and repeat.
4367 if (dev
!= last_failed_dev
) {
4369 last_failed_dev
= dev
;
4373 /* We might be failing to detect boot device, give it
4374 * a few more chances.
4382 "WARNING: synchronous SCSI scan failed without making any progress, switching to async\n");
4385 queue_delayed_work(system_long_wq
, &ap
->hotplug_task
,
4386 round_jiffies_relative(HZ
));
4390 * ata_scsi_offline_dev - offline attached SCSI device
4391 * @dev: ATA device to offline attached SCSI device for
4393 * This function is called from ata_eh_hotplug() and responsible
4394 * for taking the SCSI device attached to @dev offline. This
4395 * function is called with host lock which protects dev->sdev
4399 * spin_lock_irqsave(host lock)
4402 * 1 if attached SCSI device exists, 0 otherwise.
4404 int ata_scsi_offline_dev(struct ata_device
*dev
)
4407 scsi_device_set_state(dev
->sdev
, SDEV_OFFLINE
);
4414 * ata_scsi_remove_dev - remove attached SCSI device
4415 * @dev: ATA device to remove attached SCSI device for
4417 * This function is called from ata_eh_scsi_hotplug() and
4418 * responsible for removing the SCSI device attached to @dev.
4421 * Kernel thread context (may sleep).
4423 static void ata_scsi_remove_dev(struct ata_device
*dev
)
4425 struct ata_port
*ap
= dev
->link
->ap
;
4426 struct scsi_device
*sdev
;
4427 unsigned long flags
;
4429 /* Alas, we need to grab scan_mutex to ensure SCSI device
4430 * state doesn't change underneath us and thus
4431 * scsi_device_get() always succeeds. The mutex locking can
4432 * be removed if there is __scsi_device_get() interface which
4433 * increments reference counts regardless of device state.
4435 mutex_lock(&ap
->scsi_host
->scan_mutex
);
4436 spin_lock_irqsave(ap
->lock
, flags
);
4438 /* clearing dev->sdev is protected by host lock */
4443 /* If user initiated unplug races with us, sdev can go
4444 * away underneath us after the host lock and
4445 * scan_mutex are released. Hold onto it.
4447 if (scsi_device_get(sdev
) == 0) {
4448 /* The following ensures the attached sdev is
4449 * offline on return from ata_scsi_offline_dev()
4450 * regardless it wins or loses the race
4451 * against this function.
4453 scsi_device_set_state(sdev
, SDEV_OFFLINE
);
4460 spin_unlock_irqrestore(ap
->lock
, flags
);
4461 mutex_unlock(&ap
->scsi_host
->scan_mutex
);
4464 ata_dev_info(dev
, "detaching (SCSI %s)\n",
4465 dev_name(&sdev
->sdev_gendev
));
4467 scsi_remove_device(sdev
);
4468 scsi_device_put(sdev
);
4472 static void ata_scsi_handle_link_detach(struct ata_link
*link
)
4474 struct ata_port
*ap
= link
->ap
;
4475 struct ata_device
*dev
;
4477 ata_for_each_dev(dev
, link
, ALL
) {
4478 unsigned long flags
;
4480 if (!(dev
->flags
& ATA_DFLAG_DETACHED
))
4483 spin_lock_irqsave(ap
->lock
, flags
);
4484 dev
->flags
&= ~ATA_DFLAG_DETACHED
;
4485 spin_unlock_irqrestore(ap
->lock
, flags
);
4487 if (zpodd_dev_enabled(dev
))
4490 ata_scsi_remove_dev(dev
);
4495 * ata_scsi_media_change_notify - send media change event
4496 * @dev: Pointer to the disk device with media change event
4498 * Tell the block layer to send a media change notification
4502 * spin_lock_irqsave(host lock)
4504 void ata_scsi_media_change_notify(struct ata_device
*dev
)
4507 sdev_evt_send_simple(dev
->sdev
, SDEV_EVT_MEDIA_CHANGE
,
4512 * ata_scsi_hotplug - SCSI part of hotplug
4513 * @work: Pointer to ATA port to perform SCSI hotplug on
4515 * Perform SCSI part of hotplug. It's executed from a separate
4516 * workqueue after EH completes. This is necessary because SCSI
4517 * hot plugging requires working EH and hot unplugging is
4518 * synchronized with hot plugging with a mutex.
4521 * Kernel thread context (may sleep).
4523 void ata_scsi_hotplug(struct work_struct
*work
)
4525 struct ata_port
*ap
=
4526 container_of(work
, struct ata_port
, hotplug_task
.work
);
4529 if (ap
->pflags
& ATA_PFLAG_UNLOADING
) {
4530 DPRINTK("ENTER/EXIT - unloading\n");
4535 mutex_lock(&ap
->scsi_scan_mutex
);
4537 /* Unplug detached devices. We cannot use link iterator here
4538 * because PMP links have to be scanned even if PMP is
4539 * currently not attached. Iterate manually.
4541 ata_scsi_handle_link_detach(&ap
->link
);
4543 for (i
= 0; i
< SATA_PMP_MAX_PORTS
; i
++)
4544 ata_scsi_handle_link_detach(&ap
->pmp_link
[i
]);
4546 /* scan for new ones */
4547 ata_scsi_scan_host(ap
, 0);
4549 mutex_unlock(&ap
->scsi_scan_mutex
);
4554 * ata_scsi_user_scan - indication for user-initiated bus scan
4555 * @shost: SCSI host to scan
4556 * @channel: Channel to scan
4560 * This function is called when user explicitly requests bus
4561 * scan. Set probe pending flag and invoke EH.
4564 * SCSI layer (we don't care)
4569 int ata_scsi_user_scan(struct Scsi_Host
*shost
, unsigned int channel
,
4570 unsigned int id
, u64 lun
)
4572 struct ata_port
*ap
= ata_shost_to_port(shost
);
4573 unsigned long flags
;
4576 if (!ap
->ops
->error_handler
)
4579 if (lun
!= SCAN_WILD_CARD
&& lun
)
4582 if (!sata_pmp_attached(ap
)) {
4583 if (channel
!= SCAN_WILD_CARD
&& channel
)
4587 if (id
!= SCAN_WILD_CARD
&& id
)
4592 spin_lock_irqsave(ap
->lock
, flags
);
4594 if (devno
== SCAN_WILD_CARD
) {
4595 struct ata_link
*link
;
4597 ata_for_each_link(link
, ap
, EDGE
) {
4598 struct ata_eh_info
*ehi
= &link
->eh_info
;
4599 ehi
->probe_mask
|= ATA_ALL_DEVICES
;
4600 ehi
->action
|= ATA_EH_RESET
;
4603 struct ata_device
*dev
= ata_find_dev(ap
, devno
);
4606 struct ata_eh_info
*ehi
= &dev
->link
->eh_info
;
4607 ehi
->probe_mask
|= 1 << dev
->devno
;
4608 ehi
->action
|= ATA_EH_RESET
;
4614 ata_port_schedule_eh(ap
);
4615 spin_unlock_irqrestore(ap
->lock
, flags
);
4616 ata_port_wait_eh(ap
);
4618 spin_unlock_irqrestore(ap
->lock
, flags
);
4624 * ata_scsi_dev_rescan - initiate scsi_rescan_device()
4625 * @work: Pointer to ATA port to perform scsi_rescan_device()
4627 * After ATA pass thru (SAT) commands are executed successfully,
4628 * libata need to propagate the changes to SCSI layer.
4631 * Kernel thread context (may sleep).
4633 void ata_scsi_dev_rescan(struct work_struct
*work
)
4635 struct ata_port
*ap
=
4636 container_of(work
, struct ata_port
, scsi_rescan_task
);
4637 struct ata_link
*link
;
4638 struct ata_device
*dev
;
4639 unsigned long flags
;
4641 mutex_lock(&ap
->scsi_scan_mutex
);
4642 spin_lock_irqsave(ap
->lock
, flags
);
4644 ata_for_each_link(link
, ap
, EDGE
) {
4645 ata_for_each_dev(dev
, link
, ENABLED
) {
4646 struct scsi_device
*sdev
= dev
->sdev
;
4650 if (scsi_device_get(sdev
))
4653 spin_unlock_irqrestore(ap
->lock
, flags
);
4654 scsi_rescan_device(&(sdev
->sdev_gendev
));
4655 scsi_device_put(sdev
);
4656 spin_lock_irqsave(ap
->lock
, flags
);
4660 spin_unlock_irqrestore(ap
->lock
, flags
);
4661 mutex_unlock(&ap
->scsi_scan_mutex
);