?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mmc: sdhci: let GPIO based card detection have higher precedence
[linux-2.6/btrfs-unstable.git] / drivers / ata / libata-scsi.c
blob641a61a59e89c00036af65d3a31fe2cf67eb22b8
1 /*
2 * libata-scsi.c - helper library for ATA
3 *
4 * Maintained by: Tejun Heo <tj@kernel.org>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
6 * on emails.
7 *
8 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 * Copyright 2003-2004 Jeff Garzik
10 *
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 *
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
29 *
30 * Hardware documentation available from
31 * - http://www.t10.org/
32 * - http://www.t13.org/
33 *
34 */
35
36 #include <linux/slab.h>
37 #include <linux/kernel.h>
38 #include <linux/blkdev.h>
39 #include <linux/spinlock.h>
40 #include <linux/export.h>
41 #include <scsi/scsi.h>
42 #include <scsi/scsi_host.h>
43 #include <scsi/scsi_cmnd.h>
44 #include <scsi/scsi_eh.h>
45 #include <scsi/scsi_device.h>
46 #include <scsi/scsi_tcq.h>
47 #include <scsi/scsi_transport.h>
48 #include <linux/libata.h>
49 #include <linux/hdreg.h>
50 #include <linux/uaccess.h>
51 #include <linux/suspend.h>
52 #include <asm/unaligned.h>
53
54 #include "libata.h"
55 #include "libata-transport.h"
56
57 #define ATA_SCSI_RBUF_SIZE 4096
58
59 static DEFINE_SPINLOCK(ata_scsi_rbuf_lock);
60 static u8 ata_scsi_rbuf[ATA_SCSI_RBUF_SIZE];
61
62 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc);
63
64 static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
65 const struct scsi_device *scsidev);
66 static struct ata_device *ata_scsi_find_dev(struct ata_port *ap,
67 const struct scsi_device *scsidev);
68
69 #define RW_RECOVERY_MPAGE 0x1
70 #define RW_RECOVERY_MPAGE_LEN 12
71 #define CACHE_MPAGE 0x8
72 #define CACHE_MPAGE_LEN 20
73 #define CONTROL_MPAGE 0xa
74 #define CONTROL_MPAGE_LEN 12
75 #define ALL_MPAGES 0x3f
76 #define ALL_SUB_MPAGES 0xff
77
78
79 static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = {
80 RW_RECOVERY_MPAGE,
81 RW_RECOVERY_MPAGE_LEN - 2,
82 (1 << 7), /* AWRE */
83 0, /* read retry count */
84 0, 0, 0, 0,
85 0, /* write retry count */
86 0, 0, 0
87 };
88
89 static const u8 def_cache_mpage[CACHE_MPAGE_LEN] = {
90 CACHE_MPAGE,
91 CACHE_MPAGE_LEN - 2,
92 0, /* contains WCE, needs to be 0 for logic */
93 0, 0, 0, 0, 0, 0, 0, 0, 0,
94 0, /* contains DRA, needs to be 0 for logic */
95 0, 0, 0, 0, 0, 0, 0
96 };
97
98 static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
99 CONTROL_MPAGE,
100 CONTROL_MPAGE_LEN - 2,
101 2, /* DSENSE=0, GLTSD=1 */
102 0, /* [QAM+QERR may be 1, see 05-359r1] */
103 0, 0, 0, 0, 0xff, 0xff,
104 0, 30 /* extended self test time, see 05-359r1 */
105 };
106
107 static const char *ata_lpm_policy_names[] = {
108 [ATA_LPM_UNKNOWN] = "max_performance",
109 [ATA_LPM_MAX_POWER] = "max_performance",
110 [ATA_LPM_MED_POWER] = "medium_power",
111 [ATA_LPM_MIN_POWER] = "min_power",
112 };
113
114 static ssize_t ata_scsi_lpm_store(struct device *device,
115 struct device_attribute *attr,
116 const char *buf, size_t count)
117 {
118 struct Scsi_Host *shost = class_to_shost(device);
119 struct ata_port *ap = ata_shost_to_port(shost);
120 struct ata_link *link;
121 struct ata_device *dev;
122 enum ata_lpm_policy policy;
123 unsigned long flags;
124
125 /* UNKNOWN is internal state, iterate from MAX_POWER */
126 for (policy = ATA_LPM_MAX_POWER;
127 policy < ARRAY_SIZE(ata_lpm_policy_names); policy++) {
128 const char *name = ata_lpm_policy_names[policy];
129
130 if (strncmp(name, buf, strlen(name)) == 0)
131 break;
132 }
133 if (policy == ARRAY_SIZE(ata_lpm_policy_names))
134 return -EINVAL;
135
136 spin_lock_irqsave(ap->lock, flags);
137
138 ata_for_each_link(link, ap, EDGE) {
139 ata_for_each_dev(dev, &ap->link, ENABLED) {
140 if (dev->horkage & ATA_HORKAGE_NOLPM) {
141 count = -EOPNOTSUPP;
142 goto out_unlock;
143 }
144 }
145 }
146
147 ap->target_lpm_policy = policy;
148 ata_port_schedule_eh(ap);
149 out_unlock:
150 spin_unlock_irqrestore(ap->lock, flags);
151 return count;
152 }
153
154 static ssize_t ata_scsi_lpm_show(struct device *dev,
155 struct device_attribute *attr, char *buf)
156 {
157 struct Scsi_Host *shost = class_to_shost(dev);
158 struct ata_port *ap = ata_shost_to_port(shost);
159
160 if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names))
161 return -EINVAL;
162
163 return snprintf(buf, PAGE_SIZE, "%s\n",
164 ata_lpm_policy_names[ap->target_lpm_policy]);
165 }
166 DEVICE_ATTR(link_power_management_policy, S_IRUGO | S_IWUSR,
167 ata_scsi_lpm_show, ata_scsi_lpm_store);
168 EXPORT_SYMBOL_GPL(dev_attr_link_power_management_policy);
169
170 static ssize_t ata_scsi_park_show(struct device *device,
171 struct device_attribute *attr, char *buf)
172 {
173 struct scsi_device *sdev = to_scsi_device(device);
174 struct ata_port *ap;
175 struct ata_link *link;
176 struct ata_device *dev;
177 unsigned long flags, now;
178 unsigned int uninitialized_var(msecs);
179 int rc = 0;
180
181 ap = ata_shost_to_port(sdev->host);
182
183 spin_lock_irqsave(ap->lock, flags);
184 dev = ata_scsi_find_dev(ap, sdev);
185 if (!dev) {
186 rc = -ENODEV;
187 goto unlock;
188 }
189 if (dev->flags & ATA_DFLAG_NO_UNLOAD) {
190 rc = -EOPNOTSUPP;
191 goto unlock;
192 }
193
194 link = dev->link;
195 now = jiffies;
196 if (ap->pflags & ATA_PFLAG_EH_IN_PROGRESS &&
197 link->eh_context.unloaded_mask & (1 << dev->devno) &&
198 time_after(dev->unpark_deadline, now))
199 msecs = jiffies_to_msecs(dev->unpark_deadline - now);
200 else
201 msecs = 0;
202
203 unlock:
204 spin_unlock_irq(ap->lock);
205
206 return rc ? rc : snprintf(buf, 20, "%u\n", msecs);
207 }
208
209 static ssize_t ata_scsi_park_store(struct device *device,
210 struct device_attribute *attr,
211 const char *buf, size_t len)
212 {
213 struct scsi_device *sdev = to_scsi_device(device);
214 struct ata_port *ap;
215 struct ata_device *dev;
216 long int input;
217 unsigned long flags;
218 int rc;
219
220 rc = kstrtol(buf, 10, &input);
221 if (rc)
222 return rc;
223 if (input < -2)
224 return -EINVAL;
225 if (input > ATA_TMOUT_MAX_PARK) {
226 rc = -EOVERFLOW;
227 input = ATA_TMOUT_MAX_PARK;
228 }
229
230 ap = ata_shost_to_port(sdev->host);
231
232 spin_lock_irqsave(ap->lock, flags);
233 dev = ata_scsi_find_dev(ap, sdev);
234 if (unlikely(!dev)) {
235 rc = -ENODEV;
236 goto unlock;
237 }
238 if (dev->class != ATA_DEV_ATA &&
239 dev->class != ATA_DEV_ZAC) {
240 rc = -EOPNOTSUPP;
241 goto unlock;
242 }
243
244 if (input >= 0) {
245 if (dev->flags & ATA_DFLAG_NO_UNLOAD) {
246 rc = -EOPNOTSUPP;
247 goto unlock;
248 }
249
250 dev->unpark_deadline = ata_deadline(jiffies, input);
251 dev->link->eh_info.dev_action[dev->devno] |= ATA_EH_PARK;
252 ata_port_schedule_eh(ap);
253 complete(&ap->park_req_pending);
254 } else {
255 switch (input) {
256 case -1:
257 dev->flags &= ~ATA_DFLAG_NO_UNLOAD;
258 break;
259 case -2:
260 dev->flags |= ATA_DFLAG_NO_UNLOAD;
261 break;
262 }
263 }
264 unlock:
265 spin_unlock_irqrestore(ap->lock, flags);
266
267 return rc ? rc : len;
268 }
269 DEVICE_ATTR(unload_heads, S_IRUGO | S_IWUSR,
270 ata_scsi_park_show, ata_scsi_park_store);
271 EXPORT_SYMBOL_GPL(dev_attr_unload_heads);
272
273 void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
274 {
275 if (!cmd)
276 return;
277
278 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
279
280 scsi_build_sense_buffer(0, cmd->sense_buffer, sk, asc, ascq);
281 }
282
283 void ata_scsi_set_sense_information(struct scsi_cmnd *cmd,
284 const struct ata_taskfile *tf)
285 {
286 u64 information;
287
288 if (!cmd)
289 return;
290
291 information = ata_tf_read_block(tf, NULL);
292 scsi_set_sense_information(cmd->sense_buffer, information);
293 }
294
295 static ssize_t
296 ata_scsi_em_message_store(struct device *dev, struct device_attribute *attr,
297 const char *buf, size_t count)
298 {
299 struct Scsi_Host *shost = class_to_shost(dev);
300 struct ata_port *ap = ata_shost_to_port(shost);
301 if (ap->ops->em_store && (ap->flags & ATA_FLAG_EM))
302 return ap->ops->em_store(ap, buf, count);
303 return -EINVAL;
304 }
305
306 static ssize_t
307 ata_scsi_em_message_show(struct device *dev, struct device_attribute *attr,
308 char *buf)
309 {
310 struct Scsi_Host *shost = class_to_shost(dev);
311 struct ata_port *ap = ata_shost_to_port(shost);
312
313 if (ap->ops->em_show && (ap->flags & ATA_FLAG_EM))
314 return ap->ops->em_show(ap, buf);
315 return -EINVAL;
316 }
317 DEVICE_ATTR(em_message, S_IRUGO | S_IWUSR,
318 ata_scsi_em_message_show, ata_scsi_em_message_store);
319 EXPORT_SYMBOL_GPL(dev_attr_em_message);
320
321 static ssize_t
322 ata_scsi_em_message_type_show(struct device *dev, struct device_attribute *attr,
323 char *buf)
324 {
325 struct Scsi_Host *shost = class_to_shost(dev);
326 struct ata_port *ap = ata_shost_to_port(shost);
327
328 return snprintf(buf, 23, "%d\n", ap->em_message_type);
329 }
330 DEVICE_ATTR(em_message_type, S_IRUGO,
331 ata_scsi_em_message_type_show, NULL);
332 EXPORT_SYMBOL_GPL(dev_attr_em_message_type);
333
334 static ssize_t
335 ata_scsi_activity_show(struct device *dev, struct device_attribute *attr,
336 char *buf)
337 {
338 struct scsi_device *sdev = to_scsi_device(dev);
339 struct ata_port *ap = ata_shost_to_port(sdev->host);
340 struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);
341
342 if (atadev && ap->ops->sw_activity_show &&
343 (ap->flags & ATA_FLAG_SW_ACTIVITY))
344 return ap->ops->sw_activity_show(atadev, buf);
345 return -EINVAL;
346 }
347
348 static ssize_t
349 ata_scsi_activity_store(struct device *dev, struct device_attribute *attr,
350 const char *buf, size_t count)
351 {
352 struct scsi_device *sdev = to_scsi_device(dev);
353 struct ata_port *ap = ata_shost_to_port(sdev->host);
354 struct ata_device *atadev = ata_scsi_find_dev(ap, sdev);
355 enum sw_activity val;
356 int rc;
357
358 if (atadev && ap->ops->sw_activity_store &&
359 (ap->flags & ATA_FLAG_SW_ACTIVITY)) {
360 val = simple_strtoul(buf, NULL, 0);
361 switch (val) {
362 case OFF: case BLINK_ON: case BLINK_OFF:
363 rc = ap->ops->sw_activity_store(atadev, val);
364 if (!rc)
365 return count;
366 else
367 return rc;
368 }
369 }
370 return -EINVAL;
371 }
372 DEVICE_ATTR(sw_activity, S_IWUSR | S_IRUGO, ata_scsi_activity_show,
373 ata_scsi_activity_store);
374 EXPORT_SYMBOL_GPL(dev_attr_sw_activity);
375
376 struct device_attribute *ata_common_sdev_attrs[] = {
377 &dev_attr_unload_heads,
378 NULL
379 };
380 EXPORT_SYMBOL_GPL(ata_common_sdev_attrs);
381
382 static void ata_scsi_invalid_field(struct scsi_cmnd *cmd)
383 {
384 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x24, 0x0);
385 /* "Invalid field in cbd" */
386 cmd->scsi_done(cmd);
387 }
388
389 /**
390 * ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
391 * @sdev: SCSI device for which BIOS geometry is to be determined
392 * @bdev: block device associated with @sdev
393 * @capacity: capacity of SCSI device
394 * @geom: location to which geometry will be output
395 *
396 * Generic bios head/sector/cylinder calculator
397 * used by sd. Most BIOSes nowadays expect a XXX/255/16 (CHS)
398 * mapping. Some situations may arise where the disk is not
399 * bootable if this is not used.
400 *
401 * LOCKING:
402 * Defined by the SCSI layer. We don't really care.
403 *
404 * RETURNS:
405 * Zero.
406 */
407 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
408 sector_t capacity, int geom[])
409 {
410 geom[0] = 255;
411 geom[1] = 63;
412 sector_div(capacity, 255*63);
413 geom[2] = capacity;
414
415 return 0;
416 }
417
418 /**
419 * ata_scsi_unlock_native_capacity - unlock native capacity
420 * @sdev: SCSI device to adjust device capacity for
421 *
422 * This function is called if a partition on @sdev extends beyond
423 * the end of the device. It requests EH to unlock HPA.
424 *
425 * LOCKING:
426 * Defined by the SCSI layer. Might sleep.
427 */
428 void ata_scsi_unlock_native_capacity(struct scsi_device *sdev)
429 {
430 struct ata_port *ap = ata_shost_to_port(sdev->host);
431 struct ata_device *dev;
432 unsigned long flags;
433
434 spin_lock_irqsave(ap->lock, flags);
435
436 dev = ata_scsi_find_dev(ap, sdev);
437 if (dev && dev->n_sectors < dev->n_native_sectors) {
438 dev->flags |= ATA_DFLAG_UNLOCK_HPA;
439 dev->link->eh_info.action |= ATA_EH_RESET;
440 ata_port_schedule_eh(ap);
441 }
442
443 spin_unlock_irqrestore(ap->lock, flags);
444 ata_port_wait_eh(ap);
445 }
446
447 /**
448 * ata_get_identity - Handler for HDIO_GET_IDENTITY ioctl
449 * @ap: target port
450 * @sdev: SCSI device to get identify data for
451 * @arg: User buffer area for identify data
452 *
453 * LOCKING:
454 * Defined by the SCSI layer. We don't really care.
455 *
456 * RETURNS:
457 * Zero on success, negative errno on error.
458 */
459 static int ata_get_identity(struct ata_port *ap, struct scsi_device *sdev,
460 void __user *arg)
461 {
462 struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
463 u16 __user *dst = arg;
464 char buf[40];
465
466 if (!dev)
467 return -ENOMSG;
468
469 if (copy_to_user(dst, dev->id, ATA_ID_WORDS * sizeof(u16)))
470 return -EFAULT;
471
472 ata_id_string(dev->id, buf, ATA_ID_PROD, ATA_ID_PROD_LEN);
473 if (copy_to_user(dst + ATA_ID_PROD, buf, ATA_ID_PROD_LEN))
474 return -EFAULT;
475
476 ata_id_string(dev->id, buf, ATA_ID_FW_REV, ATA_ID_FW_REV_LEN);
477 if (copy_to_user(dst + ATA_ID_FW_REV, buf, ATA_ID_FW_REV_LEN))
478 return -EFAULT;
479
480 ata_id_string(dev->id, buf, ATA_ID_SERNO, ATA_ID_SERNO_LEN);
481 if (copy_to_user(dst + ATA_ID_SERNO, buf, ATA_ID_SERNO_LEN))
482 return -EFAULT;
483
484 return 0;
485 }
486
487 /**
488 * ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
489 * @scsidev: Device to which we are issuing command
490 * @arg: User provided data for issuing command
491 *
492 * LOCKING:
493 * Defined by the SCSI layer. We don't really care.
494 *
495 * RETURNS:
496 * Zero on success, negative errno on error.
497 */
498 int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
499 {
500 int rc = 0;
501 u8 scsi_cmd[MAX_COMMAND_SIZE];
502 u8 args[4], *argbuf = NULL, *sensebuf = NULL;
503 int argsize = 0;
504 enum dma_data_direction data_dir;
505 int cmd_result;
506
507 if (arg == NULL)
508 return -EINVAL;
509
510 if (copy_from_user(args, arg, sizeof(args)))
511 return -EFAULT;
512
513 sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
514 if (!sensebuf)
515 return -ENOMEM;
516
517 memset(scsi_cmd, 0, sizeof(scsi_cmd));
518
519 if (args[3]) {
520 argsize = ATA_SECT_SIZE * args[3];
521 argbuf = kmalloc(argsize, GFP_KERNEL);
522 if (argbuf == NULL) {
523 rc = -ENOMEM;
524 goto error;
525 }
526
527 scsi_cmd[1] = (4 << 1); /* PIO Data-in */
528 scsi_cmd[2] = 0x0e; /* no off.line or cc, read from dev,
529 block count in sector count field */
530 data_dir = DMA_FROM_DEVICE;
531 } else {
532 scsi_cmd[1] = (3 << 1); /* Non-data */
533 scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
534 data_dir = DMA_NONE;
535 }
536
537 scsi_cmd[0] = ATA_16;
538
539 scsi_cmd[4] = args[2];
540 if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */
541 scsi_cmd[6] = args[3];
542 scsi_cmd[8] = args[1];
543 scsi_cmd[10] = 0x4f;
544 scsi_cmd[12] = 0xc2;
545 } else {
546 scsi_cmd[6] = args[1];
547 }
548 scsi_cmd[14] = args[0];
549
550 /* Good values for timeout and retries? Values below
551 from scsi_ioctl_send_command() for default case... */
552 cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
553 sensebuf, (10*HZ), 5, 0, NULL);
554
555 if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
556 u8 *desc = sensebuf + 8;
557 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
558
559 /* If we set cc then ATA pass-through will cause a
560 * check condition even if no error. Filter that. */
561 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
562 struct scsi_sense_hdr sshdr;
563 scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
564 &sshdr);
565 if (sshdr.sense_key == RECOVERED_ERROR &&
566 sshdr.asc == 0 && sshdr.ascq == 0x1d)
567 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
568 }
569
570 /* Send userspace a few ATA registers (same as drivers/ide) */
571 if (sensebuf[0] == 0x72 && /* format is "descriptor" */
572 desc[0] == 0x09) { /* code is "ATA Descriptor" */
573 args[0] = desc[13]; /* status */
574 args[1] = desc[3]; /* error */
575 args[2] = desc[5]; /* sector count (0:7) */
576 if (copy_to_user(arg, args, sizeof(args)))
577 rc = -EFAULT;
578 }
579 }
580
581
582 if (cmd_result) {
583 rc = -EIO;
584 goto error;
585 }
586
587 if ((argbuf)
588 && copy_to_user(arg + sizeof(args), argbuf, argsize))
589 rc = -EFAULT;
590 error:
591 kfree(sensebuf);
592 kfree(argbuf);
593 return rc;
594 }
595
596 /**
597 * ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
598 * @scsidev: Device to which we are issuing command
599 * @arg: User provided data for issuing command
600 *
601 * LOCKING:
602 * Defined by the SCSI layer. We don't really care.
603 *
604 * RETURNS:
605 * Zero on success, negative errno on error.
606 */
607 int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
608 {
609 int rc = 0;
610 u8 scsi_cmd[MAX_COMMAND_SIZE];
611 u8 args[7], *sensebuf = NULL;
612 int cmd_result;
613
614 if (arg == NULL)
615 return -EINVAL;
616
617 if (copy_from_user(args, arg, sizeof(args)))
618 return -EFAULT;
619
620 sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
621 if (!sensebuf)
622 return -ENOMEM;
623
624 memset(scsi_cmd, 0, sizeof(scsi_cmd));
625 scsi_cmd[0] = ATA_16;
626 scsi_cmd[1] = (3 << 1); /* Non-data */
627 scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */
628 scsi_cmd[4] = args[1];
629 scsi_cmd[6] = args[2];
630 scsi_cmd[8] = args[3];
631 scsi_cmd[10] = args[4];
632 scsi_cmd[12] = args[5];
633 scsi_cmd[13] = args[6] & 0x4f;
634 scsi_cmd[14] = args[0];
635
636 /* Good values for timeout and retries? Values below
637 from scsi_ioctl_send_command() for default case... */
638 cmd_result = scsi_execute(scsidev, scsi_cmd, DMA_NONE, NULL, 0,
639 sensebuf, (10*HZ), 5, 0, NULL);
640
641 if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
642 u8 *desc = sensebuf + 8;
643 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
644
645 /* If we set cc then ATA pass-through will cause a
646 * check condition even if no error. Filter that. */
647 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
648 struct scsi_sense_hdr sshdr;
649 scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
650 &sshdr);
651 if (sshdr.sense_key == RECOVERED_ERROR &&
652 sshdr.asc == 0 && sshdr.ascq == 0x1d)
653 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
654 }
655
656 /* Send userspace ATA registers */
657 if (sensebuf[0] == 0x72 && /* format is "descriptor" */
658 desc[0] == 0x09) {/* code is "ATA Descriptor" */
659 args[0] = desc[13]; /* status */
660 args[1] = desc[3]; /* error */
661 args[2] = desc[5]; /* sector count (0:7) */
662 args[3] = desc[7]; /* lbal */
663 args[4] = desc[9]; /* lbam */
664 args[5] = desc[11]; /* lbah */
665 args[6] = desc[12]; /* select */
666 if (copy_to_user(arg, args, sizeof(args)))
667 rc = -EFAULT;
668 }
669 }
670
671 if (cmd_result) {
672 rc = -EIO;
673 goto error;
674 }
675
676 error:
677 kfree(sensebuf);
678 return rc;
679 }
680
681 static int ata_ioc32(struct ata_port *ap)
682 {
683 if (ap->flags & ATA_FLAG_PIO_DMA)
684 return 1;
685 if (ap->pflags & ATA_PFLAG_PIO32)
686 return 1;
687 return 0;
688 }
689
690 int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *scsidev,
691 int cmd, void __user *arg)
692 {
693 int val = -EINVAL, rc = -EINVAL;
694 unsigned long flags;
695
696 switch (cmd) {
697 case ATA_IOC_GET_IO32:
698 spin_lock_irqsave(ap->lock, flags);
699 val = ata_ioc32(ap);
700 spin_unlock_irqrestore(ap->lock, flags);
701 if (copy_to_user(arg, &val, 1))
702 return -EFAULT;
703 return 0;
704
705 case ATA_IOC_SET_IO32:
706 val = (unsigned long) arg;
707 rc = 0;
708 spin_lock_irqsave(ap->lock, flags);
709 if (ap->pflags & ATA_PFLAG_PIO32CHANGE) {
710 if (val)
711 ap->pflags |= ATA_PFLAG_PIO32;
712 else
713 ap->pflags &= ~ATA_PFLAG_PIO32;
714 } else {
715 if (val != ata_ioc32(ap))
716 rc = -EINVAL;
717 }
718 spin_unlock_irqrestore(ap->lock, flags);
719 return rc;
720
721 case HDIO_GET_IDENTITY:
722 return ata_get_identity(ap, scsidev, arg);
723
724 case HDIO_DRIVE_CMD:
725 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
726 return -EACCES;
727 return ata_cmd_ioctl(scsidev, arg);
728
729 case HDIO_DRIVE_TASK:
730 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
731 return -EACCES;
732 return ata_task_ioctl(scsidev, arg);
733
734 default:
735 rc = -ENOTTY;
736 break;
737 }
738
739 return rc;
740 }
741 EXPORT_SYMBOL_GPL(ata_sas_scsi_ioctl);
742
743 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
744 {
745 return ata_sas_scsi_ioctl(ata_shost_to_port(scsidev->host),
746 scsidev, cmd, arg);
747 }
748 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
749
750 /**
751 * ata_scsi_qc_new - acquire new ata_queued_cmd reference
752 * @dev: ATA device to which the new command is attached
753 * @cmd: SCSI command that originated this ATA command
754 *
755 * Obtain a reference to an unused ata_queued_cmd structure,
756 * which is the basic libata structure representing a single
757 * ATA command sent to the hardware.
758 *
759 * If a command was available, fill in the SCSI-specific
760 * portions of the structure with information on the
761 * current command.
762 *
763 * LOCKING:
764 * spin_lock_irqsave(host lock)
765 *
766 * RETURNS:
767 * Command allocated, or %NULL if none available.
768 */
769 static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
770 struct scsi_cmnd *cmd)
771 {
772 struct ata_queued_cmd *qc;
773
774 qc = ata_qc_new_init(dev, cmd->request->tag);
775 if (qc) {
776 qc->scsicmd = cmd;
777 qc->scsidone = cmd->scsi_done;
778
779 qc->sg = scsi_sglist(cmd);
780 qc->n_elem = scsi_sg_count(cmd);
781 } else {
782 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
783 cmd->scsi_done(cmd);
784 }
785
786 return qc;
787 }
788
789 static void ata_qc_set_pc_nbytes(struct ata_queued_cmd *qc)
790 {
791 struct scsi_cmnd *scmd = qc->scsicmd;
792
793 qc->extrabytes = scmd->request->extra_len;
794 qc->nbytes = scsi_bufflen(scmd) + qc->extrabytes;
795 }
796
797 /**
798 * ata_dump_status - user friendly display of error info
799 * @id: id of the port in question
800 * @tf: ptr to filled out taskfile
801 *
802 * Decode and dump the ATA error/status registers for the user so
803 * that they have some idea what really happened at the non
804 * make-believe layer.
805 *
806 * LOCKING:
807 * inherited from caller
808 */
809 static void ata_dump_status(unsigned id, struct ata_taskfile *tf)
810 {
811 u8 stat = tf->command, err = tf->feature;
812
813 printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
814 if (stat & ATA_BUSY) {
815 printk("Busy }\n"); /* Data is not valid in this case */
816 } else {
817 if (stat & ATA_DRDY) printk("DriveReady ");
818 if (stat & ATA_DF) printk("DeviceFault ");
819 if (stat & ATA_DSC) printk("SeekComplete ");
820 if (stat & ATA_DRQ) printk("DataRequest ");
821 if (stat & ATA_CORR) printk("CorrectedError ");
822 if (stat & ATA_SENSE) printk("Sense ");
823 if (stat & ATA_ERR) printk("Error ");
824 printk("}\n");
825
826 if (err) {
827 printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
828 if (err & ATA_ABORTED) printk("DriveStatusError ");
829 if (err & ATA_ICRC) {
830 if (err & ATA_ABORTED)
831 printk("BadCRC ");
832 else printk("Sector ");
833 }
834 if (err & ATA_UNC) printk("UncorrectableError ");
835 if (err & ATA_IDNF) printk("SectorIdNotFound ");
836 if (err & ATA_TRK0NF) printk("TrackZeroNotFound ");
837 if (err & ATA_AMNF) printk("AddrMarkNotFound ");
838 printk("}\n");
839 }
840 }
841 }
842
843 /**
844 * ata_to_sense_error - convert ATA error to SCSI error
845 * @id: ATA device number
846 * @drv_stat: value contained in ATA status register
847 * @drv_err: value contained in ATA error register
848 * @sk: the sense key we'll fill out
849 * @asc: the additional sense code we'll fill out
850 * @ascq: the additional sense code qualifier we'll fill out
851 * @verbose: be verbose
852 *
853 * Converts an ATA error into a SCSI error. Fill out pointers to
854 * SK, ASC, and ASCQ bytes for later use in fixed or descriptor
855 * format sense blocks.
856 *
857 * LOCKING:
858 * spin_lock_irqsave(host lock)
859 */
860 static void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk,
861 u8 *asc, u8 *ascq, int verbose)
862 {
863 int i;
864
865 /* Based on the 3ware driver translation table */
866 static const unsigned char sense_table[][4] = {
867 /* BBD|ECC|ID|MAR */
868 {0xd1, ABORTED_COMMAND, 0x00, 0x00},
869 // Device busy Aborted command
870 /* BBD|ECC|ID */
871 {0xd0, ABORTED_COMMAND, 0x00, 0x00},
872 // Device busy Aborted command
873 /* ECC|MC|MARK */
874 {0x61, HARDWARE_ERROR, 0x00, 0x00},
875 // Device fault Hardware error
876 /* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
877 {0x84, ABORTED_COMMAND, 0x47, 0x00},
878 // Data CRC error SCSI parity error
879 /* MC|ID|ABRT|TRK0|MARK */
880 {0x37, NOT_READY, 0x04, 0x00},
881 // Unit offline Not ready
882 /* MCR|MARK */
883 {0x09, NOT_READY, 0x04, 0x00},
884 // Unrecovered disk error Not ready
885 /* Bad address mark */
886 {0x01, MEDIUM_ERROR, 0x13, 0x00},
887 // Address mark not found for data field
888 /* TRK0 - Track 0 not found */
889 {0x02, HARDWARE_ERROR, 0x00, 0x00},
890 // Hardware error
891 /* Abort: 0x04 is not translated here, see below */
892 /* Media change request */
893 {0x08, NOT_READY, 0x04, 0x00},
894 // FIXME: faking offline
895 /* SRV/IDNF - ID not found */
896 {0x10, ILLEGAL_REQUEST, 0x21, 0x00},
897 // Logical address out of range
898 /* MC - Media Changed */
899 {0x20, UNIT_ATTENTION, 0x28, 0x00},
900 // Not ready to ready change, medium may have changed
901 /* ECC - Uncorrectable ECC error */
902 {0x40, MEDIUM_ERROR, 0x11, 0x04},
903 // Unrecovered read error
904 /* BBD - block marked bad */
905 {0x80, MEDIUM_ERROR, 0x11, 0x04},
906 // Block marked bad Medium error, unrecovered read error
907 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
908 };
909 static const unsigned char stat_table[][4] = {
910 /* Must be first because BUSY means no other bits valid */
911 {0x80, ABORTED_COMMAND, 0x47, 0x00},
912 // Busy, fake parity for now
913 {0x40, ILLEGAL_REQUEST, 0x21, 0x04},
914 // Device ready, unaligned write command
915 {0x20, HARDWARE_ERROR, 0x44, 0x00},
916 // Device fault, internal target failure
917 {0x08, ABORTED_COMMAND, 0x47, 0x00},
918 // Timed out in xfer, fake parity for now
919 {0x04, RECOVERED_ERROR, 0x11, 0x00},
920 // Recovered ECC error Medium error, recovered
921 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
922 };
923
924 /*
925 * Is this an error we can process/parse
926 */
927 if (drv_stat & ATA_BUSY) {
928 drv_err = 0; /* Ignore the err bits, they're invalid */
929 }
930
931 if (drv_err) {
932 /* Look for drv_err */
933 for (i = 0; sense_table[i][0] != 0xFF; i++) {
934 /* Look for best matches first */
935 if ((sense_table[i][0] & drv_err) ==
936 sense_table[i][0]) {
937 *sk = sense_table[i][1];
938 *asc = sense_table[i][2];
939 *ascq = sense_table[i][3];
940 goto translate_done;
941 }
942 }
943 }
944
945 /*
946 * Fall back to interpreting status bits. Note that if the drv_err
947 * has only the ABRT bit set, we decode drv_stat. ABRT by itself
948 * is not descriptive enough.
949 */
950 for (i = 0; stat_table[i][0] != 0xFF; i++) {
951 if (stat_table[i][0] & drv_stat) {
952 *sk = stat_table[i][1];
953 *asc = stat_table[i][2];
954 *ascq = stat_table[i][3];
955 goto translate_done;
956 }
957 }
958
959 /*
960 * We need a sensible error return here, which is tricky, and one
961 * that won't cause people to do things like return a disk wrongly.
962 */
963 *sk = ABORTED_COMMAND;
964 *asc = 0x00;
965 *ascq = 0x00;
966
967 translate_done:
968 if (verbose)
969 printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x "
970 "to SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n",
971 id, drv_stat, drv_err, *sk, *asc, *ascq);
972 return;
973 }
974
975 /*
976 * ata_gen_passthru_sense - Generate check condition sense block.
977 * @qc: Command that completed.
978 *
979 * This function is specific to the ATA descriptor format sense
980 * block specified for the ATA pass through commands. Regardless
981 * of whether the command errored or not, return a sense
982 * block. Copy all controller registers into the sense
983 * block. If there was no error, we get the request from an ATA
984 * passthrough command, so we use the following sense data:
985 * sk = RECOVERED ERROR
986 * asc,ascq = ATA PASS-THROUGH INFORMATION AVAILABLE
987 *
988 *
989 * LOCKING:
990 * None.
991 */
992 static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
993 {
994 struct scsi_cmnd *cmd = qc->scsicmd;
995 struct ata_taskfile *tf = &qc->result_tf;
996 unsigned char *sb = cmd->sense_buffer;
997 unsigned char *desc = sb + 8;
998 int verbose = qc->ap->ops->error_handler == NULL;
999
1000 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
1001
1002 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
1003
1004 /*
1005 * Use ata_to_sense_error() to map status register bits
1006 * onto sense key, asc & ascq.
1007 */
1008 if (qc->err_mask ||
1009 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
1010 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
1011 &sb[1], &sb[2], &sb[3], verbose);
1012 sb[1] &= 0x0f;
1013 } else {
1014 sb[1] = RECOVERED_ERROR;
1015 sb[2] = 0;
1016 sb[3] = 0x1D;
1017 }
1018
1019 /*
1020 * Sense data is current and format is descriptor.
1021 */
1022 sb[0] = 0x72;
1023
1024 desc[0] = 0x09;
1025
1026 /* set length of additional sense data */
1027 sb[7] = 14;
1028 desc[1] = 12;
1029
1030 /*
1031 * Copy registers into sense buffer.
1032 */
1033 desc[2] = 0x00;
1034 desc[3] = tf->feature; /* == error reg */
1035 desc[5] = tf->nsect;
1036 desc[7] = tf->lbal;
1037 desc[9] = tf->lbam;
1038 desc[11] = tf->lbah;
1039 desc[12] = tf->device;
1040 desc[13] = tf->command; /* == status reg */
1041
1042 /*
1043 * Fill in Extend bit, and the high order bytes
1044 * if applicable.
1045 */
1046 if (tf->flags & ATA_TFLAG_LBA48) {
1047 desc[2] |= 0x01;
1048 desc[4] = tf->hob_nsect;
1049 desc[6] = tf->hob_lbal;
1050 desc[8] = tf->hob_lbam;
1051 desc[10] = tf->hob_lbah;
1052 }
1053 }
1054
1055 /**
1056 * ata_gen_ata_sense - generate a SCSI fixed sense block
1057 * @qc: Command that we are erroring out
1058 *
1059 * Generate sense block for a failed ATA command @qc. Descriptor
1060 * format is used to accommodate LBA48 block address.
1061 *
1062 * LOCKING:
1063 * None.
1064 */
1065 static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
1066 {
1067 struct ata_device *dev = qc->dev;
1068 struct scsi_cmnd *cmd = qc->scsicmd;
1069 struct ata_taskfile *tf = &qc->result_tf;
1070 unsigned char *sb = cmd->sense_buffer;
1071 unsigned char *desc = sb + 8;
1072 int verbose = qc->ap->ops->error_handler == NULL;
1073 u64 block;
1074
1075 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
1076
1077 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
1078
1079 /* sense data is current and format is descriptor */
1080 sb[0] = 0x72;
1081
1082 /* Use ata_to_sense_error() to map status register bits
1083 * onto sense key, asc & ascq.
1084 */
1085 if (qc->err_mask ||
1086 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
1087 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
1088 &sb[1], &sb[2], &sb[3], verbose);
1089 sb[1] &= 0x0f;
1090 }
1091
1092 block = ata_tf_read_block(&qc->result_tf, dev);
1093
1094 /* information sense data descriptor */
1095 sb[7] = 12;
1096 desc[0] = 0x00;
1097 desc[1] = 10;
1098
1099 desc[2] |= 0x80; /* valid */
1100 desc[6] = block >> 40;
1101 desc[7] = block >> 32;
1102 desc[8] = block >> 24;
1103 desc[9] = block >> 16;
1104 desc[10] = block >> 8;
1105 desc[11] = block;
1106 }
1107
1108 static void ata_scsi_sdev_config(struct scsi_device *sdev)
1109 {
1110 sdev->use_10_for_rw = 1;
1111 sdev->use_10_for_ms = 1;
1112 sdev->no_report_opcodes = 1;
1113 sdev->no_write_same = 1;
1114
1115 /* Schedule policy is determined by ->qc_defer() callback and
1116 * it needs to see every deferred qc. Set dev_blocked to 1 to
1117 * prevent SCSI midlayer from automatically deferring
1118 * requests.
1119 */
1120 sdev->max_device_blocked = 1;
1121 }
1122
1123 /**
1124 * atapi_drain_needed - Check whether data transfer may overflow
1125 * @rq: request to be checked
1126 *
1127 * ATAPI commands which transfer variable length data to host
1128 * might overflow due to application error or hardare bug. This
1129 * function checks whether overflow should be drained and ignored
1130 * for @request.
1131 *
1132 * LOCKING:
1133 * None.
1134 *
1135 * RETURNS:
1136 * 1 if ; otherwise, 0.
1137 */
1138 static int atapi_drain_needed(struct request *rq)
1139 {
1140 if (likely(rq->cmd_type != REQ_TYPE_BLOCK_PC))
1141 return 0;
1142
1143 if (!blk_rq_bytes(rq) || (rq->cmd_flags & REQ_WRITE))
1144 return 0;
1145
1146 return atapi_cmd_type(rq->cmd[0]) == ATAPI_MISC;
1147 }
1148
1149 static int ata_scsi_dev_config(struct scsi_device *sdev,
1150 struct ata_device *dev)
1151 {
1152 struct request_queue *q = sdev->request_queue;
1153
1154 if (!ata_id_has_unload(dev->id))
1155 dev->flags |= ATA_DFLAG_NO_UNLOAD;
1156
1157 /* configure max sectors */
1158 blk_queue_max_hw_sectors(q, dev->max_sectors);
1159
1160 if (dev->class == ATA_DEV_ATAPI) {
1161 void *buf;
1162
1163 sdev->sector_size = ATA_SECT_SIZE;
1164
1165 /* set DMA padding */
1166 blk_queue_update_dma_pad(q, ATA_DMA_PAD_SZ - 1);
1167
1168 /* configure draining */
1169 buf = kmalloc(ATAPI_MAX_DRAIN, q->bounce_gfp | GFP_KERNEL);
1170 if (!buf) {
1171 ata_dev_err(dev, "drain buffer allocation failed\n");
1172 return -ENOMEM;
1173 }
1174
1175 blk_queue_dma_drain(q, atapi_drain_needed, buf, ATAPI_MAX_DRAIN);
1176 } else {
1177 sdev->sector_size = ata_id_logical_sector_size(dev->id);
1178 sdev->manage_start_stop = 1;
1179 }
1180
1181 /*
1182 * ata_pio_sectors() expects buffer for each sector to not cross
1183 * page boundary. Enforce it by requiring buffers to be sector
1184 * aligned, which works iff sector_size is not larger than
1185 * PAGE_SIZE. ATAPI devices also need the alignment as
1186 * IDENTIFY_PACKET is executed as ATA_PROT_PIO.
1187 */
1188 if (sdev->sector_size > PAGE_SIZE)
1189 ata_dev_warn(dev,
1190 "sector_size=%u > PAGE_SIZE, PIO may malfunction\n",
1191 sdev->sector_size);
1192
1193 blk_queue_update_dma_alignment(q, sdev->sector_size - 1);
1194
1195 if (dev->flags & ATA_DFLAG_AN)
1196 set_bit(SDEV_EVT_MEDIA_CHANGE, sdev->supported_events);
1197
1198 if (dev->flags & ATA_DFLAG_NCQ) {
1199 int depth;
1200
1201 depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
1202 depth = min(ATA_MAX_QUEUE - 1, depth);
1203 scsi_change_queue_depth(sdev, depth);
1204 }
1205
1206 blk_queue_flush_queueable(q, false);
1207
1208 dev->sdev = sdev;
1209 return 0;
1210 }
1211
1212 /**
1213 * ata_scsi_slave_config - Set SCSI device attributes
1214 * @sdev: SCSI device to examine
1215 *
1216 * This is called before we actually start reading
1217 * and writing to the device, to configure certain
1218 * SCSI mid-layer behaviors.
1219 *
1220 * LOCKING:
1221 * Defined by SCSI layer. We don't really care.
1222 */
1223
1224 int ata_scsi_slave_config(struct scsi_device *sdev)
1225 {
1226 struct ata_port *ap = ata_shost_to_port(sdev->host);
1227 struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
1228 int rc = 0;
1229
1230 ata_scsi_sdev_config(sdev);
1231
1232 if (dev)
1233 rc = ata_scsi_dev_config(sdev, dev);
1234
1235 return rc;
1236 }
1237
1238 /**
1239 * ata_scsi_slave_destroy - SCSI device is about to be destroyed
1240 * @sdev: SCSI device to be destroyed
1241 *
1242 * @sdev is about to be destroyed for hot/warm unplugging. If
1243 * this unplugging was initiated by libata as indicated by NULL
1244 * dev->sdev, this function doesn't have to do anything.
1245 * Otherwise, SCSI layer initiated warm-unplug is in progress.
1246 * Clear dev->sdev, schedule the device for ATA detach and invoke
1247 * EH.
1248 *
1249 * LOCKING:
1250 * Defined by SCSI layer. We don't really care.
1251 */
1252 void ata_scsi_slave_destroy(struct scsi_device *sdev)
1253 {
1254 struct ata_port *ap = ata_shost_to_port(sdev->host);
1255 struct request_queue *q = sdev->request_queue;
1256 unsigned long flags;
1257 struct ata_device *dev;
1258
1259 if (!ap->ops->error_handler)
1260 return;
1261
1262 spin_lock_irqsave(ap->lock, flags);
1263 dev = __ata_scsi_find_dev(ap, sdev);
1264 if (dev && dev->sdev) {
1265 /* SCSI device already in CANCEL state, no need to offline it */
1266 dev->sdev = NULL;
1267 dev->flags |= ATA_DFLAG_DETACH;
1268 ata_port_schedule_eh(ap);
1269 }
1270 spin_unlock_irqrestore(ap->lock, flags);
1271
1272 kfree(q->dma_drain_buffer);
1273 q->dma_drain_buffer = NULL;
1274 q->dma_drain_size = 0;
1275 }
1276
1277 /**
1278 * __ata_change_queue_depth - helper for ata_scsi_change_queue_depth
1279 * @ap: ATA port to which the device change the queue depth
1280 * @sdev: SCSI device to configure queue depth for
1281 * @queue_depth: new queue depth
1282 *
1283 * libsas and libata have different approaches for associating a sdev to
1284 * its ata_port.
1285 *
1286 */
1287 int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
1288 int queue_depth)
1289 {
1290 struct ata_device *dev;
1291 unsigned long flags;
1292
1293 if (queue_depth < 1 || queue_depth == sdev->queue_depth)
1294 return sdev->queue_depth;
1295
1296 dev = ata_scsi_find_dev(ap, sdev);
1297 if (!dev || !ata_dev_enabled(dev))
1298 return sdev->queue_depth;
1299
1300 /* NCQ enabled? */
1301 spin_lock_irqsave(ap->lock, flags);
1302 dev->flags &= ~ATA_DFLAG_NCQ_OFF;
1303 if (queue_depth == 1 || !ata_ncq_enabled(dev)) {
1304 dev->flags |= ATA_DFLAG_NCQ_OFF;
1305 queue_depth = 1;
1306 }
1307 spin_unlock_irqrestore(ap->lock, flags);
1308
1309 /* limit and apply queue depth */
1310 queue_depth = min(queue_depth, sdev->host->can_queue);
1311 queue_depth = min(queue_depth, ata_id_queue_depth(dev->id));
1312 queue_depth = min(queue_depth, ATA_MAX_QUEUE - 1);
1313
1314 if (sdev->queue_depth == queue_depth)
1315 return -EINVAL;
1316
1317 return scsi_change_queue_depth(sdev, queue_depth);
1318 }
1319
1320 /**
1321 * ata_scsi_change_queue_depth - SCSI callback for queue depth config
1322 * @sdev: SCSI device to configure queue depth for
1323 * @queue_depth: new queue depth
1324 *
1325 * This is libata standard hostt->change_queue_depth callback.
1326 * SCSI will call into this callback when user tries to set queue
1327 * depth via sysfs.
1328 *
1329 * LOCKING:
1330 * SCSI layer (we don't care)
1331 *
1332 * RETURNS:
1333 * Newly configured queue depth.
1334 */
1335 int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
1336 {
1337 struct ata_port *ap = ata_shost_to_port(sdev->host);
1338
1339 return __ata_change_queue_depth(ap, sdev, queue_depth);
1340 }
1341
1342 /**
1343 * ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
1344 * @qc: Storage for translated ATA taskfile
1345 *
1346 * Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
1347 * (to start). Perhaps these commands should be preceded by
1348 * CHECK POWER MODE to see what power mode the device is already in.
1349 * [See SAT revision 5 at www.t10.org]
1350 *
1351 * LOCKING:
1352 * spin_lock_irqsave(host lock)
1353 *
1354 * RETURNS:
1355 * Zero on success, non-zero on error.
1356 */
1357 static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
1358 {
1359 struct scsi_cmnd *scmd = qc->scsicmd;
1360 struct ata_taskfile *tf = &qc->tf;
1361 const u8 *cdb = scmd->cmnd;
1362
1363 if (scmd->cmd_len < 5)
1364 goto invalid_fld;
1365
1366 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1367 tf->protocol = ATA_PROT_NODATA;
1368 if (cdb[1] & 0x1) {
1369 ; /* ignore IMMED bit, violates sat-r05 */
1370 }
1371 if (cdb[4] & 0x2)
1372 goto invalid_fld; /* LOEJ bit set not supported */
1373 if (((cdb[4] >> 4) & 0xf) != 0)
1374 goto invalid_fld; /* power conditions not supported */
1375
1376 if (cdb[4] & 0x1) {
1377 tf->nsect = 1; /* 1 sector, lba=0 */
1378
1379 if (qc->dev->flags & ATA_DFLAG_LBA) {
1380 tf->flags |= ATA_TFLAG_LBA;
1381
1382 tf->lbah = 0x0;
1383 tf->lbam = 0x0;
1384 tf->lbal = 0x0;
1385 tf->device |= ATA_LBA;
1386 } else {
1387 /* CHS */
1388 tf->lbal = 0x1; /* sect */
1389 tf->lbam = 0x0; /* cyl low */
1390 tf->lbah = 0x0; /* cyl high */
1391 }
1392
1393 tf->command = ATA_CMD_VERIFY; /* READ VERIFY */
1394 } else {
1395 /* Some odd clown BIOSen issue spindown on power off (ACPI S4
1396 * or S5) causing some drives to spin up and down again.
1397 */
1398 if ((qc->ap->flags & ATA_FLAG_NO_POWEROFF_SPINDOWN) &&
1399 system_state == SYSTEM_POWER_OFF)
1400 goto skip;
1401
1402 if ((qc->ap->flags & ATA_FLAG_NO_HIBERNATE_SPINDOWN) &&
1403 system_entering_hibernation())
1404 goto skip;
1405
1406 /* Issue ATA STANDBY IMMEDIATE command */
1407 tf->command = ATA_CMD_STANDBYNOW1;
1408 }
1409
1410 /*
1411 * Standby and Idle condition timers could be implemented but that
1412 * would require libata to implement the Power condition mode page
1413 * and allow the user to change it. Changing mode pages requires
1414 * MODE SELECT to be implemented.
1415 */
1416
1417 return 0;
1418
1419 invalid_fld:
1420 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1421 /* "Invalid field in cbd" */
1422 return 1;
1423 skip:
1424 scmd->result = SAM_STAT_GOOD;
1425 return 1;
1426 }
1427
1428
1429 /**
1430 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
1431 * @qc: Storage for translated ATA taskfile
1432 *
1433 * Sets up an ATA taskfile to issue FLUSH CACHE or
1434 * FLUSH CACHE EXT.
1435 *
1436 * LOCKING:
1437 * spin_lock_irqsave(host lock)
1438 *
1439 * RETURNS:
1440 * Zero on success, non-zero on error.
1441 */
1442 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc)
1443 {
1444 struct ata_taskfile *tf = &qc->tf;
1445
1446 tf->flags |= ATA_TFLAG_DEVICE;
1447 tf->protocol = ATA_PROT_NODATA;
1448
1449 if (qc->dev->flags & ATA_DFLAG_FLUSH_EXT)
1450 tf->command = ATA_CMD_FLUSH_EXT;
1451 else
1452 tf->command = ATA_CMD_FLUSH;
1453
1454 /* flush is critical for IO integrity, consider it an IO command */
1455 qc->flags |= ATA_QCFLAG_IO;
1456
1457 return 0;
1458 }
1459
1460 /**
1461 * scsi_6_lba_len - Get LBA and transfer length
1462 * @cdb: SCSI command to translate
1463 *
1464 * Calculate LBA and transfer length for 6-byte commands.
1465 *
1466 * RETURNS:
1467 * @plba: the LBA
1468 * @plen: the transfer length
1469 */
1470 static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1471 {
1472 u64 lba = 0;
1473 u32 len;
1474
1475 VPRINTK("six-byte command\n");
1476
1477 lba |= ((u64)(cdb[1] & 0x1f)) << 16;
1478 lba |= ((u64)cdb[2]) << 8;
1479 lba |= ((u64)cdb[3]);
1480
1481 len = cdb[4];
1482
1483 *plba = lba;
1484 *plen = len;
1485 }
1486
1487 /**
1488 * scsi_10_lba_len - Get LBA and transfer length
1489 * @cdb: SCSI command to translate
1490 *
1491 * Calculate LBA and transfer length for 10-byte commands.
1492 *
1493 * RETURNS:
1494 * @plba: the LBA
1495 * @plen: the transfer length
1496 */
1497 static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1498 {
1499 u64 lba = 0;
1500 u32 len = 0;
1501
1502 VPRINTK("ten-byte command\n");
1503
1504 lba |= ((u64)cdb[2]) << 24;
1505 lba |= ((u64)cdb[3]) << 16;
1506 lba |= ((u64)cdb[4]) << 8;
1507 lba |= ((u64)cdb[5]);
1508
1509 len |= ((u32)cdb[7]) << 8;
1510 len |= ((u32)cdb[8]);
1511
1512 *plba = lba;
1513 *plen = len;
1514 }
1515
1516 /**
1517 * scsi_16_lba_len - Get LBA and transfer length
1518 * @cdb: SCSI command to translate
1519 *
1520 * Calculate LBA and transfer length for 16-byte commands.
1521 *
1522 * RETURNS:
1523 * @plba: the LBA
1524 * @plen: the transfer length
1525 */
1526 static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1527 {
1528 u64 lba = 0;
1529 u32 len = 0;
1530
1531 VPRINTK("sixteen-byte command\n");
1532
1533 lba |= ((u64)cdb[2]) << 56;
1534 lba |= ((u64)cdb[3]) << 48;
1535 lba |= ((u64)cdb[4]) << 40;
1536 lba |= ((u64)cdb[5]) << 32;
1537 lba |= ((u64)cdb[6]) << 24;
1538 lba |= ((u64)cdb[7]) << 16;
1539 lba |= ((u64)cdb[8]) << 8;
1540 lba |= ((u64)cdb[9]);
1541
1542 len |= ((u32)cdb[10]) << 24;
1543 len |= ((u32)cdb[11]) << 16;
1544 len |= ((u32)cdb[12]) << 8;
1545 len |= ((u32)cdb[13]);
1546
1547 *plba = lba;
1548 *plen = len;
1549 }
1550
1551 /**
1552 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
1553 * @qc: Storage for translated ATA taskfile
1554 *
1555 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
1556 *
1557 * LOCKING:
1558 * spin_lock_irqsave(host lock)
1559 *
1560 * RETURNS:
1561 * Zero on success, non-zero on error.
1562 */
1563 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
1564 {
1565 struct scsi_cmnd *scmd = qc->scsicmd;
1566 struct ata_taskfile *tf = &qc->tf;
1567 struct ata_device *dev = qc->dev;
1568 u64 dev_sectors = qc->dev->n_sectors;
1569 const u8 *cdb = scmd->cmnd;
1570 u64 block;
1571 u32 n_block;
1572
1573 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1574 tf->protocol = ATA_PROT_NODATA;
1575
1576 if (cdb[0] == VERIFY) {
1577 if (scmd->cmd_len < 10)
1578 goto invalid_fld;
1579 scsi_10_lba_len(cdb, &block, &n_block);
1580 } else if (cdb[0] == VERIFY_16) {
1581 if (scmd->cmd_len < 16)
1582 goto invalid_fld;
1583 scsi_16_lba_len(cdb, &block, &n_block);
1584 } else
1585 goto invalid_fld;
1586
1587 if (!n_block)
1588 goto nothing_to_do;
1589 if (block >= dev_sectors)
1590 goto out_of_range;
1591 if ((block + n_block) > dev_sectors)
1592 goto out_of_range;
1593
1594 if (dev->flags & ATA_DFLAG_LBA) {
1595 tf->flags |= ATA_TFLAG_LBA;
1596
1597 if (lba_28_ok(block, n_block)) {
1598 /* use LBA28 */
1599 tf->command = ATA_CMD_VERIFY;
1600 tf->device |= (block >> 24) & 0xf;
1601 } else if (lba_48_ok(block, n_block)) {
1602 if (!(dev->flags & ATA_DFLAG_LBA48))
1603 goto out_of_range;
1604
1605 /* use LBA48 */
1606 tf->flags |= ATA_TFLAG_LBA48;
1607 tf->command = ATA_CMD_VERIFY_EXT;
1608
1609 tf->hob_nsect = (n_block >> 8) & 0xff;
1610
1611 tf->hob_lbah = (block >> 40) & 0xff;
1612 tf->hob_lbam = (block >> 32) & 0xff;
1613 tf->hob_lbal = (block >> 24) & 0xff;
1614 } else
1615 /* request too large even for LBA48 */
1616 goto out_of_range;
1617
1618 tf->nsect = n_block & 0xff;
1619
1620 tf->lbah = (block >> 16) & 0xff;
1621 tf->lbam = (block >> 8) & 0xff;
1622 tf->lbal = block & 0xff;
1623
1624 tf->device |= ATA_LBA;
1625 } else {
1626 /* CHS */
1627 u32 sect, head, cyl, track;
1628
1629 if (!lba_28_ok(block, n_block))
1630 goto out_of_range;
1631
1632 /* Convert LBA to CHS */
1633 track = (u32)block / dev->sectors;
1634 cyl = track / dev->heads;
1635 head = track % dev->heads;
1636 sect = (u32)block % dev->sectors + 1;
1637
1638 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1639 (u32)block, track, cyl, head, sect);
1640
1641 /* Check whether the converted CHS can fit.
1642 Cylinder: 0-65535
1643 Head: 0-15
1644 Sector: 1-255*/
1645 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
1646 goto out_of_range;
1647
1648 tf->command = ATA_CMD_VERIFY;
1649 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
1650 tf->lbal = sect;
1651 tf->lbam = cyl;
1652 tf->lbah = cyl >> 8;
1653 tf->device |= head;
1654 }
1655
1656 return 0;
1657
1658 invalid_fld:
1659 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1660 /* "Invalid field in cbd" */
1661 return 1;
1662
1663 out_of_range:
1664 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1665 /* "Logical Block Address out of range" */
1666 return 1;
1667
1668 nothing_to_do:
1669 scmd->result = SAM_STAT_GOOD;
1670 return 1;
1671 }
1672
1673 /**
1674 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
1675 * @qc: Storage for translated ATA taskfile
1676 *
1677 * Converts any of six SCSI read/write commands into the
1678 * ATA counterpart, including starting sector (LBA),
1679 * sector count, and taking into account the device's LBA48
1680 * support.
1681 *
1682 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
1683 * %WRITE_16 are currently supported.
1684 *
1685 * LOCKING:
1686 * spin_lock_irqsave(host lock)
1687 *
1688 * RETURNS:
1689 * Zero on success, non-zero on error.
1690 */
1691 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
1692 {
1693 struct scsi_cmnd *scmd = qc->scsicmd;
1694 const u8 *cdb = scmd->cmnd;
1695 unsigned int tf_flags = 0;
1696 u64 block;
1697 u32 n_block;
1698 int rc;
1699
1700 if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
1701 tf_flags |= ATA_TFLAG_WRITE;
1702
1703 /* Calculate the SCSI LBA, transfer length and FUA. */
1704 switch (cdb[0]) {
1705 case READ_10:
1706 case WRITE_10:
1707 if (unlikely(scmd->cmd_len < 10))
1708 goto invalid_fld;
1709 scsi_10_lba_len(cdb, &block, &n_block);
1710 if (cdb[1] & (1 << 3))
1711 tf_flags |= ATA_TFLAG_FUA;
1712 break;
1713 case READ_6:
1714 case WRITE_6:
1715 if (unlikely(scmd->cmd_len < 6))
1716 goto invalid_fld;
1717 scsi_6_lba_len(cdb, &block, &n_block);
1718
1719 /* for 6-byte r/w commands, transfer length 0
1720 * means 256 blocks of data, not 0 block.
1721 */
1722 if (!n_block)
1723 n_block = 256;
1724 break;
1725 case READ_16:
1726 case WRITE_16:
1727 if (unlikely(scmd->cmd_len < 16))
1728 goto invalid_fld;
1729 scsi_16_lba_len(cdb, &block, &n_block);
1730 if (cdb[1] & (1 << 3))
1731 tf_flags |= ATA_TFLAG_FUA;
1732 break;
1733 default:
1734 DPRINTK("no-byte command\n");
1735 goto invalid_fld;
1736 }
1737
1738 /* Check and compose ATA command */
1739 if (!n_block)
1740 /* For 10-byte and 16-byte SCSI R/W commands, transfer
1741 * length 0 means transfer 0 block of data.
1742 * However, for ATA R/W commands, sector count 0 means
1743 * 256 or 65536 sectors, not 0 sectors as in SCSI.
1744 *
1745 * WARNING: one or two older ATA drives treat 0 as 0...
1746 */
1747 goto nothing_to_do;
1748
1749 qc->flags |= ATA_QCFLAG_IO;
1750 qc->nbytes = n_block * scmd->device->sector_size;
1751
1752 rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
1753 qc->tag);
1754 if (likely(rc == 0))
1755 return 0;
1756
1757 if (rc == -ERANGE)
1758 goto out_of_range;
1759 /* treat all other errors as -EINVAL, fall through */
1760 invalid_fld:
1761 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1762 /* "Invalid field in cbd" */
1763 return 1;
1764
1765 out_of_range:
1766 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1767 /* "Logical Block Address out of range" */
1768 return 1;
1769
1770 nothing_to_do:
1771 scmd->result = SAM_STAT_GOOD;
1772 return 1;
1773 }
1774
1775 static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
1776 {
1777 struct ata_port *ap = qc->ap;
1778 struct scsi_cmnd *cmd = qc->scsicmd;
1779 u8 *cdb = cmd->cmnd;
1780 int need_sense = (qc->err_mask != 0);
1781
1782 /* For ATA pass thru (SAT) commands, generate a sense block if
1783 * user mandated it or if there's an error. Note that if we
1784 * generate because the user forced us to [CK_COND =1], a check
1785 * condition is generated and the ATA register values are returned
1786 * whether the command completed successfully or not. If there
1787 * was no error, we use the following sense data:
1788 * sk = RECOVERED ERROR
1789 * asc,ascq = ATA PASS-THROUGH INFORMATION AVAILABLE
1790 */
1791 if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
1792 ((cdb[2] & 0x20) || need_sense)) {
1793 ata_gen_passthru_sense(qc);
1794 } else {
1795 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
1796 cmd->result = SAM_STAT_CHECK_CONDITION;
1797 } else if (!need_sense) {
1798 cmd->result = SAM_STAT_GOOD;
1799 } else {
1800 /* TODO: decide which descriptor format to use
1801 * for 48b LBA devices and call that here
1802 * instead of the fixed desc, which is only
1803 * good for smaller LBA (and maybe CHS?)
1804 * devices.
1805 */
1806 ata_gen_ata_sense(qc);
1807 }
1808 }
1809
1810 if (need_sense && !ap->ops->error_handler)
1811 ata_dump_status(ap->print_id, &qc->result_tf);
1812
1813 qc->scsidone(cmd);
1814
1815 ata_qc_free(qc);
1816 }
1817
1818 /**
1819 * ata_scsi_translate - Translate then issue SCSI command to ATA device
1820 * @dev: ATA device to which the command is addressed
1821 * @cmd: SCSI command to execute
1822 * @xlat_func: Actor which translates @cmd to an ATA taskfile
1823 *
1824 * Our ->queuecommand() function has decided that the SCSI
1825 * command issued can be directly translated into an ATA
1826 * command, rather than handled internally.
1827 *
1828 * This function sets up an ata_queued_cmd structure for the
1829 * SCSI command, and sends that ata_queued_cmd to the hardware.
1830 *
1831 * The xlat_func argument (actor) returns 0 if ready to execute
1832 * ATA command, else 1 to finish translation. If 1 is returned
1833 * then cmd->result (and possibly cmd->sense_buffer) are assumed
1834 * to be set reflecting an error condition or clean (early)
1835 * termination.
1836 *
1837 * LOCKING:
1838 * spin_lock_irqsave(host lock)
1839 *
1840 * RETURNS:
1841 * 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
1842 * needs to be deferred.
1843 */
1844 static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
1845 ata_xlat_func_t xlat_func)
1846 {
1847 struct ata_port *ap = dev->link->ap;
1848 struct ata_queued_cmd *qc;
1849 int rc;
1850
1851 VPRINTK("ENTER\n");
1852
1853 qc = ata_scsi_qc_new(dev, cmd);
1854 if (!qc)
1855 goto err_mem;
1856
1857 /* data is present; dma-map it */
1858 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1859 cmd->sc_data_direction == DMA_TO_DEVICE) {
1860 if (unlikely(scsi_bufflen(cmd) < 1)) {
1861 ata_dev_warn(dev, "WARNING: zero len r/w req\n");
1862 goto err_did;
1863 }
1864
1865 ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
1866
1867 qc->dma_dir = cmd->sc_data_direction;
1868 }
1869
1870 qc->complete_fn = ata_scsi_qc_complete;
1871
1872 if (xlat_func(qc))
1873 goto early_finish;
1874
1875 if (ap->ops->qc_defer) {
1876 if ((rc = ap->ops->qc_defer(qc)))
1877 goto defer;
1878 }
1879
1880 /* select device, send command to hardware */
1881 ata_qc_issue(qc);
1882
1883 VPRINTK("EXIT\n");
1884 return 0;
1885
1886 early_finish:
1887 ata_qc_free(qc);
1888 cmd->scsi_done(cmd);
1889 DPRINTK("EXIT - early finish (good or error)\n");
1890 return 0;
1891
1892 err_did:
1893 ata_qc_free(qc);
1894 cmd->result = (DID_ERROR << 16);
1895 cmd->scsi_done(cmd);
1896 err_mem:
1897 DPRINTK("EXIT - internal\n");
1898 return 0;
1899
1900 defer:
1901 ata_qc_free(qc);
1902 DPRINTK("EXIT - defer\n");
1903 if (rc == ATA_DEFER_LINK)
1904 return SCSI_MLQUEUE_DEVICE_BUSY;
1905 else
1906 return SCSI_MLQUEUE_HOST_BUSY;
1907 }
1908
1909 /**
1910 * ata_scsi_rbuf_get - Map response buffer.
1911 * @cmd: SCSI command containing buffer to be mapped.
1912 * @flags: unsigned long variable to store irq enable status
1913 * @copy_in: copy in from user buffer
1914 *
1915 * Prepare buffer for simulated SCSI commands.
1916 *
1917 * LOCKING:
1918 * spin_lock_irqsave(ata_scsi_rbuf_lock) on success
1919 *
1920 * RETURNS:
1921 * Pointer to response buffer.
1922 */
1923 static void *ata_scsi_rbuf_get(struct scsi_cmnd *cmd, bool copy_in,
1924 unsigned long *flags)
1925 {
1926 spin_lock_irqsave(&ata_scsi_rbuf_lock, *flags);
1927
1928 memset(ata_scsi_rbuf, 0, ATA_SCSI_RBUF_SIZE);
1929 if (copy_in)
1930 sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
1931 ata_scsi_rbuf, ATA_SCSI_RBUF_SIZE);
1932 return ata_scsi_rbuf;
1933 }
1934
1935 /**
1936 * ata_scsi_rbuf_put - Unmap response buffer.
1937 * @cmd: SCSI command containing buffer to be unmapped.
1938 * @copy_out: copy out result
1939 * @flags: @flags passed to ata_scsi_rbuf_get()
1940 *
1941 * Returns rbuf buffer. The result is copied to @cmd's buffer if
1942 * @copy_back is true.
1943 *
1944 * LOCKING:
1945 * Unlocks ata_scsi_rbuf_lock.
1946 */
1947 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, bool copy_out,
1948 unsigned long *flags)
1949 {
1950 if (copy_out)
1951 sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
1952 ata_scsi_rbuf, ATA_SCSI_RBUF_SIZE);
1953 spin_unlock_irqrestore(&ata_scsi_rbuf_lock, *flags);
1954 }
1955
1956 /**
1957 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1958 * @args: device IDENTIFY data / SCSI command of interest.
1959 * @actor: Callback hook for desired SCSI command simulator
1960 *
1961 * Takes care of the hard work of simulating a SCSI command...
1962 * Mapping the response buffer, calling the command's handler,
1963 * and handling the handler's return value. This return value
1964 * indicates whether the handler wishes the SCSI command to be
1965 * completed successfully (0), or not (in which case cmd->result
1966 * and sense buffer are assumed to be set).
1967 *
1968 * LOCKING:
1969 * spin_lock_irqsave(host lock)
1970 */
1971 static void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1972 unsigned int (*actor)(struct ata_scsi_args *args, u8 *rbuf))
1973 {
1974 u8 *rbuf;
1975 unsigned int rc;
1976 struct scsi_cmnd *cmd = args->cmd;
1977 unsigned long flags;
1978
1979 rbuf = ata_scsi_rbuf_get(cmd, false, &flags);
1980 rc = actor(args, rbuf);
1981 ata_scsi_rbuf_put(cmd, rc == 0, &flags);
1982
1983 if (rc == 0)
1984 cmd->result = SAM_STAT_GOOD;
1985 args->done(cmd);
1986 }
1987
1988 /**
1989 * ata_scsiop_inq_std - Simulate INQUIRY command
1990 * @args: device IDENTIFY data / SCSI command of interest.
1991 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1992 *
1993 * Returns standard device identification data associated
1994 * with non-VPD INQUIRY command output.
1995 *
1996 * LOCKING:
1997 * spin_lock_irqsave(host lock)
1998 */
1999 static unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf)
2000 {
2001 const u8 versions[] = {
2002 0x00,
2003 0x60, /* SAM-3 (no version claimed) */
2004
2005 0x03,
2006 0x20, /* SBC-2 (no version claimed) */
2007
2008 0x02,
2009 0x60 /* SPC-3 (no version claimed) */
2010 };
2011 const u8 versions_zbc[] = {
2012 0x00,
2013 0xA0, /* SAM-5 (no version claimed) */
2014
2015 0x04,
2016 0xC0, /* SBC-3 (no version claimed) */
2017
2018 0x04,
2019 0x60, /* SPC-4 (no version claimed) */
2020
2021 0x60,
2022 0x20, /* ZBC (no version claimed) */
2023 };
2024
2025 u8 hdr[] = {
2026 TYPE_DISK,
2027 0,
2028 0x5, /* claim SPC-3 version compatibility */
2029 2,
2030 95 - 4
2031 };
2032
2033 VPRINTK("ENTER\n");
2034
2035 /* set scsi removable (RMB) bit per ata bit */
2036 if (ata_id_removable(args->id))
2037 hdr[1] |= (1 << 7);
2038
2039 if (args->dev->class == ATA_DEV_ZAC) {
2040 hdr[0] = TYPE_ZBC;
2041 hdr[2] = 0x6; /* ZBC is defined in SPC-4 */
2042 }
2043
2044 memcpy(rbuf, hdr, sizeof(hdr));
2045 memcpy(&rbuf[8], "ATA ", 8);
2046 ata_id_string(args->id, &rbuf[16], ATA_ID_PROD, 16);
2047
2048 /* From SAT, use last 2 words from fw rev unless they are spaces */
2049 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV + 2, 4);
2050 if (strncmp(&rbuf[32], " ", 4) == 0)
2051 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV, 4);
2052
2053 if (rbuf[32] == 0 || rbuf[32] == ' ')
2054 memcpy(&rbuf[32], "n/a ", 4);
2055
2056 if (args->dev->class == ATA_DEV_ZAC)
2057 memcpy(rbuf + 58, versions_zbc, sizeof(versions_zbc));
2058 else
2059 memcpy(rbuf + 58, versions, sizeof(versions));
2060
2061 return 0;
2062 }
2063
2064 /**
2065 * ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
2066 * @args: device IDENTIFY data / SCSI command of interest.
2067 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2068 *
2069 * Returns list of inquiry VPD pages available.
2070 *
2071 * LOCKING:
2072 * spin_lock_irqsave(host lock)
2073 */
2074 static unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf)
2075 {
2076 const u8 pages[] = {
2077 0x00, /* page 0x00, this page */
2078 0x80, /* page 0x80, unit serial no page */
2079 0x83, /* page 0x83, device ident page */
2080 0x89, /* page 0x89, ata info page */
2081 0xb0, /* page 0xb0, block limits page */
2082 0xb1, /* page 0xb1, block device characteristics page */
2083 0xb2, /* page 0xb2, thin provisioning page */
2084 };
2085
2086 rbuf[3] = sizeof(pages); /* number of supported VPD pages */
2087 memcpy(rbuf + 4, pages, sizeof(pages));
2088 return 0;
2089 }
2090
2091 /**
2092 * ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
2093 * @args: device IDENTIFY data / SCSI command of interest.
2094 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2095 *
2096 * Returns ATA device serial number.
2097 *
2098 * LOCKING:
2099 * spin_lock_irqsave(host lock)
2100 */
2101 static unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf)
2102 {
2103 const u8 hdr[] = {
2104 0,
2105 0x80, /* this page code */
2106 0,
2107 ATA_ID_SERNO_LEN, /* page len */
2108 };
2109
2110 memcpy(rbuf, hdr, sizeof(hdr));
2111 ata_id_string(args->id, (unsigned char *) &rbuf[4],
2112 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
2113 return 0;
2114 }
2115
2116 /**
2117 * ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
2118 * @args: device IDENTIFY data / SCSI command of interest.
2119 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2120 *
2121 * Yields two logical unit device identification designators:
2122 * - vendor specific ASCII containing the ATA serial number
2123 * - SAT defined "t10 vendor id based" containing ASCII vendor
2124 * name ("ATA "), model and serial numbers.
2125 *
2126 * LOCKING:
2127 * spin_lock_irqsave(host lock)
2128 */
2129 static unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf)
2130 {
2131 const int sat_model_serial_desc_len = 68;
2132 int num;
2133
2134 rbuf[1] = 0x83; /* this page code */
2135 num = 4;
2136
2137 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
2138 rbuf[num + 0] = 2;
2139 rbuf[num + 3] = ATA_ID_SERNO_LEN;
2140 num += 4;
2141 ata_id_string(args->id, (unsigned char *) rbuf + num,
2142 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
2143 num += ATA_ID_SERNO_LEN;
2144
2145 /* SAT defined lu model and serial numbers descriptor */
2146 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
2147 rbuf[num + 0] = 2;
2148 rbuf[num + 1] = 1;
2149 rbuf[num + 3] = sat_model_serial_desc_len;
2150 num += 4;
2151 memcpy(rbuf + num, "ATA ", 8);
2152 num += 8;
2153 ata_id_string(args->id, (unsigned char *) rbuf + num, ATA_ID_PROD,
2154 ATA_ID_PROD_LEN);
2155 num += ATA_ID_PROD_LEN;
2156 ata_id_string(args->id, (unsigned char *) rbuf + num, ATA_ID_SERNO,
2157 ATA_ID_SERNO_LEN);
2158 num += ATA_ID_SERNO_LEN;
2159
2160 if (ata_id_has_wwn(args->id)) {
2161 /* SAT defined lu world wide name */
2162 /* piv=0, assoc=lu, code_set=binary, designator=NAA */
2163 rbuf[num + 0] = 1;
2164 rbuf[num + 1] = 3;
2165 rbuf[num + 3] = ATA_ID_WWN_LEN;
2166 num += 4;
2167 ata_id_string(args->id, (unsigned char *) rbuf + num,
2168 ATA_ID_WWN, ATA_ID_WWN_LEN);
2169 num += ATA_ID_WWN_LEN;
2170 }
2171 rbuf[3] = num - 4; /* page len (assume less than 256 bytes) */
2172 return 0;
2173 }
2174
2175 /**
2176 * ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
2177 * @args: device IDENTIFY data / SCSI command of interest.
2178 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2179 *
2180 * Yields SAT-specified ATA VPD page.
2181 *
2182 * LOCKING:
2183 * spin_lock_irqsave(host lock)
2184 */
2185 static unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf)
2186 {
2187 struct ata_taskfile tf;
2188
2189 memset(&tf, 0, sizeof(tf));
2190
2191 rbuf[1] = 0x89; /* our page code */
2192 rbuf[2] = (0x238 >> 8); /* page size fixed at 238h */
2193 rbuf[3] = (0x238 & 0xff);
2194
2195 memcpy(&rbuf[8], "linux ", 8);
2196 memcpy(&rbuf[16], "libata ", 16);
2197 memcpy(&rbuf[32], DRV_VERSION, 4);
2198
2199 /* we don't store the ATA device signature, so we fake it */
2200
2201 tf.command = ATA_DRDY; /* really, this is Status reg */
2202 tf.lbal = 0x1;
2203 tf.nsect = 0x1;
2204
2205 ata_tf_to_fis(&tf, 0, 1, &rbuf[36]); /* TODO: PMP? */
2206 rbuf[36] = 0x34; /* force D2H Reg FIS (34h) */
2207
2208 rbuf[56] = ATA_CMD_ID_ATA;
2209
2210 memcpy(&rbuf[60], &args->id[0], 512);
2211 return 0;
2212 }
2213
2214 static unsigned int ata_scsiop_inq_b0(struct ata_scsi_args *args, u8 *rbuf)
2215 {
2216 u16 min_io_sectors;
2217
2218 rbuf[1] = 0xb0;
2219 rbuf[3] = 0x3c; /* required VPD size with unmap support */
2220
2221 /*
2222 * Optimal transfer length granularity.
2223 *
2224 * This is always one physical block, but for disks with a smaller
2225 * logical than physical sector size we need to figure out what the
2226 * latter is.
2227 */
2228 min_io_sectors = 1 << ata_id_log2_per_physical_sector(args->id);
2229 put_unaligned_be16(min_io_sectors, &rbuf[6]);
2230
2231 /*
2232 * Optimal unmap granularity.
2233 *
2234 * The ATA spec doesn't even know about a granularity or alignment
2235 * for the TRIM command. We can leave away most of the unmap related
2236 * VPD page entries, but we have specifify a granularity to signal
2237 * that we support some form of unmap - in thise case via WRITE SAME
2238 * with the unmap bit set.
2239 */
2240 if (ata_id_has_trim(args->id)) {
2241 put_unaligned_be64(65535 * 512 / 8, &rbuf[36]);
2242 put_unaligned_be32(1, &rbuf[28]);
2243 }
2244
2245 return 0;
2246 }
2247
2248 static unsigned int ata_scsiop_inq_b1(struct ata_scsi_args *args, u8 *rbuf)
2249 {
2250 int form_factor = ata_id_form_factor(args->id);
2251 int media_rotation_rate = ata_id_rotation_rate(args->id);
2252
2253 rbuf[1] = 0xb1;
2254 rbuf[3] = 0x3c;
2255 rbuf[4] = media_rotation_rate >> 8;
2256 rbuf[5] = media_rotation_rate;
2257 rbuf[7] = form_factor;
2258
2259 return 0;
2260 }
2261
2262 static unsigned int ata_scsiop_inq_b2(struct ata_scsi_args *args, u8 *rbuf)
2263 {
2264 /* SCSI Thin Provisioning VPD page: SBC-3 rev 22 or later */
2265 rbuf[1] = 0xb2;
2266 rbuf[3] = 0x4;
2267 rbuf[5] = 1 << 6; /* TPWS */
2268
2269 return 0;
2270 }
2271
2272 /**
2273 * ata_scsiop_noop - Command handler that simply returns success.
2274 * @args: device IDENTIFY data / SCSI command of interest.
2275 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2276 *
2277 * No operation. Simply returns success to caller, to indicate
2278 * that the caller should successfully complete this SCSI command.
2279 *
2280 * LOCKING:
2281 * spin_lock_irqsave(host lock)
2282 */
2283 static unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf)
2284 {
2285 VPRINTK("ENTER\n");
2286 return 0;
2287 }
2288
2289 /**
2290 * modecpy - Prepare response for MODE SENSE
2291 * @dest: output buffer
2292 * @src: data being copied
2293 * @n: length of mode page
2294 * @changeable: whether changeable parameters are requested
2295 *
2296 * Generate a generic MODE SENSE page for either current or changeable
2297 * parameters.
2298 *
2299 * LOCKING:
2300 * None.
2301 */
2302 static void modecpy(u8 *dest, const u8 *src, int n, bool changeable)
2303 {
2304 if (changeable) {
2305 memcpy(dest, src, 2);
2306 memset(dest + 2, 0, n - 2);
2307 } else {
2308 memcpy(dest, src, n);
2309 }
2310 }
2311
2312 /**
2313 * ata_msense_caching - Simulate MODE SENSE caching info page
2314 * @id: device IDENTIFY data
2315 * @buf: output buffer
2316 * @changeable: whether changeable parameters are requested
2317 *
2318 * Generate a caching info page, which conditionally indicates
2319 * write caching to the SCSI layer, depending on device
2320 * capabilities.
2321 *
2322 * LOCKING:
2323 * None.
2324 */
2325 static unsigned int ata_msense_caching(u16 *id, u8 *buf, bool changeable)
2326 {
2327 modecpy(buf, def_cache_mpage, sizeof(def_cache_mpage), changeable);
2328 if (changeable || ata_id_wcache_enabled(id))
2329 buf[2] |= (1 << 2); /* write cache enable */
2330 if (!changeable && !ata_id_rahead_enabled(id))
2331 buf[12] |= (1 << 5); /* disable read ahead */
2332 return sizeof(def_cache_mpage);
2333 }
2334
2335 /**
2336 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
2337 * @buf: output buffer
2338 * @changeable: whether changeable parameters are requested
2339 *
2340 * Generate a generic MODE SENSE control mode page.
2341 *
2342 * LOCKING:
2343 * None.
2344 */
2345 static unsigned int ata_msense_ctl_mode(u8 *buf, bool changeable)
2346 {
2347 modecpy(buf, def_control_mpage, sizeof(def_control_mpage), changeable);
2348 return sizeof(def_control_mpage);
2349 }
2350
2351 /**
2352 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
2353 * @buf: output buffer
2354 * @changeable: whether changeable parameters are requested
2355 *
2356 * Generate a generic MODE SENSE r/w error recovery page.
2357 *
2358 * LOCKING:
2359 * None.
2360 */
2361 static unsigned int ata_msense_rw_recovery(u8 *buf, bool changeable)
2362 {
2363 modecpy(buf, def_rw_recovery_mpage, sizeof(def_rw_recovery_mpage),
2364 changeable);
2365 return sizeof(def_rw_recovery_mpage);
2366 }
2367
2368 /*
2369 * We can turn this into a real blacklist if it's needed, for now just
2370 * blacklist any Maxtor BANC1G10 revision firmware
2371 */
2372 static int ata_dev_supports_fua(u16 *id)
2373 {
2374 unsigned char model[ATA_ID_PROD_LEN + 1], fw[ATA_ID_FW_REV_LEN + 1];
2375
2376 if (!libata_fua)
2377 return 0;
2378 if (!ata_id_has_fua(id))
2379 return 0;
2380
2381 ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
2382 ata_id_c_string(id, fw, ATA_ID_FW_REV, sizeof(fw));
2383
2384 if (strcmp(model, "Maxtor"))
2385 return 1;
2386 if (strcmp(fw, "BANC1G10"))
2387 return 1;
2388
2389 return 0; /* blacklisted */
2390 }
2391
2392 /**
2393 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
2394 * @args: device IDENTIFY data / SCSI command of interest.
2395 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2396 *
2397 * Simulate MODE SENSE commands. Assume this is invoked for direct
2398 * access devices (e.g. disks) only. There should be no block
2399 * descriptor for other device types.
2400 *
2401 * LOCKING:
2402 * spin_lock_irqsave(host lock)
2403 */
2404 static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf)
2405 {
2406 struct ata_device *dev = args->dev;
2407 u8 *scsicmd = args->cmd->cmnd, *p = rbuf;
2408 const u8 sat_blk_desc[] = {
2409 0, 0, 0, 0, /* number of blocks: sat unspecified */
2410 0,
2411 0, 0x2, 0x0 /* block length: 512 bytes */
2412 };
2413 u8 pg, spg;
2414 unsigned int ebd, page_control, six_byte;
2415 u8 dpofua;
2416
2417 VPRINTK("ENTER\n");
2418
2419 six_byte = (scsicmd[0] == MODE_SENSE);
2420 ebd = !(scsicmd[1] & 0x8); /* dbd bit inverted == edb */
2421 /*
2422 * LLBA bit in msense(10) ignored (compliant)
2423 */
2424
2425 page_control = scsicmd[2] >> 6;
2426 switch (page_control) {
2427 case 0: /* current */
2428 case 1: /* changeable */
2429 case 2: /* defaults */
2430 break; /* supported */
2431 case 3: /* saved */
2432 goto saving_not_supp;
2433 default:
2434 goto invalid_fld;
2435 }
2436
2437 if (six_byte)
2438 p += 4 + (ebd ? 8 : 0);
2439 else
2440 p += 8 + (ebd ? 8 : 0);
2441
2442 pg = scsicmd[2] & 0x3f;
2443 spg = scsicmd[3];
2444 /*
2445 * No mode subpages supported (yet) but asking for _all_
2446 * subpages may be valid
2447 */
2448 if (spg && (spg != ALL_SUB_MPAGES))
2449 goto invalid_fld;
2450
2451 switch(pg) {
2452 case RW_RECOVERY_MPAGE:
2453 p += ata_msense_rw_recovery(p, page_control == 1);
2454 break;
2455
2456 case CACHE_MPAGE:
2457 p += ata_msense_caching(args->id, p, page_control == 1);
2458 break;
2459
2460 case CONTROL_MPAGE:
2461 p += ata_msense_ctl_mode(p, page_control == 1);
2462 break;
2463
2464 case ALL_MPAGES:
2465 p += ata_msense_rw_recovery(p, page_control == 1);
2466 p += ata_msense_caching(args->id, p, page_control == 1);
2467 p += ata_msense_ctl_mode(p, page_control == 1);
2468 break;
2469
2470 default: /* invalid page code */
2471 goto invalid_fld;
2472 }
2473
2474 dpofua = 0;
2475 if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
2476 (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
2477 dpofua = 1 << 4;
2478
2479 if (six_byte) {
2480 rbuf[0] = p - rbuf - 1;
2481 rbuf[2] |= dpofua;
2482 if (ebd) {
2483 rbuf[3] = sizeof(sat_blk_desc);
2484 memcpy(rbuf + 4, sat_blk_desc, sizeof(sat_blk_desc));
2485 }
2486 } else {
2487 unsigned int output_len = p - rbuf - 2;
2488
2489 rbuf[0] = output_len >> 8;
2490 rbuf[1] = output_len;
2491 rbuf[3] |= dpofua;
2492 if (ebd) {
2493 rbuf[7] = sizeof(sat_blk_desc);
2494 memcpy(rbuf + 8, sat_blk_desc, sizeof(sat_blk_desc));
2495 }
2496 }
2497 return 0;
2498
2499 invalid_fld:
2500 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
2501 /* "Invalid field in cbd" */
2502 return 1;
2503
2504 saving_not_supp:
2505 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
2506 /* "Saving parameters not supported" */
2507 return 1;
2508 }
2509
2510 /**
2511 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
2512 * @args: device IDENTIFY data / SCSI command of interest.
2513 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2514 *
2515 * Simulate READ CAPACITY commands.
2516 *
2517 * LOCKING:
2518 * None.
2519 */
2520 static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf)
2521 {
2522 struct ata_device *dev = args->dev;
2523 u64 last_lba = dev->n_sectors - 1; /* LBA of the last block */
2524 u32 sector_size; /* physical sector size in bytes */
2525 u8 log2_per_phys;
2526 u16 lowest_aligned;
2527
2528 sector_size = ata_id_logical_sector_size(dev->id);
2529 log2_per_phys = ata_id_log2_per_physical_sector(dev->id);
2530 lowest_aligned = ata_id_logical_sector_offset(dev->id, log2_per_phys);
2531
2532 VPRINTK("ENTER\n");
2533
2534 if (args->cmd->cmnd[0] == READ_CAPACITY) {
2535 if (last_lba >= 0xffffffffULL)
2536 last_lba = 0xffffffff;
2537
2538 /* sector count, 32-bit */
2539 rbuf[0] = last_lba >> (8 * 3);
2540 rbuf[1] = last_lba >> (8 * 2);
2541 rbuf[2] = last_lba >> (8 * 1);
2542 rbuf[3] = last_lba;
2543
2544 /* sector size */
2545 rbuf[4] = sector_size >> (8 * 3);
2546 rbuf[5] = sector_size >> (8 * 2);
2547 rbuf[6] = sector_size >> (8 * 1);
2548 rbuf[7] = sector_size;
2549 } else {
2550 /* sector count, 64-bit */
2551 rbuf[0] = last_lba >> (8 * 7);
2552 rbuf[1] = last_lba >> (8 * 6);
2553 rbuf[2] = last_lba >> (8 * 5);
2554 rbuf[3] = last_lba >> (8 * 4);
2555 rbuf[4] = last_lba >> (8 * 3);
2556 rbuf[5] = last_lba >> (8 * 2);
2557 rbuf[6] = last_lba >> (8 * 1);
2558 rbuf[7] = last_lba;
2559
2560 /* sector size */
2561 rbuf[ 8] = sector_size >> (8 * 3);
2562 rbuf[ 9] = sector_size >> (8 * 2);
2563 rbuf[10] = sector_size >> (8 * 1);
2564 rbuf[11] = sector_size;
2565
2566 rbuf[12] = 0;
2567 rbuf[13] = log2_per_phys;
2568 rbuf[14] = (lowest_aligned >> 8) & 0x3f;
2569 rbuf[15] = lowest_aligned;
2570
2571 if (ata_id_has_trim(args->id) &&
2572 !(dev->horkage & ATA_HORKAGE_NOTRIM)) {
2573 rbuf[14] |= 0x80; /* LBPME */
2574
2575 if (ata_id_has_zero_after_trim(args->id) &&
2576 dev->horkage & ATA_HORKAGE_ZERO_AFTER_TRIM) {
2577 ata_dev_info(dev, "Enabling discard_zeroes_data\n");
2578 rbuf[14] |= 0x40; /* LBPRZ */
2579 }
2580 }
2581 }
2582 return 0;
2583 }
2584
2585 /**
2586 * ata_scsiop_report_luns - Simulate REPORT LUNS command
2587 * @args: device IDENTIFY data / SCSI command of interest.
2588 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2589 *
2590 * Simulate REPORT LUNS command.
2591 *
2592 * LOCKING:
2593 * spin_lock_irqsave(host lock)
2594 */
2595 static unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf)
2596 {
2597 VPRINTK("ENTER\n");
2598 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
2599
2600 return 0;
2601 }
2602
2603 static void atapi_sense_complete(struct ata_queued_cmd *qc)
2604 {
2605 if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
2606 /* FIXME: not quite right; we don't want the
2607 * translation of taskfile registers into
2608 * a sense descriptors, since that's only
2609 * correct for ATA, not ATAPI
2610 */
2611 ata_gen_passthru_sense(qc);
2612 }
2613
2614 qc->scsidone(qc->scsicmd);
2615 ata_qc_free(qc);
2616 }
2617
2618 /* is it pointless to prefer PIO for "safety reasons"? */
2619 static inline int ata_pio_use_silly(struct ata_port *ap)
2620 {
2621 return (ap->flags & ATA_FLAG_PIO_DMA);
2622 }
2623
2624 static void atapi_request_sense(struct ata_queued_cmd *qc)
2625 {
2626 struct ata_port *ap = qc->ap;
2627 struct scsi_cmnd *cmd = qc->scsicmd;
2628
2629 DPRINTK("ATAPI request sense\n");
2630
2631 memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
2632
2633 #ifdef CONFIG_ATA_SFF
2634 if (ap->ops->sff_tf_read)
2635 ap->ops->sff_tf_read(ap, &qc->tf);
2636 #endif
2637
2638 /* fill these in, for the case where they are -not- overwritten */
2639 cmd->sense_buffer[0] = 0x70;
2640 cmd->sense_buffer[2] = qc->tf.feature >> 4;
2641
2642 ata_qc_reinit(qc);
2643
2644 /* setup sg table and init transfer direction */
2645 sg_init_one(&qc->sgent, cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);
2646 ata_sg_init(qc, &qc->sgent, 1);
2647 qc->dma_dir = DMA_FROM_DEVICE;
2648
2649 memset(&qc->cdb, 0, qc->dev->cdb_len);
2650 qc->cdb[0] = REQUEST_SENSE;
2651 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2652
2653 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2654 qc->tf.command = ATA_CMD_PACKET;
2655
2656 if (ata_pio_use_silly(ap)) {
2657 qc->tf.protocol = ATAPI_PROT_DMA;
2658 qc->tf.feature |= ATAPI_PKT_DMA;
2659 } else {
2660 qc->tf.protocol = ATAPI_PROT_PIO;
2661 qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
2662 qc->tf.lbah = 0;
2663 }
2664 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2665
2666 qc->complete_fn = atapi_sense_complete;
2667
2668 ata_qc_issue(qc);
2669
2670 DPRINTK("EXIT\n");
2671 }
2672
2673 static void atapi_qc_complete(struct ata_queued_cmd *qc)
2674 {
2675 struct scsi_cmnd *cmd = qc->scsicmd;
2676 unsigned int err_mask = qc->err_mask;
2677
2678 VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
2679
2680 /* handle completion from new EH */
2681 if (unlikely(qc->ap->ops->error_handler &&
2682 (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
2683
2684 if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
2685 /* FIXME: not quite right; we don't want the
2686 * translation of taskfile registers into a
2687 * sense descriptors, since that's only
2688 * correct for ATA, not ATAPI
2689 */
2690 ata_gen_passthru_sense(qc);
2691 }
2692
2693 /* SCSI EH automatically locks door if sdev->locked is
2694 * set. Sometimes door lock request continues to
2695 * fail, for example, when no media is present. This
2696 * creates a loop - SCSI EH issues door lock which
2697 * fails and gets invoked again to acquire sense data
2698 * for the failed command.
2699 *
2700 * If door lock fails, always clear sdev->locked to
2701 * avoid this infinite loop.
2702 *
2703 * This may happen before SCSI scan is complete. Make
2704 * sure qc->dev->sdev isn't NULL before dereferencing.
2705 */
2706 if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL && qc->dev->sdev)
2707 qc->dev->sdev->locked = 0;
2708
2709 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
2710 qc->scsidone(cmd);
2711 ata_qc_free(qc);
2712 return;
2713 }
2714
2715 /* successful completion or old EH failure path */
2716 if (unlikely(err_mask & AC_ERR_DEV)) {
2717 cmd->result = SAM_STAT_CHECK_CONDITION;
2718 atapi_request_sense(qc);
2719 return;
2720 } else if (unlikely(err_mask)) {
2721 /* FIXME: not quite right; we don't want the
2722 * translation of taskfile registers into
2723 * a sense descriptors, since that's only
2724 * correct for ATA, not ATAPI
2725 */
2726 ata_gen_passthru_sense(qc);
2727 } else {
2728 u8 *scsicmd = cmd->cmnd;
2729
2730 if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
2731 unsigned long flags;
2732 u8 *buf;
2733
2734 buf = ata_scsi_rbuf_get(cmd, true, &flags);
2735
2736 /* ATAPI devices typically report zero for their SCSI version,
2737 * and sometimes deviate from the spec WRT response data
2738 * format. If SCSI version is reported as zero like normal,
2739 * then we make the following fixups: 1) Fake MMC-5 version,
2740 * to indicate to the Linux scsi midlayer this is a modern
2741 * device. 2) Ensure response data format / ATAPI information
2742 * are always correct.
2743 */
2744 if (buf[2] == 0) {
2745 buf[2] = 0x5;
2746 buf[3] = 0x32;
2747 }
2748
2749 ata_scsi_rbuf_put(cmd, true, &flags);
2750 }
2751
2752 cmd->result = SAM_STAT_GOOD;
2753 }
2754
2755 qc->scsidone(cmd);
2756 ata_qc_free(qc);
2757 }
2758 /**
2759 * atapi_xlat - Initialize PACKET taskfile
2760 * @qc: command structure to be initialized
2761 *
2762 * LOCKING:
2763 * spin_lock_irqsave(host lock)
2764 *
2765 * RETURNS:
2766 * Zero on success, non-zero on failure.
2767 */
2768 static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
2769 {
2770 struct scsi_cmnd *scmd = qc->scsicmd;
2771 struct ata_device *dev = qc->dev;
2772 int nodata = (scmd->sc_data_direction == DMA_NONE);
2773 int using_pio = !nodata && (dev->flags & ATA_DFLAG_PIO);
2774 unsigned int nbytes;
2775
2776 memset(qc->cdb, 0, dev->cdb_len);
2777 memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
2778
2779 qc->complete_fn = atapi_qc_complete;
2780
2781 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2782 if (scmd->sc_data_direction == DMA_TO_DEVICE) {
2783 qc->tf.flags |= ATA_TFLAG_WRITE;
2784 DPRINTK("direction: write\n");
2785 }
2786
2787 qc->tf.command = ATA_CMD_PACKET;
2788 ata_qc_set_pc_nbytes(qc);
2789
2790 /* check whether ATAPI DMA is safe */
2791 if (!nodata && !using_pio && atapi_check_dma(qc))
2792 using_pio = 1;
2793
2794 /* Some controller variants snoop this value for Packet
2795 * transfers to do state machine and FIFO management. Thus we
2796 * want to set it properly, and for DMA where it is
2797 * effectively meaningless.
2798 */
2799 nbytes = min(ata_qc_raw_nbytes(qc), (unsigned int)63 * 1024);
2800
2801 /* Most ATAPI devices which honor transfer chunk size don't
2802 * behave according to the spec when odd chunk size which
2803 * matches the transfer length is specified. If the number of
2804 * bytes to transfer is 2n+1. According to the spec, what
2805 * should happen is to indicate that 2n+1 is going to be
2806 * transferred and transfer 2n+2 bytes where the last byte is
2807 * padding.
2808 *
2809 * In practice, this doesn't happen. ATAPI devices first
2810 * indicate and transfer 2n bytes and then indicate and
2811 * transfer 2 bytes where the last byte is padding.
2812 *
2813 * This inconsistency confuses several controllers which
2814 * perform PIO using DMA such as Intel AHCIs and sil3124/32.
2815 * These controllers use actual number of transferred bytes to
2816 * update DMA poitner and transfer of 4n+2 bytes make those
2817 * controller push DMA pointer by 4n+4 bytes because SATA data
2818 * FISes are aligned to 4 bytes. This causes data corruption
2819 * and buffer overrun.
2820 *
2821 * Always setting nbytes to even number solves this problem
2822 * because then ATAPI devices don't have to split data at 2n
2823 * boundaries.
2824 */
2825 if (nbytes & 0x1)
2826 nbytes++;
2827
2828 qc->tf.lbam = (nbytes & 0xFF);
2829 qc->tf.lbah = (nbytes >> 8);
2830
2831 if (nodata)
2832 qc->tf.protocol = ATAPI_PROT_NODATA;
2833 else if (using_pio)
2834 qc->tf.protocol = ATAPI_PROT_PIO;
2835 else {
2836 /* DMA data xfer */
2837 qc->tf.protocol = ATAPI_PROT_DMA;
2838 qc->tf.feature |= ATAPI_PKT_DMA;
2839
2840 if ((dev->flags & ATA_DFLAG_DMADIR) &&
2841 (scmd->sc_data_direction != DMA_TO_DEVICE))
2842 /* some SATA bridges need us to indicate data xfer direction */
2843 qc->tf.feature |= ATAPI_DMADIR;
2844 }
2845
2846
2847 /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
2848 as ATAPI tape drives don't get this right otherwise */
2849 return 0;
2850 }
2851
2852 static struct ata_device *ata_find_dev(struct ata_port *ap, int devno)
2853 {
2854 if (!sata_pmp_attached(ap)) {
2855 if (likely(devno < ata_link_max_devices(&ap->link)))
2856 return &ap->link.device[devno];
2857 } else {
2858 if (likely(devno < ap->nr_pmp_links))
2859 return &ap->pmp_link[devno].device[0];
2860 }
2861
2862 return NULL;
2863 }
2864
2865 static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
2866 const struct scsi_device *scsidev)
2867 {
2868 int devno;
2869
2870 /* skip commands not addressed to targets we simulate */
2871 if (!sata_pmp_attached(ap)) {
2872 if (unlikely(scsidev->channel || scsidev->lun))
2873 return NULL;
2874 devno = scsidev->id;
2875 } else {
2876 if (unlikely(scsidev->id || scsidev->lun))
2877 return NULL;
2878 devno = scsidev->channel;
2879 }
2880
2881 return ata_find_dev(ap, devno);
2882 }
2883
2884 /**
2885 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
2886 * @ap: ATA port to which the device is attached
2887 * @scsidev: SCSI device from which we derive the ATA device
2888 *
2889 * Given various information provided in struct scsi_cmnd,
2890 * map that onto an ATA bus, and using that mapping
2891 * determine which ata_device is associated with the
2892 * SCSI command to be sent.
2893 *
2894 * LOCKING:
2895 * spin_lock_irqsave(host lock)
2896 *
2897 * RETURNS:
2898 * Associated ATA device, or %NULL if not found.
2899 */
2900 static struct ata_device *
2901 ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
2902 {
2903 struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
2904
2905 if (unlikely(!dev || !ata_dev_enabled(dev)))
2906 return NULL;
2907
2908 return dev;
2909 }
2910
2911 /*
2912 * ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
2913 * @byte1: Byte 1 from pass-thru CDB.
2914 *
2915 * RETURNS:
2916 * ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
2917 */
2918 static u8
2919 ata_scsi_map_proto(u8 byte1)
2920 {
2921 switch((byte1 & 0x1e) >> 1) {
2922 case 3: /* Non-data */
2923 return ATA_PROT_NODATA;
2924
2925 case 6: /* DMA */
2926 case 10: /* UDMA Data-in */
2927 case 11: /* UDMA Data-Out */
2928 return ATA_PROT_DMA;
2929
2930 case 4: /* PIO Data-in */
2931 case 5: /* PIO Data-out */
2932 return ATA_PROT_PIO;
2933
2934 case 0: /* Hard Reset */
2935 case 1: /* SRST */
2936 case 8: /* Device Diagnostic */
2937 case 9: /* Device Reset */
2938 case 7: /* DMA Queued */
2939 case 12: /* FPDMA */
2940 case 15: /* Return Response Info */
2941 default: /* Reserved */
2942 break;
2943 }
2944
2945 return ATA_PROT_UNKNOWN;
2946 }
2947
2948 /**
2949 * ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
2950 * @qc: command structure to be initialized
2951 *
2952 * Handles either 12 or 16-byte versions of the CDB.
2953 *
2954 * RETURNS:
2955 * Zero on success, non-zero on failure.
2956 */
2957 static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
2958 {
2959 struct ata_taskfile *tf = &(qc->tf);
2960 struct scsi_cmnd *scmd = qc->scsicmd;
2961 struct ata_device *dev = qc->dev;
2962 const u8 *cdb = scmd->cmnd;
2963
2964 if ((tf->protocol = ata_scsi_map_proto(cdb[1])) == ATA_PROT_UNKNOWN)
2965 goto invalid_fld;
2966
2967 /*
2968 * 12 and 16 byte CDBs use different offsets to
2969 * provide the various register values.
2970 */
2971 if (cdb[0] == ATA_16) {
2972 /*
2973 * 16-byte CDB - may contain extended commands.
2974 *
2975 * If that is the case, copy the upper byte register values.
2976 */
2977 if (cdb[1] & 0x01) {
2978 tf->hob_feature = cdb[3];
2979 tf->hob_nsect = cdb[5];
2980 tf->hob_lbal = cdb[7];
2981 tf->hob_lbam = cdb[9];
2982 tf->hob_lbah = cdb[11];
2983 tf->flags |= ATA_TFLAG_LBA48;
2984 } else
2985 tf->flags &= ~ATA_TFLAG_LBA48;
2986
2987 /*
2988 * Always copy low byte, device and command registers.
2989 */
2990 tf->feature = cdb[4];
2991 tf->nsect = cdb[6];
2992 tf->lbal = cdb[8];
2993 tf->lbam = cdb[10];
2994 tf->lbah = cdb[12];
2995 tf->device = cdb[13];
2996 tf->command = cdb[14];
2997 } else {
2998 /*
2999 * 12-byte CDB - incapable of extended commands.
3000 */
3001 tf->flags &= ~ATA_TFLAG_LBA48;
3002
3003 tf->feature = cdb[3];
3004 tf->nsect = cdb[4];
3005 tf->lbal = cdb[5];
3006 tf->lbam = cdb[6];
3007 tf->lbah = cdb[7];
3008 tf->device = cdb[8];
3009 tf->command = cdb[9];
3010 }
3011
3012 /* enforce correct master/slave bit */
3013 tf->device = dev->devno ?
3014 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
3015
3016 switch (tf->command) {
3017 /* READ/WRITE LONG use a non-standard sect_size */
3018 case ATA_CMD_READ_LONG:
3019 case ATA_CMD_READ_LONG_ONCE:
3020 case ATA_CMD_WRITE_LONG:
3021 case ATA_CMD_WRITE_LONG_ONCE:
3022 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
3023 goto invalid_fld;
3024 qc->sect_size = scsi_bufflen(scmd);
3025 break;
3026
3027 /* commands using reported Logical Block size (e.g. 512 or 4K) */
3028 case ATA_CMD_CFA_WRITE_NE:
3029 case ATA_CMD_CFA_TRANS_SECT:
3030 case ATA_CMD_CFA_WRITE_MULT_NE:
3031 /* XXX: case ATA_CMD_CFA_WRITE_SECTORS_WITHOUT_ERASE: */
3032 case ATA_CMD_READ:
3033 case ATA_CMD_READ_EXT:
3034 case ATA_CMD_READ_QUEUED:
3035 /* XXX: case ATA_CMD_READ_QUEUED_EXT: */
3036 case ATA_CMD_FPDMA_READ:
3037 case ATA_CMD_READ_MULTI:
3038 case ATA_CMD_READ_MULTI_EXT:
3039 case ATA_CMD_PIO_READ:
3040 case ATA_CMD_PIO_READ_EXT:
3041 case ATA_CMD_READ_STREAM_DMA_EXT:
3042 case ATA_CMD_READ_STREAM_EXT:
3043 case ATA_CMD_VERIFY:
3044 case ATA_CMD_VERIFY_EXT:
3045 case ATA_CMD_WRITE:
3046 case ATA_CMD_WRITE_EXT:
3047 case ATA_CMD_WRITE_FUA_EXT:
3048 case ATA_CMD_WRITE_QUEUED:
3049 case ATA_CMD_WRITE_QUEUED_FUA_EXT:
3050 case ATA_CMD_FPDMA_WRITE:
3051 case ATA_CMD_WRITE_MULTI:
3052 case ATA_CMD_WRITE_MULTI_EXT:
3053 case ATA_CMD_WRITE_MULTI_FUA_EXT:
3054 case ATA_CMD_PIO_WRITE:
3055 case ATA_CMD_PIO_WRITE_EXT:
3056 case ATA_CMD_WRITE_STREAM_DMA_EXT:
3057 case ATA_CMD_WRITE_STREAM_EXT:
3058 qc->sect_size = scmd->device->sector_size;
3059 break;
3060
3061 /* Everything else uses 512 byte "sectors" */
3062 default:
3063 qc->sect_size = ATA_SECT_SIZE;
3064 }
3065
3066 /*
3067 * Set flags so that all registers will be written, pass on
3068 * write indication (used for PIO/DMA setup), result TF is
3069 * copied back and we don't whine too much about its failure.
3070 */
3071 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3072 if (scmd->sc_data_direction == DMA_TO_DEVICE)
3073 tf->flags |= ATA_TFLAG_WRITE;
3074
3075 qc->flags |= ATA_QCFLAG_RESULT_TF | ATA_QCFLAG_QUIET;
3076
3077 /*
3078 * Set transfer length.
3079 *
3080 * TODO: find out if we need to do more here to
3081 * cover scatter/gather case.
3082 */
3083 ata_qc_set_pc_nbytes(qc);
3084
3085 /* We may not issue DMA commands if no DMA mode is set */
3086 if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
3087 goto invalid_fld;
3088
3089 /* sanity check for pio multi commands */
3090 if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf))
3091 goto invalid_fld;
3092
3093 if (is_multi_taskfile(tf)) {
3094 unsigned int multi_count = 1 << (cdb[1] >> 5);
3095
3096 /* compare the passed through multi_count
3097 * with the cached multi_count of libata
3098 */
3099 if (multi_count != dev->multi_count)
3100 ata_dev_warn(dev, "invalid multi_count %u ignored\n",
3101 multi_count);
3102 }
3103
3104 /*
3105 * Filter SET_FEATURES - XFER MODE command -- otherwise,
3106 * SET_FEATURES - XFER MODE must be preceded/succeeded
3107 * by an update to hardware-specific registers for each
3108 * controller (i.e. the reason for ->set_piomode(),
3109 * ->set_dmamode(), and ->post_set_mode() hooks).
3110 */
3111 if (tf->command == ATA_CMD_SET_FEATURES &&
3112 tf->feature == SETFEATURES_XFER)
3113 goto invalid_fld;
3114
3115 /*
3116 * Filter TPM commands by default. These provide an
3117 * essentially uncontrolled encrypted "back door" between
3118 * applications and the disk. Set libata.allow_tpm=1 if you
3119 * have a real reason for wanting to use them. This ensures
3120 * that installed software cannot easily mess stuff up without
3121 * user intent. DVR type users will probably ship with this enabled
3122 * for movie content management.
3123 *
3124 * Note that for ATA8 we can issue a DCS change and DCS freeze lock
3125 * for this and should do in future but that it is not sufficient as
3126 * DCS is an optional feature set. Thus we also do the software filter
3127 * so that we comply with the TC consortium stated goal that the user
3128 * can turn off TC features of their system.
3129 */
3130 if (tf->command >= 0x5C && tf->command <= 0x5F && !libata_allow_tpm)
3131 goto invalid_fld;
3132
3133 return 0;
3134
3135 invalid_fld:
3136 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
3137 /* "Invalid field in cdb" */
3138 return 1;
3139 }
3140
3141 static unsigned int ata_scsi_write_same_xlat(struct ata_queued_cmd *qc)
3142 {
3143 struct ata_taskfile *tf = &qc->tf;
3144 struct scsi_cmnd *scmd = qc->scsicmd;
3145 struct ata_device *dev = qc->dev;
3146 const u8 *cdb = scmd->cmnd;
3147 u64 block;
3148 u32 n_block;
3149 u32 size;
3150 void *buf;
3151
3152 /* we may not issue DMA commands if no DMA mode is set */
3153 if (unlikely(!dev->dma_mode))
3154 goto invalid_fld;
3155
3156 if (unlikely(scmd->cmd_len < 16))
3157 goto invalid_fld;
3158 scsi_16_lba_len(cdb, &block, &n_block);
3159
3160 /* for now we only support WRITE SAME with the unmap bit set */
3161 if (unlikely(!(cdb[1] & 0x8)))
3162 goto invalid_fld;
3163
3164 /*
3165 * WRITE SAME always has a sector sized buffer as payload, this
3166 * should never be a multiple entry S/G list.
3167 */
3168 if (!scsi_sg_count(scmd))
3169 goto invalid_fld;
3170
3171 buf = page_address(sg_page(scsi_sglist(scmd)));
3172 size = ata_set_lba_range_entries(buf, 512, block, n_block);
3173
3174 if (ata_ncq_enabled(dev) && ata_fpdma_dsm_supported(dev)) {
3175 /* Newer devices support queued TRIM commands */
3176 tf->protocol = ATA_PROT_NCQ;
3177 tf->command = ATA_CMD_FPDMA_SEND;
3178 tf->hob_nsect = ATA_SUBCMD_FPDMA_SEND_DSM & 0x1f;
3179 tf->nsect = qc->tag << 3;
3180 tf->hob_feature = (size / 512) >> 8;
3181 tf->feature = size / 512;
3182
3183 tf->auxiliary = 1;
3184 } else {
3185 tf->protocol = ATA_PROT_DMA;
3186 tf->hob_feature = 0;
3187 tf->feature = ATA_DSM_TRIM;
3188 tf->hob_nsect = (size / 512) >> 8;
3189 tf->nsect = size / 512;
3190 tf->command = ATA_CMD_DSM;
3191 }
3192
3193 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 |
3194 ATA_TFLAG_WRITE;
3195
3196 ata_qc_set_pc_nbytes(qc);
3197
3198 return 0;
3199
3200 invalid_fld:
3201 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
3202 /* "Invalid field in cdb" */
3203 return 1;
3204 }
3205
3206 /**
3207 * ata_mselect_caching - Simulate MODE SELECT for caching info page
3208 * @qc: Storage for translated ATA taskfile
3209 * @buf: input buffer
3210 * @len: number of valid bytes in the input buffer
3211 *
3212 * Prepare a taskfile to modify caching information for the device.
3213 *
3214 * LOCKING:
3215 * None.
3216 */
3217 static int ata_mselect_caching(struct ata_queued_cmd *qc,
3218 const u8 *buf, int len)
3219 {
3220 struct ata_taskfile *tf = &qc->tf;
3221 struct ata_device *dev = qc->dev;
3222 char mpage[CACHE_MPAGE_LEN];
3223 u8 wce;
3224
3225 /*
3226 * The first two bytes of def_cache_mpage are a header, so offsets
3227 * in mpage are off by 2 compared to buf. Same for len.
3228 */
3229
3230 if (len != CACHE_MPAGE_LEN - 2)
3231 return -EINVAL;
3232
3233 wce = buf[0] & (1 << 2);
3234
3235 /*
3236 * Check that read-only bits are not modified.
3237 */
3238 ata_msense_caching(dev->id, mpage, false);
3239 mpage[2] &= ~(1 << 2);
3240 mpage[2] |= wce;
3241 if (memcmp(mpage + 2, buf, CACHE_MPAGE_LEN - 2) != 0)
3242 return -EINVAL;
3243
3244 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
3245 tf->protocol = ATA_PROT_NODATA;
3246 tf->nsect = 0;
3247 tf->command = ATA_CMD_SET_FEATURES;
3248 tf->feature = wce ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
3249 return 0;
3250 }
3251
3252 /**
3253 * ata_scsiop_mode_select - Simulate MODE SELECT 6, 10 commands
3254 * @qc: Storage for translated ATA taskfile
3255 *
3256 * Converts a MODE SELECT command to an ATA SET FEATURES taskfile.
3257 * Assume this is invoked for direct access devices (e.g. disks) only.
3258 * There should be no block descriptor for other device types.
3259 *
3260 * LOCKING:
3261 * spin_lock_irqsave(host lock)
3262 */
3263 static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc)
3264 {
3265 struct scsi_cmnd *scmd = qc->scsicmd;
3266 const u8 *cdb = scmd->cmnd;
3267 const u8 *p;
3268 u8 pg, spg;
3269 unsigned six_byte, pg_len, hdr_len, bd_len;
3270 int len;
3271
3272 VPRINTK("ENTER\n");
3273
3274 six_byte = (cdb[0] == MODE_SELECT);
3275 if (six_byte) {
3276 if (scmd->cmd_len < 5)
3277 goto invalid_fld;
3278
3279 len = cdb[4];
3280 hdr_len = 4;
3281 } else {
3282 if (scmd->cmd_len < 9)
3283 goto invalid_fld;
3284
3285 len = (cdb[7] << 8) + cdb[8];
3286 hdr_len = 8;
3287 }
3288
3289 /* We only support PF=1, SP=0. */
3290 if ((cdb[1] & 0x11) != 0x10)
3291 goto invalid_fld;
3292
3293 /* Test early for possible overrun. */
3294 if (!scsi_sg_count(scmd) || scsi_sglist(scmd)->length < len)
3295 goto invalid_param_len;
3296
3297 p = page_address(sg_page(scsi_sglist(scmd)));
3298
3299 /* Move past header and block descriptors. */
3300 if (len < hdr_len)
3301 goto invalid_param_len;
3302
3303 if (six_byte)
3304 bd_len = p[3];
3305 else
3306 bd_len = (p[6] << 8) + p[7];
3307
3308 len -= hdr_len;
3309 p += hdr_len;
3310 if (len < bd_len)
3311 goto invalid_param_len;
3312 if (bd_len != 0 && bd_len != 8)
3313 goto invalid_param;
3314
3315 len -= bd_len;
3316 p += bd_len;
3317 if (len == 0)
3318 goto skip;
3319
3320 /* Parse both possible formats for the mode page headers. */
3321 pg = p[0] & 0x3f;
3322 if (p[0] & 0x40) {
3323 if (len < 4)
3324 goto invalid_param_len;
3325
3326 spg = p[1];
3327 pg_len = (p[2] << 8) | p[3];
3328 p += 4;
3329 len -= 4;
3330 } else {
3331 if (len < 2)
3332 goto invalid_param_len;
3333
3334 spg = 0;
3335 pg_len = p[1];
3336 p += 2;
3337 len -= 2;
3338 }
3339
3340 /*
3341 * No mode subpages supported (yet) but asking for _all_
3342 * subpages may be valid
3343 */
3344 if (spg && (spg != ALL_SUB_MPAGES))
3345 goto invalid_param;
3346 if (pg_len > len)
3347 goto invalid_param_len;
3348
3349 switch (pg) {
3350 case CACHE_MPAGE:
3351 if (ata_mselect_caching(qc, p, pg_len) < 0)
3352 goto invalid_param;
3353 break;
3354
3355 default: /* invalid page code */
3356 goto invalid_param;
3357 }
3358
3359 /*
3360 * Only one page has changeable data, so we only support setting one
3361 * page at a time.
3362 */
3363 if (len > pg_len)
3364 goto invalid_param;
3365
3366 return 0;
3367
3368 invalid_fld:
3369 /* "Invalid field in CDB" */
3370 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
3371 return 1;
3372
3373 invalid_param:
3374 /* "Invalid field in parameter list" */
3375 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x26, 0x0);
3376 return 1;
3377
3378 invalid_param_len:
3379 /* "Parameter list length error" */
3380 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
3381 return 1;
3382
3383 skip:
3384 scmd->result = SAM_STAT_GOOD;
3385 return 1;
3386 }
3387
3388 /**
3389 * ata_get_xlat_func - check if SCSI to ATA translation is possible
3390 * @dev: ATA device
3391 * @cmd: SCSI command opcode to consider
3392 *
3393 * Look up the SCSI command given, and determine whether the
3394 * SCSI command is to be translated or simulated.
3395 *
3396 * RETURNS:
3397 * Pointer to translation function if possible, %NULL if not.
3398 */
3399
3400 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
3401 {
3402 switch (cmd) {
3403 case READ_6:
3404 case READ_10:
3405 case READ_16:
3406
3407 case WRITE_6:
3408 case WRITE_10:
3409 case WRITE_16:
3410 return ata_scsi_rw_xlat;
3411
3412 case WRITE_SAME_16:
3413 return ata_scsi_write_same_xlat;
3414
3415 case SYNCHRONIZE_CACHE:
3416 if (ata_try_flush_cache(dev))
3417 return ata_scsi_flush_xlat;
3418 break;
3419
3420 case VERIFY:
3421 case VERIFY_16:
3422 return ata_scsi_verify_xlat;
3423
3424 case ATA_12:
3425 case ATA_16:
3426 return ata_scsi_pass_thru;
3427
3428 case MODE_SELECT:
3429 case MODE_SELECT_10:
3430 return ata_scsi_mode_select_xlat;
3431 break;
3432
3433 case START_STOP:
3434 return ata_scsi_start_stop_xlat;
3435 }
3436
3437 return NULL;
3438 }
3439
3440 /**
3441 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
3442 * @ap: ATA port to which the command was being sent
3443 * @cmd: SCSI command to dump
3444 *
3445 * Prints the contents of a SCSI command via printk().
3446 */
3447
3448 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
3449 struct scsi_cmnd *cmd)
3450 {
3451 #ifdef ATA_DEBUG
3452 struct scsi_device *scsidev = cmd->device;
3453 u8 *scsicmd = cmd->cmnd;
3454
3455 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
3456 ap->print_id,
3457 scsidev->channel, scsidev->id, scsidev->lun,
3458 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
3459 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
3460 scsicmd[8]);
3461 #endif
3462 }
3463
3464 static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
3465 struct ata_device *dev)
3466 {
3467 u8 scsi_op = scmd->cmnd[0];
3468 ata_xlat_func_t xlat_func;
3469 int rc = 0;
3470
3471 if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
3472 if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
3473 goto bad_cdb_len;
3474
3475 xlat_func = ata_get_xlat_func(dev, scsi_op);
3476 } else {
3477 if (unlikely(!scmd->cmd_len))
3478 goto bad_cdb_len;
3479
3480 xlat_func = NULL;
3481 if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
3482 /* relay SCSI command to ATAPI device */
3483 int len = COMMAND_SIZE(scsi_op);
3484 if (unlikely(len > scmd->cmd_len || len > dev->cdb_len))
3485 goto bad_cdb_len;
3486
3487 xlat_func = atapi_xlat;
3488 } else {
3489 /* ATA_16 passthru, treat as an ATA command */
3490 if (unlikely(scmd->cmd_len > 16))
3491 goto bad_cdb_len;
3492
3493 xlat_func = ata_get_xlat_func(dev, scsi_op);
3494 }
3495 }
3496
3497 if (xlat_func)
3498 rc = ata_scsi_translate(dev, scmd, xlat_func);
3499 else
3500 ata_scsi_simulate(dev, scmd);
3501
3502 return rc;
3503
3504 bad_cdb_len:
3505 DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
3506 scmd->cmd_len, scsi_op, dev->cdb_len);
3507 scmd->result = DID_ERROR << 16;
3508 scmd->scsi_done(scmd);
3509 return 0;
3510 }
3511
3512 /**
3513 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
3514 * @shost: SCSI host of command to be sent
3515 * @cmd: SCSI command to be sent
3516 *
3517 * In some cases, this function translates SCSI commands into
3518 * ATA taskfiles, and queues the taskfiles to be sent to
3519 * hardware. In other cases, this function simulates a
3520 * SCSI device by evaluating and responding to certain
3521 * SCSI commands. This creates the overall effect of
3522 * ATA and ATAPI devices appearing as SCSI devices.
3523 *
3524 * LOCKING:
3525 * ATA host lock
3526 *
3527 * RETURNS:
3528 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
3529 * 0 otherwise.
3530 */
3531 int ata_scsi_queuecmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
3532 {
3533 struct ata_port *ap;
3534 struct ata_device *dev;
3535 struct scsi_device *scsidev = cmd->device;
3536 int rc = 0;
3537 unsigned long irq_flags;
3538
3539 ap = ata_shost_to_port(shost);
3540
3541 spin_lock_irqsave(ap->lock, irq_flags);
3542
3543 ata_scsi_dump_cdb(ap, cmd);
3544
3545 dev = ata_scsi_find_dev(ap, scsidev);
3546 if (likely(dev))
3547 rc = __ata_scsi_queuecmd(cmd, dev);
3548 else {
3549 cmd->result = (DID_BAD_TARGET << 16);
3550 cmd->scsi_done(cmd);
3551 }
3552
3553 spin_unlock_irqrestore(ap->lock, irq_flags);
3554
3555 return rc;
3556 }
3557
3558 /**
3559 * ata_scsi_simulate - simulate SCSI command on ATA device
3560 * @dev: the target device
3561 * @cmd: SCSI command being sent to device.
3562 *
3563 * Interprets and directly executes a select list of SCSI commands
3564 * that can be handled internally.
3565 *
3566 * LOCKING:
3567 * spin_lock_irqsave(host lock)
3568 */
3569
3570 void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
3571 {
3572 struct ata_scsi_args args;
3573 const u8 *scsicmd = cmd->cmnd;
3574 u8 tmp8;
3575
3576 args.dev = dev;
3577 args.id = dev->id;
3578 args.cmd = cmd;
3579 args.done = cmd->scsi_done;
3580
3581 switch(scsicmd[0]) {
3582 /* TODO: worth improving? */
3583 case FORMAT_UNIT:
3584 ata_scsi_invalid_field(cmd);
3585 break;
3586
3587 case INQUIRY:
3588 if (scsicmd[1] & 2) /* is CmdDt set? */
3589 ata_scsi_invalid_field(cmd);
3590 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
3591 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
3592 else switch (scsicmd[2]) {
3593 case 0x00:
3594 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
3595 break;
3596 case 0x80:
3597 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
3598 break;
3599 case 0x83:
3600 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
3601 break;
3602 case 0x89:
3603 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
3604 break;
3605 case 0xb0:
3606 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b0);
3607 break;
3608 case 0xb1:
3609 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b1);
3610 break;
3611 case 0xb2:
3612 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b2);
3613 break;
3614 default:
3615 ata_scsi_invalid_field(cmd);
3616 break;
3617 }
3618 break;
3619
3620 case MODE_SENSE:
3621 case MODE_SENSE_10:
3622 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
3623 break;
3624
3625 case READ_CAPACITY:
3626 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3627 break;
3628
3629 case SERVICE_ACTION_IN_16:
3630 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
3631 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3632 else
3633 ata_scsi_invalid_field(cmd);
3634 break;
3635
3636 case REPORT_LUNS:
3637 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
3638 break;
3639
3640 case REQUEST_SENSE:
3641 ata_scsi_set_sense(cmd, 0, 0, 0);
3642 cmd->result = (DRIVER_SENSE << 24);
3643 cmd->scsi_done(cmd);
3644 break;
3645
3646 /* if we reach this, then writeback caching is disabled,
3647 * turning this into a no-op.
3648 */
3649 case SYNCHRONIZE_CACHE:
3650 /* fall through */
3651
3652 /* no-op's, complete with success */
3653 case REZERO_UNIT:
3654 case SEEK_6:
3655 case SEEK_10:
3656 case TEST_UNIT_READY:
3657 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3658 break;
3659
3660 case SEND_DIAGNOSTIC:
3661 tmp8 = scsicmd[1] & ~(1 << 3);
3662 if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
3663 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3664 else
3665 ata_scsi_invalid_field(cmd);
3666 break;
3667
3668 /* all other commands */
3669 default:
3670 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
3671 /* "Invalid command operation code" */
3672 cmd->scsi_done(cmd);
3673 break;
3674 }
3675 }
3676
3677 int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
3678 {
3679 int i, rc;
3680
3681 for (i = 0; i < host->n_ports; i++) {
3682 struct ata_port *ap = host->ports[i];
3683 struct Scsi_Host *shost;
3684
3685 rc = -ENOMEM;
3686 shost = scsi_host_alloc(sht, sizeof(struct ata_port *));
3687 if (!shost)
3688 goto err_alloc;
3689
3690 shost->eh_noresume = 1;
3691 *(struct ata_port **)&shost->hostdata[0] = ap;
3692 ap->scsi_host = shost;
3693
3694 shost->transportt = ata_scsi_transport_template;
3695 shost->unique_id = ap->print_id;
3696 shost->max_id = 16;
3697 shost->max_lun = 1;
3698 shost->max_channel = 1;
3699 shost->max_cmd_len = 16;
3700 shost->no_write_same = 1;
3701
3702 /* Schedule policy is determined by ->qc_defer()
3703 * callback and it needs to see every deferred qc.
3704 * Set host_blocked to 1 to prevent SCSI midlayer from
3705 * automatically deferring requests.
3706 */
3707 shost->max_host_blocked = 1;
3708
3709 if (scsi_init_shared_tag_map(shost, host->n_tags))
3710 goto err_add;
3711
3712 rc = scsi_add_host_with_dma(ap->scsi_host,
3713 &ap->tdev, ap->host->dev);
3714 if (rc)
3715 goto err_add;
3716 }
3717
3718 return 0;
3719
3720 err_add:
3721 scsi_host_put(host->ports[i]->scsi_host);
3722 err_alloc:
3723 while (--i >= 0) {
3724 struct Scsi_Host *shost = host->ports[i]->scsi_host;
3725
3726 scsi_remove_host(shost);
3727 scsi_host_put(shost);
3728 }
3729 return rc;
3730 }
3731
3732 void ata_scsi_scan_host(struct ata_port *ap, int sync)
3733 {
3734 int tries = 5;
3735 struct ata_device *last_failed_dev = NULL;
3736 struct ata_link *link;
3737 struct ata_device *dev;
3738
3739 repeat:
3740 ata_for_each_link(link, ap, EDGE) {
3741 ata_for_each_dev(dev, link, ENABLED) {
3742 struct scsi_device *sdev;
3743 int channel = 0, id = 0;
3744
3745 if (dev->sdev)
3746 continue;
3747
3748 if (ata_is_host_link(link))
3749 id = dev->devno;
3750 else
3751 channel = link->pmp;
3752
3753 sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
3754 NULL);
3755 if (!IS_ERR(sdev)) {
3756 dev->sdev = sdev;
3757 scsi_device_put(sdev);
3758 } else {
3759 dev->sdev = NULL;
3760 }
3761 }
3762 }
3763
3764 /* If we scanned while EH was in progress or allocation
3765 * failure occurred, scan would have failed silently. Check
3766 * whether all devices are attached.
3767 */
3768 ata_for_each_link(link, ap, EDGE) {
3769 ata_for_each_dev(dev, link, ENABLED) {
3770 if (!dev->sdev)
3771 goto exit_loop;
3772 }
3773 }
3774 exit_loop:
3775 if (!link)
3776 return;
3777
3778 /* we're missing some SCSI devices */
3779 if (sync) {
3780 /* If caller requested synchrnous scan && we've made
3781 * any progress, sleep briefly and repeat.
3782 */
3783 if (dev != last_failed_dev) {
3784 msleep(100);
3785 last_failed_dev = dev;
3786 goto repeat;
3787 }
3788
3789 /* We might be failing to detect boot device, give it
3790 * a few more chances.
3791 */
3792 if (--tries) {
3793 msleep(100);
3794 goto repeat;
3795 }
3796
3797 ata_port_err(ap,
3798 "WARNING: synchronous SCSI scan failed without making any progress, switching to async\n");
3799 }
3800
3801 queue_delayed_work(system_long_wq, &ap->hotplug_task,
3802 round_jiffies_relative(HZ));
3803 }
3804
3805 /**
3806 * ata_scsi_offline_dev - offline attached SCSI device
3807 * @dev: ATA device to offline attached SCSI device for
3808 *
3809 * This function is called from ata_eh_hotplug() and responsible
3810 * for taking the SCSI device attached to @dev offline. This
3811 * function is called with host lock which protects dev->sdev
3812 * against clearing.
3813 *
3814 * LOCKING:
3815 * spin_lock_irqsave(host lock)
3816 *
3817 * RETURNS:
3818 * 1 if attached SCSI device exists, 0 otherwise.
3819 */
3820 int ata_scsi_offline_dev(struct ata_device *dev)
3821 {
3822 if (dev->sdev) {
3823 scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
3824 return 1;
3825 }
3826 return 0;
3827 }
3828
3829 /**
3830 * ata_scsi_remove_dev - remove attached SCSI device
3831 * @dev: ATA device to remove attached SCSI device for
3832 *
3833 * This function is called from ata_eh_scsi_hotplug() and
3834 * responsible for removing the SCSI device attached to @dev.
3835 *
3836 * LOCKING:
3837 * Kernel thread context (may sleep).
3838 */
3839 static void ata_scsi_remove_dev(struct ata_device *dev)
3840 {
3841 struct ata_port *ap = dev->link->ap;
3842 struct scsi_device *sdev;
3843 unsigned long flags;
3844
3845 /* Alas, we need to grab scan_mutex to ensure SCSI device
3846 * state doesn't change underneath us and thus
3847 * scsi_device_get() always succeeds. The mutex locking can
3848 * be removed if there is __scsi_device_get() interface which
3849 * increments reference counts regardless of device state.
3850 */
3851 mutex_lock(&ap->scsi_host->scan_mutex);
3852 spin_lock_irqsave(ap->lock, flags);
3853
3854 /* clearing dev->sdev is protected by host lock */
3855 sdev = dev->sdev;
3856 dev->sdev = NULL;
3857
3858 if (sdev) {
3859 /* If user initiated unplug races with us, sdev can go
3860 * away underneath us after the host lock and
3861 * scan_mutex are released. Hold onto it.
3862 */
3863 if (scsi_device_get(sdev) == 0) {
3864 /* The following ensures the attached sdev is
3865 * offline on return from ata_scsi_offline_dev()
3866 * regardless it wins or loses the race
3867 * against this function.
3868 */
3869 scsi_device_set_state(sdev, SDEV_OFFLINE);
3870 } else {
3871 WARN_ON(1);
3872 sdev = NULL;
3873 }
3874 }
3875
3876 spin_unlock_irqrestore(ap->lock, flags);
3877 mutex_unlock(&ap->scsi_host->scan_mutex);
3878
3879 if (sdev) {
3880 ata_dev_info(dev, "detaching (SCSI %s)\n",
3881 dev_name(&sdev->sdev_gendev));
3882
3883 scsi_remove_device(sdev);
3884 scsi_device_put(sdev);
3885 }
3886 }
3887
3888 static void ata_scsi_handle_link_detach(struct ata_link *link)
3889 {
3890 struct ata_port *ap = link->ap;
3891 struct ata_device *dev;
3892
3893 ata_for_each_dev(dev, link, ALL) {
3894 unsigned long flags;
3895
3896 if (!(dev->flags & ATA_DFLAG_DETACHED))
3897 continue;
3898
3899 spin_lock_irqsave(ap->lock, flags);
3900 dev->flags &= ~ATA_DFLAG_DETACHED;
3901 spin_unlock_irqrestore(ap->lock, flags);
3902
3903 if (zpodd_dev_enabled(dev))
3904 zpodd_exit(dev);
3905
3906 ata_scsi_remove_dev(dev);
3907 }
3908 }
3909
3910 /**
3911 * ata_scsi_media_change_notify - send media change event
3912 * @dev: Pointer to the disk device with media change event
3913 *
3914 * Tell the block layer to send a media change notification
3915 * event.
3916 *
3917 * LOCKING:
3918 * spin_lock_irqsave(host lock)
3919 */
3920 void ata_scsi_media_change_notify(struct ata_device *dev)
3921 {
3922 if (dev->sdev)
3923 sdev_evt_send_simple(dev->sdev, SDEV_EVT_MEDIA_CHANGE,
3924 GFP_ATOMIC);
3925 }
3926
3927 /**
3928 * ata_scsi_hotplug - SCSI part of hotplug
3929 * @work: Pointer to ATA port to perform SCSI hotplug on
3930 *
3931 * Perform SCSI part of hotplug. It's executed from a separate
3932 * workqueue after EH completes. This is necessary because SCSI
3933 * hot plugging requires working EH and hot unplugging is
3934 * synchronized with hot plugging with a mutex.
3935 *
3936 * LOCKING:
3937 * Kernel thread context (may sleep).
3938 */
3939 void ata_scsi_hotplug(struct work_struct *work)
3940 {
3941 struct ata_port *ap =
3942 container_of(work, struct ata_port, hotplug_task.work);
3943 int i;
3944
3945 if (ap->pflags & ATA_PFLAG_UNLOADING) {
3946 DPRINTK("ENTER/EXIT - unloading\n");
3947 return;
3948 }
3949
3950 /*
3951 * XXX - UGLY HACK
3952 *
3953 * The block layer suspend/resume path is fundamentally broken due
3954 * to freezable kthreads and workqueue and may deadlock if a block
3955 * device gets removed while resume is in progress. I don't know
3956 * what the solution is short of removing freezable kthreads and
3957 * workqueues altogether.
3958 *
3959 * The following is an ugly hack to avoid kicking off device
3960 * removal while freezer is active. This is a joke but does avoid
3961 * this particular deadlock scenario.
3962 *
3963 * https://bugzilla.kernel.org/show_bug.cgi?id=62801
3964 * http://marc.info/?l=linux-kernel&m=138695698516487
3965 */
3966 #ifdef CONFIG_FREEZER
3967 while (pm_freezing)
3968 msleep(10);
3969 #endif
3970
3971 DPRINTK("ENTER\n");
3972 mutex_lock(&ap->scsi_scan_mutex);
3973
3974 /* Unplug detached devices. We cannot use link iterator here
3975 * because PMP links have to be scanned even if PMP is
3976 * currently not attached. Iterate manually.
3977 */
3978 ata_scsi_handle_link_detach(&ap->link);
3979 if (ap->pmp_link)
3980 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
3981 ata_scsi_handle_link_detach(&ap->pmp_link[i]);
3982
3983 /* scan for new ones */
3984 ata_scsi_scan_host(ap, 0);
3985
3986 mutex_unlock(&ap->scsi_scan_mutex);
3987 DPRINTK("EXIT\n");
3988 }
3989
3990 /**
3991 * ata_scsi_user_scan - indication for user-initiated bus scan
3992 * @shost: SCSI host to scan
3993 * @channel: Channel to scan
3994 * @id: ID to scan
3995 * @lun: LUN to scan
3996 *
3997 * This function is called when user explicitly requests bus
3998 * scan. Set probe pending flag and invoke EH.
3999 *
4000 * LOCKING:
4001 * SCSI layer (we don't care)
4002 *
4003 * RETURNS:
4004 * Zero.
4005 */
4006 int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
4007 unsigned int id, u64 lun)
4008 {
4009 struct ata_port *ap = ata_shost_to_port(shost);
4010 unsigned long flags;
4011 int devno, rc = 0;
4012
4013 if (!ap->ops->error_handler)
4014 return -EOPNOTSUPP;
4015
4016 if (lun != SCAN_WILD_CARD && lun)
4017 return -EINVAL;
4018
4019 if (!sata_pmp_attached(ap)) {
4020 if (channel != SCAN_WILD_CARD && channel)
4021 return -EINVAL;
4022 devno = id;
4023 } else {
4024 if (id != SCAN_WILD_CARD && id)
4025 return -EINVAL;
4026 devno = channel;
4027 }
4028
4029 spin_lock_irqsave(ap->lock, flags);
4030
4031 if (devno == SCAN_WILD_CARD) {
4032 struct ata_link *link;
4033
4034 ata_for_each_link(link, ap, EDGE) {
4035 struct ata_eh_info *ehi = &link->eh_info;
4036 ehi->probe_mask |= ATA_ALL_DEVICES;
4037 ehi->action |= ATA_EH_RESET;
4038 }
4039 } else {
4040 struct ata_device *dev = ata_find_dev(ap, devno);
4041
4042 if (dev) {
4043 struct ata_eh_info *ehi = &dev->link->eh_info;
4044 ehi->probe_mask |= 1 << dev->devno;
4045 ehi->action |= ATA_EH_RESET;
4046 } else
4047 rc = -EINVAL;
4048 }
4049
4050 if (rc == 0) {
4051 ata_port_schedule_eh(ap);
4052 spin_unlock_irqrestore(ap->lock, flags);
4053 ata_port_wait_eh(ap);
4054 } else
4055 spin_unlock_irqrestore(ap->lock, flags);
4056
4057 return rc;
4058 }
4059
4060 /**
4061 * ata_scsi_dev_rescan - initiate scsi_rescan_device()
4062 * @work: Pointer to ATA port to perform scsi_rescan_device()
4063 *
4064 * After ATA pass thru (SAT) commands are executed successfully,
4065 * libata need to propagate the changes to SCSI layer.
4066 *
4067 * LOCKING:
4068 * Kernel thread context (may sleep).
4069 */
4070 void ata_scsi_dev_rescan(struct work_struct *work)
4071 {
4072 struct ata_port *ap =
4073 container_of(work, struct ata_port, scsi_rescan_task);
4074 struct ata_link *link;
4075 struct ata_device *dev;
4076 unsigned long flags;
4077
4078 mutex_lock(&ap->scsi_scan_mutex);
4079 spin_lock_irqsave(ap->lock, flags);
4080
4081 ata_for_each_link(link, ap, EDGE) {
4082 ata_for_each_dev(dev, link, ENABLED) {
4083 struct scsi_device *sdev = dev->sdev;
4084
4085 if (!sdev)
4086 continue;
4087 if (scsi_device_get(sdev))
4088 continue;
4089
4090 spin_unlock_irqrestore(ap->lock, flags);
4091 scsi_rescan_device(&(sdev->sdev_gendev));
4092 scsi_device_put(sdev);
4093 spin_lock_irqsave(ap->lock, flags);
4094 }
4095 }
4096
4097 spin_unlock_irqrestore(ap->lock, flags);
4098 mutex_unlock(&ap->scsi_scan_mutex);
4099 }
4100
4101 /**
4102 * ata_sas_port_alloc - Allocate port for a SAS attached SATA device
4103 * @host: ATA host container for all SAS ports
4104 * @port_info: Information from low-level host driver
4105 * @shost: SCSI host that the scsi device is attached to
4106 *
4107 * LOCKING:
4108 * PCI/etc. bus probe sem.
4109 *
4110 * RETURNS:
4111 * ata_port pointer on success / NULL on failure.
4112 */
4113
4114 struct ata_port *ata_sas_port_alloc(struct ata_host *host,
4115 struct ata_port_info *port_info,
4116 struct Scsi_Host *shost)
4117 {
4118 struct ata_port *ap;
4119
4120 ap = ata_port_alloc(host);
4121 if (!ap)
4122 return NULL;
4123
4124 ap->port_no = 0;
4125 ap->lock = &host->lock;
4126 ap->pio_mask = port_info->pio_mask;
4127 ap->mwdma_mask = port_info->mwdma_mask;
4128 ap->udma_mask = port_info->udma_mask;
4129 ap->flags |= port_info->flags;
4130 ap->ops = port_info->port_ops;
4131 ap->cbl = ATA_CBL_SATA;
4132
4133 return ap;
4134 }
4135 EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
4136
4137 /**
4138 * ata_sas_port_start - Set port up for dma.
4139 * @ap: Port to initialize
4140 *
4141 * Called just after data structures for each port are
4142 * initialized.
4143 *
4144 * May be used as the port_start() entry in ata_port_operations.
4145 *
4146 * LOCKING:
4147 * Inherited from caller.
4148 */
4149 int ata_sas_port_start(struct ata_port *ap)
4150 {
4151 /*
4152 * the port is marked as frozen at allocation time, but if we don't
4153 * have new eh, we won't thaw it
4154 */
4155 if (!ap->ops->error_handler)
4156 ap->pflags &= ~ATA_PFLAG_FROZEN;
4157 return 0;
4158 }
4159 EXPORT_SYMBOL_GPL(ata_sas_port_start);
4160
4161 /**
4162 * ata_port_stop - Undo ata_sas_port_start()
4163 * @ap: Port to shut down
4164 *
4165 * May be used as the port_stop() entry in ata_port_operations.
4166 *
4167 * LOCKING:
4168 * Inherited from caller.
4169 */
4170
4171 void ata_sas_port_stop(struct ata_port *ap)
4172 {
4173 }
4174 EXPORT_SYMBOL_GPL(ata_sas_port_stop);
4175
4176 /**
4177 * ata_sas_async_probe - simply schedule probing and return
4178 * @ap: Port to probe
4179 *
4180 * For batch scheduling of probe for sas attached ata devices, assumes
4181 * the port has already been through ata_sas_port_init()
4182 */
4183 void ata_sas_async_probe(struct ata_port *ap)
4184 {
4185 __ata_port_probe(ap);
4186 }
4187 EXPORT_SYMBOL_GPL(ata_sas_async_probe);
4188
4189 int ata_sas_sync_probe(struct ata_port *ap)
4190 {
4191 return ata_port_probe(ap);
4192 }
4193 EXPORT_SYMBOL_GPL(ata_sas_sync_probe);
4194
4195
4196 /**
4197 * ata_sas_port_init - Initialize a SATA device
4198 * @ap: SATA port to initialize
4199 *
4200 * LOCKING:
4201 * PCI/etc. bus probe sem.
4202 *
4203 * RETURNS:
4204 * Zero on success, non-zero on error.
4205 */
4206
4207 int ata_sas_port_init(struct ata_port *ap)
4208 {
4209 int rc = ap->ops->port_start(ap);
4210
4211 if (rc)
4212 return rc;
4213 ap->print_id = atomic_inc_return(&ata_print_id);
4214 return 0;
4215 }
4216 EXPORT_SYMBOL_GPL(ata_sas_port_init);
4217
4218 /**
4219 * ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc
4220 * @ap: SATA port to destroy
4221 *
4222 */
4223
4224 void ata_sas_port_destroy(struct ata_port *ap)
4225 {
4226 if (ap->ops->port_stop)
4227 ap->ops->port_stop(ap);
4228 kfree(ap);
4229 }
4230 EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
4231
4232 /**
4233 * ata_sas_slave_configure - Default slave_config routine for libata devices
4234 * @sdev: SCSI device to configure
4235 * @ap: ATA port to which SCSI device is attached
4236 *
4237 * RETURNS:
4238 * Zero.
4239 */
4240
4241 int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
4242 {
4243 ata_scsi_sdev_config(sdev);
4244 ata_scsi_dev_config(sdev, ap->link.device);
4245 return 0;
4246 }
4247 EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
4248
4249 /**
4250 * ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
4251 * @cmd: SCSI command to be sent
4252 * @ap: ATA port to which the command is being sent
4253 *
4254 * RETURNS:
4255 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
4256 * 0 otherwise.
4257 */
4258
4259 int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap)
4260 {
4261 int rc = 0;
4262
4263 ata_scsi_dump_cdb(ap, cmd);
4264
4265 if (likely(ata_dev_enabled(ap->link.device)))
4266 rc = __ata_scsi_queuecmd(cmd, ap->link.device);
4267 else {
4268 cmd->result = (DID_BAD_TARGET << 16);
4269 cmd->scsi_done(cmd);
4270 }
4271 return rc;
4272 }
4273 EXPORT_SYMBOL_GPL(ata_sas_queuecmd);
4274
4275 int ata_sas_allocate_tag(struct ata_port *ap)
4276 {
4277 unsigned int max_queue = ap->host->n_tags;
4278 unsigned int i, tag;
4279
4280 for (i = 0, tag = ap->sas_last_tag + 1; i < max_queue; i++, tag++) {
4281 tag = tag < max_queue ? tag : 0;
4282
4283 /* the last tag is reserved for internal command. */
4284 if (tag == ATA_TAG_INTERNAL)
4285 continue;
4286
4287 if (!test_and_set_bit(tag, &ap->sas_tag_allocated)) {
4288 ap->sas_last_tag = tag;
4289 return tag;
4290 }
4291 }
4292 return -1;
4293 }
4294
4295 void ata_sas_free_tag(unsigned int tag, struct ata_port *ap)
4296 {
4297 clear_bit(tag, &ap->sas_tag_allocated);
4298 }
(deprecated) Btrfs devel tree