1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/compat.h>
17#include <linux/slab.h>
18#include <linux/kernel.h>
19#include <linux/blkdev.h>
20#include <linux/spinlock.h>
21#include <linux/export.h>
22#include <scsi/scsi.h>
23#include <scsi/scsi_host.h>
24#include <scsi/scsi_cmnd.h>
25#include <scsi/scsi_eh.h>
26#include <scsi/scsi_device.h>
27#include <scsi/scsi_tcq.h>
28#include <scsi/scsi_transport.h>
29#include <linux/libata.h>
30#include <linux/hdreg.h>
31#include <linux/uaccess.h>
32#include <linux/suspend.h>
33#include <asm/unaligned.h>
34#include <linux/ioprio.h>
35#include <linux/of.h>
36
37#include "libata.h"
38#include "libata-transport.h"
39
40#define ATA_SCSI_RBUF_SIZE 576
41
42static DEFINE_SPINLOCK(ata_scsi_rbuf_lock);
43static u8 ata_scsi_rbuf[ATA_SCSI_RBUF_SIZE];
44
45typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc);
46
47static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
48 const struct scsi_device *scsidev);
49
50#define RW_RECOVERY_MPAGE 0x1
51#define RW_RECOVERY_MPAGE_LEN 12
52#define CACHE_MPAGE 0x8
53#define CACHE_MPAGE_LEN 20
54#define CONTROL_MPAGE 0xa
55#define CONTROL_MPAGE_LEN 12
56#define ALL_MPAGES 0x3f
57#define ALL_SUB_MPAGES 0xff
58
59
60static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = {
61 RW_RECOVERY_MPAGE,
62 RW_RECOVERY_MPAGE_LEN - 2,
63 (1 << 7),
64 0,
65 0, 0, 0, 0,
66 0,
67 0, 0, 0
68};
69
70static const u8 def_cache_mpage[CACHE_MPAGE_LEN] = {
71 CACHE_MPAGE,
72 CACHE_MPAGE_LEN - 2,
73 0,
74 0, 0, 0, 0, 0, 0, 0, 0, 0,
75 0,
76 0, 0, 0, 0, 0, 0, 0
77};
78
79static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
80 CONTROL_MPAGE,
81 CONTROL_MPAGE_LEN - 2,
82 2,
83 0,
84 0, 0, 0, 0, 0xff, 0xff,
85 0, 30
86};
87
88static ssize_t ata_scsi_park_show(struct device *device,
89 struct device_attribute *attr, char *buf)
90{
91 struct scsi_device *sdev = to_scsi_device(device);
92 struct ata_port *ap;
93 struct ata_link *link;
94 struct ata_device *dev;
95 unsigned long now;
96 unsigned int msecs;
97 int rc = 0;
98
99 ap = ata_shost_to_port(sdev->host);
100
101 spin_lock_irq(ap->lock);
102 dev = ata_scsi_find_dev(ap, sdev);
103 if (!dev) {
104 rc = -ENODEV;
105 goto unlock;
106 }
107 if (dev->flags & ATA_DFLAG_NO_UNLOAD) {
108 rc = -EOPNOTSUPP;
109 goto unlock;
110 }
111
112 link = dev->link;
113 now = jiffies;
114 if (ap->pflags & ATA_PFLAG_EH_IN_PROGRESS &&
115 link->eh_context.unloaded_mask & (1 << dev->devno) &&
116 time_after(dev->unpark_deadline, now))
117 msecs = jiffies_to_msecs(dev->unpark_deadline - now);
118 else
119 msecs = 0;
120
121unlock:
122 spin_unlock_irq(ap->lock);
123
124 return rc ? rc : snprintf(buf, 20, "%u\n", msecs);
125}
126
127static ssize_t ata_scsi_park_store(struct device *device,
128 struct device_attribute *attr,
129 const char *buf, size_t len)
130{
131 struct scsi_device *sdev = to_scsi_device(device);
132 struct ata_port *ap;
133 struct ata_device *dev;
134 long int input;
135 unsigned long flags;
136 int rc;
137
138 rc = kstrtol(buf, 10, &input);
139 if (rc)
140 return rc;
141 if (input < -2)
142 return -EINVAL;
143 if (input > ATA_TMOUT_MAX_PARK) {
144 rc = -EOVERFLOW;
145 input = ATA_TMOUT_MAX_PARK;
146 }
147
148 ap = ata_shost_to_port(sdev->host);
149
150 spin_lock_irqsave(ap->lock, flags);
151 dev = ata_scsi_find_dev(ap, sdev);
152 if (unlikely(!dev)) {
153 rc = -ENODEV;
154 goto unlock;
155 }
156 if (dev->class != ATA_DEV_ATA &&
157 dev->class != ATA_DEV_ZAC) {
158 rc = -EOPNOTSUPP;
159 goto unlock;
160 }
161
162 if (input >= 0) {
163 if (dev->flags & ATA_DFLAG_NO_UNLOAD) {
164 rc = -EOPNOTSUPP;
165 goto unlock;
166 }
167
168 dev->unpark_deadline = ata_deadline(jiffies, input);
169 dev->link->eh_info.dev_action[dev->devno] |= ATA_EH_PARK;
170 ata_port_schedule_eh(ap);
171 complete(&ap->park_req_pending);
172 } else {
173 switch (input) {
174 case -1:
175 dev->flags &= ~ATA_DFLAG_NO_UNLOAD;
176 break;
177 case -2:
178 dev->flags |= ATA_DFLAG_NO_UNLOAD;
179 break;
180 }
181 }
182unlock:
183 spin_unlock_irqrestore(ap->lock, flags);
184
185 return rc ? rc : len;
186}
187DEVICE_ATTR(unload_heads, S_IRUGO | S_IWUSR,
188 ata_scsi_park_show, ata_scsi_park_store);
189EXPORT_SYMBOL_GPL(dev_attr_unload_heads);
190
191void ata_scsi_set_sense(struct ata_device *dev, struct scsi_cmnd *cmd,
192 u8 sk, u8 asc, u8 ascq)
193{
194 bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE);
195
196 if (!cmd)
197 return;
198
199 scsi_build_sense(cmd, d_sense, sk, asc, ascq);
200}
201
202void ata_scsi_set_sense_information(struct ata_device *dev,
203 struct scsi_cmnd *cmd,
204 const struct ata_taskfile *tf)
205{
206 u64 information;
207
208 if (!cmd)
209 return;
210
211 information = ata_tf_read_block(tf, dev);
212 if (information == U64_MAX)
213 return;
214
215 scsi_set_sense_information(cmd->sense_buffer,
216 SCSI_SENSE_BUFFERSIZE, information);
217}
218
219static void ata_scsi_set_invalid_field(struct ata_device *dev,
220 struct scsi_cmnd *cmd, u16 field, u8 bit)
221{
222 ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x24, 0x0);
223
224 scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
225 field, bit, 1);
226}
227
228static void ata_scsi_set_invalid_parameter(struct ata_device *dev,
229 struct scsi_cmnd *cmd, u16 field)
230{
231
232 ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x26, 0x0);
233 scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
234 field, 0xff, 0);
235}
236
237static struct attribute *ata_common_sdev_attrs[] = {
238 &dev_attr_unload_heads.attr,
239 NULL
240};
241
242static const struct attribute_group ata_common_sdev_attr_group = {
243 .attrs = ata_common_sdev_attrs
244};
245
246const struct attribute_group *ata_common_sdev_groups[] = {
247 &ata_common_sdev_attr_group,
248 NULL
249};
250EXPORT_SYMBOL_GPL(ata_common_sdev_groups);
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
271 sector_t capacity, int geom[])
272{
273 geom[0] = 255;
274 geom[1] = 63;
275 sector_div(capacity, 255*63);
276 geom[2] = capacity;
277
278 return 0;
279}
280EXPORT_SYMBOL_GPL(ata_std_bios_param);
281
282
283
284
285
286
287
288
289
290
291
292void ata_scsi_unlock_native_capacity(struct scsi_device *sdev)
293{
294 struct ata_port *ap = ata_shost_to_port(sdev->host);
295 struct ata_device *dev;
296 unsigned long flags;
297
298 spin_lock_irqsave(ap->lock, flags);
299
300 dev = ata_scsi_find_dev(ap, sdev);
301 if (dev && dev->n_sectors < dev->n_native_sectors) {
302 dev->flags |= ATA_DFLAG_UNLOCK_HPA;
303 dev->link->eh_info.action |= ATA_EH_RESET;
304 ata_port_schedule_eh(ap);
305 }
306
307 spin_unlock_irqrestore(ap->lock, flags);
308 ata_port_wait_eh(ap);
309}
310EXPORT_SYMBOL_GPL(ata_scsi_unlock_native_capacity);
311
312
313
314
315
316
317
318
319
320
321
322
323
324static int ata_get_identity(struct ata_port *ap, struct scsi_device *sdev,
325 void __user *arg)
326{
327 struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
328 u16 __user *dst = arg;
329 char buf[40];
330
331 if (!dev)
332 return -ENOMSG;
333
334 if (copy_to_user(dst, dev->id, ATA_ID_WORDS * sizeof(u16)))
335 return -EFAULT;
336
337 ata_id_string(dev->id, buf, ATA_ID_PROD, ATA_ID_PROD_LEN);
338 if (copy_to_user(dst + ATA_ID_PROD, buf, ATA_ID_PROD_LEN))
339 return -EFAULT;
340
341 ata_id_string(dev->id, buf, ATA_ID_FW_REV, ATA_ID_FW_REV_LEN);
342 if (copy_to_user(dst + ATA_ID_FW_REV, buf, ATA_ID_FW_REV_LEN))
343 return -EFAULT;
344
345 ata_id_string(dev->id, buf, ATA_ID_SERNO, ATA_ID_SERNO_LEN);
346 if (copy_to_user(dst + ATA_ID_SERNO, buf, ATA_ID_SERNO_LEN))
347 return -EFAULT;
348
349 return 0;
350}
351
352
353
354
355
356
357
358
359
360
361
362
363int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
364{
365 int rc = 0;
366 u8 sensebuf[SCSI_SENSE_BUFFERSIZE];
367 u8 scsi_cmd[MAX_COMMAND_SIZE];
368 u8 args[4], *argbuf = NULL;
369 int argsize = 0;
370 enum dma_data_direction data_dir;
371 struct scsi_sense_hdr sshdr;
372 int cmd_result;
373
374 if (arg == NULL)
375 return -EINVAL;
376
377 if (copy_from_user(args, arg, sizeof(args)))
378 return -EFAULT;
379
380 memset(sensebuf, 0, sizeof(sensebuf));
381 memset(scsi_cmd, 0, sizeof(scsi_cmd));
382
383 if (args[3]) {
384 argsize = ATA_SECT_SIZE * args[3];
385 argbuf = kmalloc(argsize, GFP_KERNEL);
386 if (argbuf == NULL) {
387 rc = -ENOMEM;
388 goto error;
389 }
390
391 scsi_cmd[1] = (4 << 1);
392 scsi_cmd[2] = 0x0e;
393
394 data_dir = DMA_FROM_DEVICE;
395 } else {
396 scsi_cmd[1] = (3 << 1);
397 scsi_cmd[2] = 0x20;
398 data_dir = DMA_NONE;
399 }
400
401 scsi_cmd[0] = ATA_16;
402
403 scsi_cmd[4] = args[2];
404 if (args[0] == ATA_CMD_SMART) {
405 scsi_cmd[6] = args[3];
406 scsi_cmd[8] = args[1];
407 scsi_cmd[10] = ATA_SMART_LBAM_PASS;
408 scsi_cmd[12] = ATA_SMART_LBAH_PASS;
409 } else {
410 scsi_cmd[6] = args[1];
411 }
412 scsi_cmd[14] = args[0];
413
414
415
416 cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
417 sensebuf, &sshdr, (10*HZ), 5, 0, 0, NULL);
418
419 if (cmd_result < 0) {
420 rc = cmd_result;
421 goto error;
422 }
423 if (scsi_sense_valid(&sshdr)) {
424 u8 *desc = sensebuf + 8;
425
426
427
428 if (scsi_status_is_check_condition(cmd_result)) {
429 if (sshdr.sense_key == RECOVERED_ERROR &&
430 sshdr.asc == 0 && sshdr.ascq == 0x1d)
431 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
432 }
433
434
435 if (sensebuf[0] == 0x72 &&
436 desc[0] == 0x09) {
437 args[0] = desc[13];
438 args[1] = desc[3];
439 args[2] = desc[5];
440 if (copy_to_user(arg, args, sizeof(args)))
441 rc = -EFAULT;
442 }
443 }
444
445
446 if (cmd_result) {
447 rc = -EIO;
448 goto error;
449 }
450
451 if ((argbuf)
452 && copy_to_user(arg + sizeof(args), argbuf, argsize))
453 rc = -EFAULT;
454error:
455 kfree(argbuf);
456 return rc;
457}
458
459
460
461
462
463
464
465
466
467
468
469
470int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
471{
472 int rc = 0;
473 u8 sensebuf[SCSI_SENSE_BUFFERSIZE];
474 u8 scsi_cmd[MAX_COMMAND_SIZE];
475 u8 args[7];
476 struct scsi_sense_hdr sshdr;
477 int cmd_result;
478
479 if (arg == NULL)
480 return -EINVAL;
481
482 if (copy_from_user(args, arg, sizeof(args)))
483 return -EFAULT;
484
485 memset(sensebuf, 0, sizeof(sensebuf));
486 memset(scsi_cmd, 0, sizeof(scsi_cmd));
487 scsi_cmd[0] = ATA_16;
488 scsi_cmd[1] = (3 << 1);
489 scsi_cmd[2] = 0x20;
490 scsi_cmd[4] = args[1];
491 scsi_cmd[6] = args[2];
492 scsi_cmd[8] = args[3];
493 scsi_cmd[10] = args[4];
494 scsi_cmd[12] = args[5];
495 scsi_cmd[13] = args[6] & 0x4f;
496 scsi_cmd[14] = args[0];
497
498
499
500 cmd_result = scsi_execute(scsidev, scsi_cmd, DMA_NONE, NULL, 0,
501 sensebuf, &sshdr, (10*HZ), 5, 0, 0, NULL);
502
503 if (cmd_result < 0) {
504 rc = cmd_result;
505 goto error;
506 }
507 if (scsi_sense_valid(&sshdr)) {
508 u8 *desc = sensebuf + 8;
509
510
511
512 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
513 if (sshdr.sense_key == RECOVERED_ERROR &&
514 sshdr.asc == 0 && sshdr.ascq == 0x1d)
515 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
516 }
517
518
519 if (sensebuf[0] == 0x72 &&
520 desc[0] == 0x09) {
521 args[0] = desc[13];
522 args[1] = desc[3];
523 args[2] = desc[5];
524 args[3] = desc[7];
525 args[4] = desc[9];
526 args[5] = desc[11];
527 args[6] = desc[12];
528 if (copy_to_user(arg, args, sizeof(args)))
529 rc = -EFAULT;
530 }
531 }
532
533 if (cmd_result) {
534 rc = -EIO;
535 goto error;
536 }
537
538 error:
539 return rc;
540}
541
542static int ata_ioc32(struct ata_port *ap)
543{
544 if (ap->flags & ATA_FLAG_PIO_DMA)
545 return 1;
546 if (ap->pflags & ATA_PFLAG_PIO32)
547 return 1;
548 return 0;
549}
550
551
552
553
554
555int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *scsidev,
556 unsigned int cmd, void __user *arg)
557{
558 unsigned long val;
559 int rc = -EINVAL;
560 unsigned long flags;
561
562 switch (cmd) {
563 case HDIO_GET_32BIT:
564 spin_lock_irqsave(ap->lock, flags);
565 val = ata_ioc32(ap);
566 spin_unlock_irqrestore(ap->lock, flags);
567#ifdef CONFIG_COMPAT
568 if (in_compat_syscall())
569 return put_user(val, (compat_ulong_t __user *)arg);
570#endif
571 return put_user(val, (unsigned long __user *)arg);
572
573 case HDIO_SET_32BIT:
574 val = (unsigned long) arg;
575 rc = 0;
576 spin_lock_irqsave(ap->lock, flags);
577 if (ap->pflags & ATA_PFLAG_PIO32CHANGE) {
578 if (val)
579 ap->pflags |= ATA_PFLAG_PIO32;
580 else
581 ap->pflags &= ~ATA_PFLAG_PIO32;
582 } else {
583 if (val != ata_ioc32(ap))
584 rc = -EINVAL;
585 }
586 spin_unlock_irqrestore(ap->lock, flags);
587 return rc;
588
589 case HDIO_GET_IDENTITY:
590 return ata_get_identity(ap, scsidev, arg);
591
592 case HDIO_DRIVE_CMD:
593 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
594 return -EACCES;
595 return ata_cmd_ioctl(scsidev, arg);
596
597 case HDIO_DRIVE_TASK:
598 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
599 return -EACCES;
600 return ata_task_ioctl(scsidev, arg);
601
602 default:
603 rc = -ENOTTY;
604 break;
605 }
606
607 return rc;
608}
609EXPORT_SYMBOL_GPL(ata_sas_scsi_ioctl);
610
611int ata_scsi_ioctl(struct scsi_device *scsidev, unsigned int cmd,
612 void __user *arg)
613{
614 return ata_sas_scsi_ioctl(ata_shost_to_port(scsidev->host),
615 scsidev, cmd, arg);
616}
617EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
639 struct scsi_cmnd *cmd)
640{
641 struct ata_queued_cmd *qc;
642
643 qc = ata_qc_new_init(dev, scsi_cmd_to_rq(cmd)->tag);
644 if (qc) {
645 qc->scsicmd = cmd;
646 qc->scsidone = scsi_done;
647
648 qc->sg = scsi_sglist(cmd);
649 qc->n_elem = scsi_sg_count(cmd);
650
651 if (scsi_cmd_to_rq(cmd)->rq_flags & RQF_QUIET)
652 qc->flags |= ATA_QCFLAG_QUIET;
653 } else {
654 cmd->result = (DID_OK << 16) | SAM_STAT_TASK_SET_FULL;
655 scsi_done(cmd);
656 }
657
658 return qc;
659}
660
661static void ata_qc_set_pc_nbytes(struct ata_queued_cmd *qc)
662{
663 struct scsi_cmnd *scmd = qc->scsicmd;
664
665 qc->extrabytes = scmd->extra_len;
666 qc->nbytes = scsi_bufflen(scmd) + qc->extrabytes;
667}
668
669
670
671
672
673
674
675
676
677
678
679
680
681static void ata_dump_status(unsigned id, struct ata_taskfile *tf)
682{
683 u8 stat = tf->command, err = tf->feature;
684
685 pr_warn("ata%u: status=0x%02x { ", id, stat);
686 if (stat & ATA_BUSY) {
687 pr_cont("Busy }\n");
688 } else {
689 if (stat & ATA_DRDY) pr_cont("DriveReady ");
690 if (stat & ATA_DF) pr_cont("DeviceFault ");
691 if (stat & ATA_DSC) pr_cont("SeekComplete ");
692 if (stat & ATA_DRQ) pr_cont("DataRequest ");
693 if (stat & ATA_CORR) pr_cont("CorrectedError ");
694 if (stat & ATA_SENSE) pr_cont("Sense ");
695 if (stat & ATA_ERR) pr_cont("Error ");
696 pr_cont("}\n");
697
698 if (err) {
699 pr_warn("ata%u: error=0x%02x { ", id, err);
700 if (err & ATA_ABORTED) pr_cont("DriveStatusError ");
701 if (err & ATA_ICRC) {
702 if (err & ATA_ABORTED)
703 pr_cont("BadCRC ");
704 else pr_cont("Sector ");
705 }
706 if (err & ATA_UNC) pr_cont("UncorrectableError ");
707 if (err & ATA_IDNF) pr_cont("SectorIdNotFound ");
708 if (err & ATA_TRK0NF) pr_cont("TrackZeroNotFound ");
709 if (err & ATA_AMNF) pr_cont("AddrMarkNotFound ");
710 pr_cont("}\n");
711 }
712 }
713}
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732static void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk,
733 u8 *asc, u8 *ascq, int verbose)
734{
735 int i;
736
737
738 static const unsigned char sense_table[][4] = {
739
740 {0xd1, ABORTED_COMMAND, 0x00, 0x00},
741
742
743 {0xd0, ABORTED_COMMAND, 0x00, 0x00},
744
745
746 {0x61, HARDWARE_ERROR, 0x00, 0x00},
747
748
749 {0x84, ABORTED_COMMAND, 0x47, 0x00},
750
751
752 {0x37, NOT_READY, 0x04, 0x00},
753
754
755 {0x09, NOT_READY, 0x04, 0x00},
756
757
758 {0x01, MEDIUM_ERROR, 0x13, 0x00},
759
760
761 {0x02, HARDWARE_ERROR, 0x00, 0x00},
762
763
764
765 {0x08, NOT_READY, 0x04, 0x00},
766
767
768 {0x10, ILLEGAL_REQUEST, 0x21, 0x00},
769
770
771 {0x20, UNIT_ATTENTION, 0x28, 0x00},
772
773
774 {0x40, MEDIUM_ERROR, 0x11, 0x04},
775
776
777 {0x80, MEDIUM_ERROR, 0x11, 0x04},
778
779 {0xFF, 0xFF, 0xFF, 0xFF},
780 };
781 static const unsigned char stat_table[][4] = {
782
783 {0x80, ABORTED_COMMAND, 0x47, 0x00},
784
785 {0x40, ILLEGAL_REQUEST, 0x21, 0x04},
786
787 {0x20, HARDWARE_ERROR, 0x44, 0x00},
788
789 {0x08, ABORTED_COMMAND, 0x47, 0x00},
790
791 {0x04, RECOVERED_ERROR, 0x11, 0x00},
792
793 {0xFF, 0xFF, 0xFF, 0xFF},
794 };
795
796
797
798
799 if (drv_stat & ATA_BUSY) {
800 drv_err = 0;
801 }
802
803 if (drv_err) {
804
805 for (i = 0; sense_table[i][0] != 0xFF; i++) {
806
807 if ((sense_table[i][0] & drv_err) ==
808 sense_table[i][0]) {
809 *sk = sense_table[i][1];
810 *asc = sense_table[i][2];
811 *ascq = sense_table[i][3];
812 goto translate_done;
813 }
814 }
815 }
816
817
818
819
820
821
822 for (i = 0; stat_table[i][0] != 0xFF; i++) {
823 if (stat_table[i][0] & drv_stat) {
824 *sk = stat_table[i][1];
825 *asc = stat_table[i][2];
826 *ascq = stat_table[i][3];
827 goto translate_done;
828 }
829 }
830
831
832
833
834
835 *sk = ABORTED_COMMAND;
836 *asc = 0x00;
837 *ascq = 0x00;
838
839 translate_done:
840 if (verbose)
841 pr_err("ata%u: translated ATA stat/err 0x%02x/%02x to SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n",
842 id, drv_stat, drv_err, *sk, *asc, *ascq);
843 return;
844}
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
864{
865 struct scsi_cmnd *cmd = qc->scsicmd;
866 struct ata_taskfile *tf = &qc->result_tf;
867 unsigned char *sb = cmd->sense_buffer;
868 unsigned char *desc = sb + 8;
869 int verbose = qc->ap->ops->error_handler == NULL;
870 u8 sense_key, asc, ascq;
871
872 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
873
874
875
876
877
878 if (qc->err_mask ||
879 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
880 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
881 &sense_key, &asc, &ascq, verbose);
882 ata_scsi_set_sense(qc->dev, cmd, sense_key, asc, ascq);
883 } else {
884
885
886
887
888 scsi_build_sense(cmd, 1, RECOVERED_ERROR, 0, 0x1D);
889 }
890
891 if ((cmd->sense_buffer[0] & 0x7f) >= 0x72) {
892 u8 len;
893
894
895 len = sb[7];
896 desc = (char *)scsi_sense_desc_find(sb, len + 8, 9);
897 if (!desc) {
898 if (SCSI_SENSE_BUFFERSIZE < len + 14)
899 return;
900 sb[7] = len + 14;
901 desc = sb + 8 + len;
902 }
903 desc[0] = 9;
904 desc[1] = 12;
905
906
907
908 desc[2] = 0x00;
909 desc[3] = tf->feature;
910 desc[5] = tf->nsect;
911 desc[7] = tf->lbal;
912 desc[9] = tf->lbam;
913 desc[11] = tf->lbah;
914 desc[12] = tf->device;
915 desc[13] = tf->command;
916
917
918
919
920
921 if (tf->flags & ATA_TFLAG_LBA48) {
922 desc[2] |= 0x01;
923 desc[4] = tf->hob_nsect;
924 desc[6] = tf->hob_lbal;
925 desc[8] = tf->hob_lbam;
926 desc[10] = tf->hob_lbah;
927 }
928 } else {
929
930 desc[0] = tf->feature;
931 desc[1] = tf->command;
932 desc[2] = tf->device;
933 desc[3] = tf->nsect;
934 desc[7] = 0;
935 if (tf->flags & ATA_TFLAG_LBA48) {
936 desc[8] |= 0x80;
937 if (tf->hob_nsect)
938 desc[8] |= 0x40;
939 if (tf->hob_lbal || tf->hob_lbam || tf->hob_lbah)
940 desc[8] |= 0x20;
941 }
942 desc[9] = tf->lbal;
943 desc[10] = tf->lbam;
944 desc[11] = tf->lbah;
945 }
946}
947
948
949
950
951
952
953
954
955
956
957
958static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
959{
960 struct ata_device *dev = qc->dev;
961 struct scsi_cmnd *cmd = qc->scsicmd;
962 struct ata_taskfile *tf = &qc->result_tf;
963 unsigned char *sb = cmd->sense_buffer;
964 int verbose = qc->ap->ops->error_handler == NULL;
965 u64 block;
966 u8 sense_key, asc, ascq;
967
968 memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
969
970 if (ata_dev_disabled(dev)) {
971
972
973 ata_scsi_set_sense(dev, cmd, NOT_READY, 0x04, 0x21);
974 return;
975 }
976
977
978
979 if (qc->err_mask ||
980 tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
981 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
982 &sense_key, &asc, &ascq, verbose);
983 ata_scsi_set_sense(dev, cmd, sense_key, asc, ascq);
984 } else {
985
986 ata_dev_warn(dev, "could not decode error status 0x%x err_mask 0x%x\n",
987 tf->command, qc->err_mask);
988 ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
989 return;
990 }
991
992 block = ata_tf_read_block(&qc->result_tf, dev);
993 if (block == U64_MAX)
994 return;
995
996 scsi_set_sense_information(sb, SCSI_SENSE_BUFFERSIZE, block);
997}
998
999void ata_scsi_sdev_config(struct scsi_device *sdev)
1000{
1001 sdev->use_10_for_rw = 1;
1002 sdev->use_10_for_ms = 1;
1003 sdev->no_write_same = 1;
1004
1005
1006
1007
1008
1009
1010 sdev->max_device_blocked = 1;
1011}
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028bool ata_scsi_dma_need_drain(struct request *rq)
1029{
1030 return atapi_cmd_type(scsi_req(rq)->cmd[0]) == ATAPI_MISC;
1031}
1032EXPORT_SYMBOL_GPL(ata_scsi_dma_need_drain);
1033
1034int ata_scsi_dev_config(struct scsi_device *sdev, struct ata_device *dev)
1035{
1036 struct request_queue *q = sdev->request_queue;
1037
1038 if (!ata_id_has_unload(dev->id))
1039 dev->flags |= ATA_DFLAG_NO_UNLOAD;
1040
1041
1042 blk_queue_max_hw_sectors(q, dev->max_sectors);
1043
1044 if (dev->class == ATA_DEV_ATAPI) {
1045 sdev->sector_size = ATA_SECT_SIZE;
1046
1047
1048 blk_queue_update_dma_pad(q, ATA_DMA_PAD_SZ - 1);
1049
1050
1051 blk_queue_max_segments(q, queue_max_segments(q) - 1);
1052
1053 sdev->dma_drain_len = ATAPI_MAX_DRAIN;
1054 sdev->dma_drain_buf = kmalloc(sdev->dma_drain_len, GFP_NOIO);
1055 if (!sdev->dma_drain_buf) {
1056 ata_dev_err(dev, "drain buffer allocation failed\n");
1057 return -ENOMEM;
1058 }
1059 } else {
1060 sdev->sector_size = ata_id_logical_sector_size(dev->id);
1061 sdev->manage_start_stop = 1;
1062 }
1063
1064
1065
1066
1067
1068
1069
1070
1071 if (sdev->sector_size > PAGE_SIZE)
1072 ata_dev_warn(dev,
1073 "sector_size=%u > PAGE_SIZE, PIO may malfunction\n",
1074 sdev->sector_size);
1075
1076 blk_queue_update_dma_alignment(q, sdev->sector_size - 1);
1077
1078 if (dev->flags & ATA_DFLAG_AN)
1079 set_bit(SDEV_EVT_MEDIA_CHANGE, sdev->supported_events);
1080
1081 if (dev->flags & ATA_DFLAG_NCQ) {
1082 int depth;
1083
1084 depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
1085 depth = min(ATA_MAX_QUEUE, depth);
1086 scsi_change_queue_depth(sdev, depth);
1087 }
1088
1089 if (dev->flags & ATA_DFLAG_TRUSTED)
1090 sdev->security_supported = 1;
1091
1092 dev->sdev = sdev;
1093 return 0;
1094}
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108int ata_scsi_slave_config(struct scsi_device *sdev)
1109{
1110 struct ata_port *ap = ata_shost_to_port(sdev->host);
1111 struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
1112 int rc = 0;
1113
1114 ata_scsi_sdev_config(sdev);
1115
1116 if (dev)
1117 rc = ata_scsi_dev_config(sdev, dev);
1118
1119 return rc;
1120}
1121EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137void ata_scsi_slave_destroy(struct scsi_device *sdev)
1138{
1139 struct ata_port *ap = ata_shost_to_port(sdev->host);
1140 unsigned long flags;
1141 struct ata_device *dev;
1142
1143 if (!ap->ops->error_handler)
1144 return;
1145
1146 spin_lock_irqsave(ap->lock, flags);
1147 dev = __ata_scsi_find_dev(ap, sdev);
1148 if (dev && dev->sdev) {
1149
1150 dev->sdev = NULL;
1151 dev->flags |= ATA_DFLAG_DETACH;
1152 ata_port_schedule_eh(ap);
1153 }
1154 spin_unlock_irqrestore(ap->lock, flags);
1155
1156 kfree(sdev->dma_drain_buf);
1157}
1158EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
1176{
1177 struct scsi_cmnd *scmd = qc->scsicmd;
1178 struct ata_taskfile *tf = &qc->tf;
1179 const u8 *cdb = scmd->cmnd;
1180 u16 fp;
1181 u8 bp = 0xff;
1182
1183 if (scmd->cmd_len < 5) {
1184 fp = 4;
1185 goto invalid_fld;
1186 }
1187
1188 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1189 tf->protocol = ATA_PROT_NODATA;
1190 if (cdb[1] & 0x1) {
1191 ;
1192 }
1193 if (cdb[4] & 0x2) {
1194 fp = 4;
1195 bp = 1;
1196 goto invalid_fld;
1197 }
1198 if (((cdb[4] >> 4) & 0xf) != 0) {
1199 fp = 4;
1200 bp = 3;
1201 goto invalid_fld;
1202 }
1203
1204 if (cdb[4] & 0x1) {
1205 tf->nsect = 1;
1206
1207 if (qc->dev->flags & ATA_DFLAG_LBA) {
1208 tf->flags |= ATA_TFLAG_LBA;
1209
1210 tf->lbah = 0x0;
1211 tf->lbam = 0x0;
1212 tf->lbal = 0x0;
1213 tf->device |= ATA_LBA;
1214 } else {
1215
1216 tf->lbal = 0x1;
1217 tf->lbam = 0x0;
1218 tf->lbah = 0x0;
1219 }
1220
1221 tf->command = ATA_CMD_VERIFY;
1222 } else {
1223
1224
1225
1226 if ((qc->ap->flags & ATA_FLAG_NO_POWEROFF_SPINDOWN) &&
1227 system_state == SYSTEM_POWER_OFF)
1228 goto skip;
1229
1230 if ((qc->ap->flags & ATA_FLAG_NO_HIBERNATE_SPINDOWN) &&
1231 system_entering_hibernation())
1232 goto skip;
1233
1234
1235 tf->command = ATA_CMD_STANDBYNOW1;
1236 }
1237
1238
1239
1240
1241
1242
1243
1244
1245 return 0;
1246
1247 invalid_fld:
1248 ata_scsi_set_invalid_field(qc->dev, scmd, fp, bp);
1249 return 1;
1250 skip:
1251 scmd->result = SAM_STAT_GOOD;
1252 return 1;
1253}
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc)
1270{
1271 struct ata_taskfile *tf = &qc->tf;
1272
1273 tf->flags |= ATA_TFLAG_DEVICE;
1274 tf->protocol = ATA_PROT_NODATA;
1275
1276 if (qc->dev->flags & ATA_DFLAG_FLUSH_EXT)
1277 tf->command = ATA_CMD_FLUSH_EXT;
1278 else
1279 tf->command = ATA_CMD_FLUSH;
1280
1281
1282 qc->flags |= ATA_QCFLAG_IO;
1283
1284 return 0;
1285}
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1298{
1299 u64 lba = 0;
1300 u32 len;
1301
1302 VPRINTK("six-byte command\n");
1303
1304 lba |= ((u64)(cdb[1] & 0x1f)) << 16;
1305 lba |= ((u64)cdb[2]) << 8;
1306 lba |= ((u64)cdb[3]);
1307
1308 len = cdb[4];
1309
1310 *plba = lba;
1311 *plen = len;
1312}
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1325{
1326 u64 lba = 0;
1327 u32 len = 0;
1328
1329 VPRINTK("ten-byte command\n");
1330
1331 lba |= ((u64)cdb[2]) << 24;
1332 lba |= ((u64)cdb[3]) << 16;
1333 lba |= ((u64)cdb[4]) << 8;
1334 lba |= ((u64)cdb[5]);
1335
1336 len |= ((u32)cdb[7]) << 8;
1337 len |= ((u32)cdb[8]);
1338
1339 *plba = lba;
1340 *plen = len;
1341}
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1354{
1355 u64 lba = 0;
1356 u32 len = 0;
1357
1358 VPRINTK("sixteen-byte command\n");
1359
1360 lba |= ((u64)cdb[2]) << 56;
1361 lba |= ((u64)cdb[3]) << 48;
1362 lba |= ((u64)cdb[4]) << 40;
1363 lba |= ((u64)cdb[5]) << 32;
1364 lba |= ((u64)cdb[6]) << 24;
1365 lba |= ((u64)cdb[7]) << 16;
1366 lba |= ((u64)cdb[8]) << 8;
1367 lba |= ((u64)cdb[9]);
1368
1369 len |= ((u32)cdb[10]) << 24;
1370 len |= ((u32)cdb[11]) << 16;
1371 len |= ((u32)cdb[12]) << 8;
1372 len |= ((u32)cdb[13]);
1373
1374 *plba = lba;
1375 *plen = len;
1376}
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
1391{
1392 struct scsi_cmnd *scmd = qc->scsicmd;
1393 struct ata_taskfile *tf = &qc->tf;
1394 struct ata_device *dev = qc->dev;
1395 u64 dev_sectors = qc->dev->n_sectors;
1396 const u8 *cdb = scmd->cmnd;
1397 u64 block;
1398 u32 n_block;
1399 u16 fp;
1400
1401 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1402 tf->protocol = ATA_PROT_NODATA;
1403
1404 if (cdb[0] == VERIFY) {
1405 if (scmd->cmd_len < 10) {
1406 fp = 9;
1407 goto invalid_fld;
1408 }
1409 scsi_10_lba_len(cdb, &block, &n_block);
1410 } else if (cdb[0] == VERIFY_16) {
1411 if (scmd->cmd_len < 16) {
1412 fp = 15;
1413 goto invalid_fld;
1414 }
1415 scsi_16_lba_len(cdb, &block, &n_block);
1416 } else {
1417 fp = 0;
1418 goto invalid_fld;
1419 }
1420
1421 if (!n_block)
1422 goto nothing_to_do;
1423 if (block >= dev_sectors)
1424 goto out_of_range;
1425 if ((block + n_block) > dev_sectors)
1426 goto out_of_range;
1427
1428 if (dev->flags & ATA_DFLAG_LBA) {
1429 tf->flags |= ATA_TFLAG_LBA;
1430
1431 if (lba_28_ok(block, n_block)) {
1432
1433 tf->command = ATA_CMD_VERIFY;
1434 tf->device |= (block >> 24) & 0xf;
1435 } else if (lba_48_ok(block, n_block)) {
1436 if (!(dev->flags & ATA_DFLAG_LBA48))
1437 goto out_of_range;
1438
1439
1440 tf->flags |= ATA_TFLAG_LBA48;
1441 tf->command = ATA_CMD_VERIFY_EXT;
1442
1443 tf->hob_nsect = (n_block >> 8) & 0xff;
1444
1445 tf->hob_lbah = (block >> 40) & 0xff;
1446 tf->hob_lbam = (block >> 32) & 0xff;
1447 tf->hob_lbal = (block >> 24) & 0xff;
1448 } else
1449
1450 goto out_of_range;
1451
1452 tf->nsect = n_block & 0xff;
1453
1454 tf->lbah = (block >> 16) & 0xff;
1455 tf->lbam = (block >> 8) & 0xff;
1456 tf->lbal = block & 0xff;
1457
1458 tf->device |= ATA_LBA;
1459 } else {
1460
1461 u32 sect, head, cyl, track;
1462
1463 if (!lba_28_ok(block, n_block))
1464 goto out_of_range;
1465
1466
1467 track = (u32)block / dev->sectors;
1468 cyl = track / dev->heads;
1469 head = track % dev->heads;
1470 sect = (u32)block % dev->sectors + 1;
1471
1472 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1473 (u32)block, track, cyl, head, sect);
1474
1475
1476
1477
1478
1479 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
1480 goto out_of_range;
1481
1482 tf->command = ATA_CMD_VERIFY;
1483 tf->nsect = n_block & 0xff;
1484 tf->lbal = sect;
1485 tf->lbam = cyl;
1486 tf->lbah = cyl >> 8;
1487 tf->device |= head;
1488 }
1489
1490 return 0;
1491
1492invalid_fld:
1493 ata_scsi_set_invalid_field(qc->dev, scmd, fp, 0xff);
1494 return 1;
1495
1496out_of_range:
1497 ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1498
1499 return 1;
1500
1501nothing_to_do:
1502 scmd->result = SAM_STAT_GOOD;
1503 return 1;
1504}
1505
1506static bool ata_check_nblocks(struct scsi_cmnd *scmd, u32 n_blocks)
1507{
1508 struct request *rq = scsi_cmd_to_rq(scmd);
1509 u32 req_blocks;
1510
1511 if (!blk_rq_is_passthrough(rq))
1512 return true;
1513
1514 req_blocks = blk_rq_bytes(rq) / scmd->device->sector_size;
1515 if (n_blocks > req_blocks)
1516 return false;
1517
1518 return true;
1519}
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
1540{
1541 struct scsi_cmnd *scmd = qc->scsicmd;
1542 const u8 *cdb = scmd->cmnd;
1543 struct request *rq = scsi_cmd_to_rq(scmd);
1544 int class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq));
1545 unsigned int tf_flags = 0;
1546 u64 block;
1547 u32 n_block;
1548 int rc;
1549 u16 fp = 0;
1550
1551 if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
1552 tf_flags |= ATA_TFLAG_WRITE;
1553
1554
1555 switch (cdb[0]) {
1556 case READ_10:
1557 case WRITE_10:
1558 if (unlikely(scmd->cmd_len < 10)) {
1559 fp = 9;
1560 goto invalid_fld;
1561 }
1562 scsi_10_lba_len(cdb, &block, &n_block);
1563 if (cdb[1] & (1 << 3))
1564 tf_flags |= ATA_TFLAG_FUA;
1565 if (!ata_check_nblocks(scmd, n_block))
1566 goto invalid_fld;
1567 break;
1568 case READ_6:
1569 case WRITE_6:
1570 if (unlikely(scmd->cmd_len < 6)) {
1571 fp = 5;
1572 goto invalid_fld;
1573 }
1574 scsi_6_lba_len(cdb, &block, &n_block);
1575
1576
1577
1578
1579 if (!n_block)
1580 n_block = 256;
1581 if (!ata_check_nblocks(scmd, n_block))
1582 goto invalid_fld;
1583 break;
1584 case READ_16:
1585 case WRITE_16:
1586 if (unlikely(scmd->cmd_len < 16)) {
1587 fp = 15;
1588 goto invalid_fld;
1589 }
1590 scsi_16_lba_len(cdb, &block, &n_block);
1591 if (cdb[1] & (1 << 3))
1592 tf_flags |= ATA_TFLAG_FUA;
1593 if (!ata_check_nblocks(scmd, n_block))
1594 goto invalid_fld;
1595 break;
1596 default:
1597 DPRINTK("no-byte command\n");
1598 fp = 0;
1599 goto invalid_fld;
1600 }
1601
1602
1603 if (!n_block)
1604
1605
1606
1607
1608
1609
1610
1611 goto nothing_to_do;
1612
1613 qc->flags |= ATA_QCFLAG_IO;
1614 qc->nbytes = n_block * scmd->device->sector_size;
1615
1616 rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
1617 qc->hw_tag, class);
1618
1619 if (likely(rc == 0))
1620 return 0;
1621
1622 if (rc == -ERANGE)
1623 goto out_of_range;
1624
1625invalid_fld:
1626 ata_scsi_set_invalid_field(qc->dev, scmd, fp, 0xff);
1627 return 1;
1628
1629out_of_range:
1630 ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1631
1632 return 1;
1633
1634nothing_to_do:
1635 scmd->result = SAM_STAT_GOOD;
1636 return 1;
1637}
1638
1639static void ata_qc_done(struct ata_queued_cmd *qc)
1640{
1641 struct scsi_cmnd *cmd = qc->scsicmd;
1642 void (*done)(struct scsi_cmnd *) = qc->scsidone;
1643
1644 ata_qc_free(qc);
1645 done(cmd);
1646}
1647
1648static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
1649{
1650 struct ata_port *ap = qc->ap;
1651 struct scsi_cmnd *cmd = qc->scsicmd;
1652 u8 *cdb = cmd->cmnd;
1653 int need_sense = (qc->err_mask != 0);
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664 if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
1665 ((cdb[2] & 0x20) || need_sense))
1666 ata_gen_passthru_sense(qc);
1667 else if (qc->flags & ATA_QCFLAG_SENSE_VALID)
1668 cmd->result = SAM_STAT_CHECK_CONDITION;
1669 else if (need_sense)
1670 ata_gen_ata_sense(qc);
1671 else
1672 cmd->result = SAM_STAT_GOOD;
1673
1674 if (need_sense && !ap->ops->error_handler)
1675 ata_dump_status(ap->print_id, &qc->result_tf);
1676
1677 ata_qc_done(qc);
1678}
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
1707 ata_xlat_func_t xlat_func)
1708{
1709 struct ata_port *ap = dev->link->ap;
1710 struct ata_queued_cmd *qc;
1711 int rc;
1712
1713 VPRINTK("ENTER\n");
1714
1715 qc = ata_scsi_qc_new(dev, cmd);
1716 if (!qc)
1717 goto err_mem;
1718
1719
1720 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1721 cmd->sc_data_direction == DMA_TO_DEVICE) {
1722 if (unlikely(scsi_bufflen(cmd) < 1)) {
1723 ata_dev_warn(dev, "WARNING: zero len r/w req\n");
1724 goto err_did;
1725 }
1726
1727 ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
1728
1729 qc->dma_dir = cmd->sc_data_direction;
1730 }
1731
1732 qc->complete_fn = ata_scsi_qc_complete;
1733
1734 if (xlat_func(qc))
1735 goto early_finish;
1736
1737 if (ap->ops->qc_defer) {
1738 if ((rc = ap->ops->qc_defer(qc)))
1739 goto defer;
1740 }
1741
1742
1743 ata_qc_issue(qc);
1744
1745 VPRINTK("EXIT\n");
1746 return 0;
1747
1748early_finish:
1749 ata_qc_free(qc);
1750 scsi_done(cmd);
1751 DPRINTK("EXIT - early finish (good or error)\n");
1752 return 0;
1753
1754err_did:
1755 ata_qc_free(qc);
1756 cmd->result = (DID_ERROR << 16);
1757 scsi_done(cmd);
1758err_mem:
1759 DPRINTK("EXIT - internal\n");
1760 return 0;
1761
1762defer:
1763 ata_qc_free(qc);
1764 DPRINTK("EXIT - defer\n");
1765 if (rc == ATA_DEFER_LINK)
1766 return SCSI_MLQUEUE_DEVICE_BUSY;
1767 else
1768 return SCSI_MLQUEUE_HOST_BUSY;
1769}
1770
1771struct ata_scsi_args {
1772 struct ata_device *dev;
1773 u16 *id;
1774 struct scsi_cmnd *cmd;
1775};
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792static void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1793 unsigned int (*actor)(struct ata_scsi_args *args, u8 *rbuf))
1794{
1795 unsigned int rc;
1796 struct scsi_cmnd *cmd = args->cmd;
1797 unsigned long flags;
1798
1799 spin_lock_irqsave(&ata_scsi_rbuf_lock, flags);
1800
1801 memset(ata_scsi_rbuf, 0, ATA_SCSI_RBUF_SIZE);
1802 rc = actor(args, ata_scsi_rbuf);
1803 if (rc == 0)
1804 sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
1805 ata_scsi_rbuf, ATA_SCSI_RBUF_SIZE);
1806
1807 spin_unlock_irqrestore(&ata_scsi_rbuf_lock, flags);
1808
1809 if (rc == 0)
1810 cmd->result = SAM_STAT_GOOD;
1811}
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824static unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf)
1825{
1826 static const u8 versions[] = {
1827 0x00,
1828 0x60,
1829
1830 0x03,
1831 0x20,
1832
1833 0x03,
1834 0x00
1835 };
1836 static const u8 versions_zbc[] = {
1837 0x00,
1838 0xA0,
1839
1840 0x06,
1841 0x00,
1842
1843 0x05,
1844 0xC0,
1845
1846 0x60,
1847 0x24,
1848 };
1849
1850 u8 hdr[] = {
1851 TYPE_DISK,
1852 0,
1853 0x5,
1854 2,
1855 95 - 4,
1856 0,
1857 0,
1858 2
1859 };
1860
1861 VPRINTK("ENTER\n");
1862
1863
1864
1865
1866 if (ata_id_removable(args->id) ||
1867 (args->dev->link->ap->pflags & ATA_PFLAG_EXTERNAL))
1868 hdr[1] |= (1 << 7);
1869
1870 if (args->dev->class == ATA_DEV_ZAC) {
1871 hdr[0] = TYPE_ZBC;
1872 hdr[2] = 0x7;
1873 }
1874
1875 memcpy(rbuf, hdr, sizeof(hdr));
1876 memcpy(&rbuf[8], "ATA ", 8);
1877 ata_id_string(args->id, &rbuf[16], ATA_ID_PROD, 16);
1878
1879
1880 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV + 2, 4);
1881 if (strncmp(&rbuf[32], " ", 4) == 0)
1882 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV, 4);
1883
1884 if (rbuf[32] == 0 || rbuf[32] == ' ')
1885 memcpy(&rbuf[32], "n/a ", 4);
1886
1887 if (ata_id_zoned_cap(args->id) || args->dev->class == ATA_DEV_ZAC)
1888 memcpy(rbuf + 58, versions_zbc, sizeof(versions_zbc));
1889 else
1890 memcpy(rbuf + 58, versions, sizeof(versions));
1891
1892 return 0;
1893}
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905static unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf)
1906{
1907 int i, num_pages = 0;
1908 static const u8 pages[] = {
1909 0x00,
1910 0x80,
1911 0x83,
1912 0x89,
1913 0xb0,
1914 0xb1,
1915 0xb2,
1916 0xb6,
1917 0xb9,
1918 };
1919
1920 for (i = 0; i < sizeof(pages); i++) {
1921 if (pages[i] == 0xb6 &&
1922 !(args->dev->flags & ATA_DFLAG_ZAC))
1923 continue;
1924 rbuf[num_pages + 4] = pages[i];
1925 num_pages++;
1926 }
1927 rbuf[3] = num_pages;
1928 return 0;
1929}
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941static unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf)
1942{
1943 static const u8 hdr[] = {
1944 0,
1945 0x80,
1946 0,
1947 ATA_ID_SERNO_LEN,
1948 };
1949
1950 memcpy(rbuf, hdr, sizeof(hdr));
1951 ata_id_string(args->id, (unsigned char *) &rbuf[4],
1952 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1953 return 0;
1954}
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969static unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf)
1970{
1971 const int sat_model_serial_desc_len = 68;
1972 int num;
1973
1974 rbuf[1] = 0x83;
1975 num = 4;
1976
1977
1978 rbuf[num + 0] = 2;
1979 rbuf[num + 3] = ATA_ID_SERNO_LEN;
1980 num += 4;
1981 ata_id_string(args->id, (unsigned char *) rbuf + num,
1982 ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1983 num += ATA_ID_SERNO_LEN;
1984
1985
1986
1987 rbuf[num + 0] = 2;
1988 rbuf[num + 1] = 1;
1989 rbuf[num + 3] = sat_model_serial_desc_len;
1990 num += 4;
1991 memcpy(rbuf + num, "ATA ", 8);
1992 num += 8;
1993 ata_id_string(args->id, (unsigned char *) rbuf + num, ATA_ID_PROD,
1994 ATA_ID_PROD_LEN);
1995 num += ATA_ID_PROD_LEN;
1996 ata_id_string(args->id, (unsigned char *) rbuf + num, ATA_ID_SERNO,
1997 ATA_ID_SERNO_LEN);
1998 num += ATA_ID_SERNO_LEN;
1999
2000 if (ata_id_has_wwn(args->id)) {
2001
2002
2003 rbuf[num + 0] = 1;
2004 rbuf[num + 1] = 3;
2005 rbuf[num + 3] = ATA_ID_WWN_LEN;
2006 num += 4;
2007 ata_id_string(args->id, (unsigned char *) rbuf + num,
2008 ATA_ID_WWN, ATA_ID_WWN_LEN);
2009 num += ATA_ID_WWN_LEN;
2010 }
2011 rbuf[3] = num - 4;
2012 return 0;
2013}
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025static unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf)
2026{
2027 rbuf[1] = 0x89;
2028 rbuf[2] = (0x238 >> 8);
2029 rbuf[3] = (0x238 & 0xff);
2030
2031 memcpy(&rbuf[8], "linux ", 8);
2032 memcpy(&rbuf[16], "libata ", 16);
2033 memcpy(&rbuf[32], DRV_VERSION, 4);
2034
2035 rbuf[36] = 0x34;
2036 rbuf[37] = (1 << 7);
2037
2038
2039
2040 rbuf[38] = ATA_DRDY;
2041 rbuf[40] = 0x1;
2042 rbuf[48] = 0x1;
2043
2044 rbuf[56] = ATA_CMD_ID_ATA;
2045
2046 memcpy(&rbuf[60], &args->id[0], 512);
2047 return 0;
2048}
2049
2050static unsigned int ata_scsiop_inq_b0(struct ata_scsi_args *args, u8 *rbuf)
2051{
2052 struct ata_device *dev = args->dev;
2053 u16 min_io_sectors;
2054
2055 rbuf[1] = 0xb0;
2056 rbuf[3] = 0x3c;
2057
2058
2059
2060
2061
2062
2063
2064
2065 min_io_sectors = 1 << ata_id_log2_per_physical_sector(args->id);
2066 put_unaligned_be16(min_io_sectors, &rbuf[6]);
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077 if (ata_id_has_trim(args->id)) {
2078 u64 max_blocks = 65535 * ATA_MAX_TRIM_RNUM;
2079
2080 if (dev->horkage & ATA_HORKAGE_MAX_TRIM_128M)
2081 max_blocks = 128 << (20 - SECTOR_SHIFT);
2082
2083 put_unaligned_be64(max_blocks, &rbuf[36]);
2084 put_unaligned_be32(1, &rbuf[28]);
2085 }
2086
2087 return 0;
2088}
2089
2090static unsigned int ata_scsiop_inq_b1(struct ata_scsi_args *args, u8 *rbuf)
2091{
2092 int form_factor = ata_id_form_factor(args->id);
2093 int media_rotation_rate = ata_id_rotation_rate(args->id);
2094 u8 zoned = ata_id_zoned_cap(args->id);
2095
2096 rbuf[1] = 0xb1;
2097 rbuf[3] = 0x3c;
2098 rbuf[4] = media_rotation_rate >> 8;
2099 rbuf[5] = media_rotation_rate;
2100 rbuf[7] = form_factor;
2101 if (zoned)
2102 rbuf[8] = (zoned << 4);
2103
2104 return 0;
2105}
2106
2107static unsigned int ata_scsiop_inq_b2(struct ata_scsi_args *args, u8 *rbuf)
2108{
2109
2110 rbuf[1] = 0xb2;
2111 rbuf[3] = 0x4;
2112 rbuf[5] = 1 << 6;
2113
2114 return 0;
2115}
2116
2117static unsigned int ata_scsiop_inq_b6(struct ata_scsi_args *args, u8 *rbuf)
2118{
2119
2120
2121
2122 rbuf[1] = 0xb6;
2123 rbuf[3] = 0x3C;
2124
2125
2126
2127
2128 if (args->dev->zac_zoned_cap & 1)
2129 rbuf[4] |= 1;
2130 put_unaligned_be32(args->dev->zac_zones_optimal_open, &rbuf[8]);
2131 put_unaligned_be32(args->dev->zac_zones_optimal_nonseq, &rbuf[12]);
2132 put_unaligned_be32(args->dev->zac_zones_max_open, &rbuf[16]);
2133
2134 return 0;
2135}
2136
2137static unsigned int ata_scsiop_inq_b9(struct ata_scsi_args *args, u8 *rbuf)
2138{
2139 struct ata_cpr_log *cpr_log = args->dev->cpr_log;
2140 u8 *desc = &rbuf[64];
2141 int i;
2142
2143
2144 rbuf[1] = 0xb9;
2145 put_unaligned_be16(64 + (int)cpr_log->nr_cpr * 32 - 4, &rbuf[3]);
2146
2147 for (i = 0; i < cpr_log->nr_cpr; i++, desc += 32) {
2148 desc[0] = cpr_log->cpr[i].num;
2149 desc[1] = cpr_log->cpr[i].num_storage_elements;
2150 put_unaligned_be64(cpr_log->cpr[i].start_lba, &desc[8]);
2151 put_unaligned_be64(cpr_log->cpr[i].num_lbas, &desc[16]);
2152 }
2153
2154 return 0;
2155}
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170static void modecpy(u8 *dest, const u8 *src, int n, bool changeable)
2171{
2172 if (changeable) {
2173 memcpy(dest, src, 2);
2174 memset(dest + 2, 0, n - 2);
2175 } else {
2176 memcpy(dest, src, n);
2177 }
2178}
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193static unsigned int ata_msense_caching(u16 *id, u8 *buf, bool changeable)
2194{
2195 modecpy(buf, def_cache_mpage, sizeof(def_cache_mpage), changeable);
2196 if (changeable) {
2197 buf[2] |= (1 << 2);
2198 } else {
2199 buf[2] |= (ata_id_wcache_enabled(id) << 2);
2200 buf[12] |= (!ata_id_rahead_enabled(id) << 5);
2201 }
2202 return sizeof(def_cache_mpage);
2203}
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216static unsigned int ata_msense_control(struct ata_device *dev, u8 *buf,
2217 bool changeable)
2218{
2219 modecpy(buf, def_control_mpage, sizeof(def_control_mpage), changeable);
2220 if (changeable) {
2221 buf[2] |= (1 << 2);
2222 } else {
2223 bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE);
2224
2225 buf[2] |= (d_sense << 2);
2226 }
2227 return sizeof(def_control_mpage);
2228}
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240static unsigned int ata_msense_rw_recovery(u8 *buf, bool changeable)
2241{
2242 modecpy(buf, def_rw_recovery_mpage, sizeof(def_rw_recovery_mpage),
2243 changeable);
2244 return sizeof(def_rw_recovery_mpage);
2245}
2246
2247
2248
2249
2250
2251static int ata_dev_supports_fua(u16 *id)
2252{
2253 unsigned char model[ATA_ID_PROD_LEN + 1], fw[ATA_ID_FW_REV_LEN + 1];
2254
2255 if (!libata_fua)
2256 return 0;
2257 if (!ata_id_has_fua(id))
2258 return 0;
2259
2260 ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
2261 ata_id_c_string(id, fw, ATA_ID_FW_REV, sizeof(fw));
2262
2263 if (strcmp(model, "Maxtor"))
2264 return 1;
2265 if (strcmp(fw, "BANC1G10"))
2266 return 1;
2267
2268 return 0;
2269}
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf)
2284{
2285 struct ata_device *dev = args->dev;
2286 u8 *scsicmd = args->cmd->cmnd, *p = rbuf;
2287 static const u8 sat_blk_desc[] = {
2288 0, 0, 0, 0,
2289 0,
2290 0, 0x2, 0x0
2291 };
2292 u8 pg, spg;
2293 unsigned int ebd, page_control, six_byte;
2294 u8 dpofua, bp = 0xff;
2295 u16 fp;
2296
2297 VPRINTK("ENTER\n");
2298
2299 six_byte = (scsicmd[0] == MODE_SENSE);
2300 ebd = !(scsicmd[1] & 0x8);
2301
2302
2303
2304
2305 page_control = scsicmd[2] >> 6;
2306 switch (page_control) {
2307 case 0:
2308 case 1:
2309 case 2:
2310 break;
2311 case 3:
2312 goto saving_not_supp;
2313 default:
2314 fp = 2;
2315 bp = 6;
2316 goto invalid_fld;
2317 }
2318
2319 if (six_byte)
2320 p += 4 + (ebd ? 8 : 0);
2321 else
2322 p += 8 + (ebd ? 8 : 0);
2323
2324 pg = scsicmd[2] & 0x3f;
2325 spg = scsicmd[3];
2326
2327
2328
2329
2330 if (spg && (spg != ALL_SUB_MPAGES)) {
2331 fp = 3;
2332 goto invalid_fld;
2333 }
2334
2335 switch(pg) {
2336 case RW_RECOVERY_MPAGE:
2337 p += ata_msense_rw_recovery(p, page_control == 1);
2338 break;
2339
2340 case CACHE_MPAGE:
2341 p += ata_msense_caching(args->id, p, page_control == 1);
2342 break;
2343
2344 case CONTROL_MPAGE:
2345 p += ata_msense_control(args->dev, p, page_control == 1);
2346 break;
2347
2348 case ALL_MPAGES:
2349 p += ata_msense_rw_recovery(p, page_control == 1);
2350 p += ata_msense_caching(args->id, p, page_control == 1);
2351 p += ata_msense_control(args->dev, p, page_control == 1);
2352 break;
2353
2354 default:
2355 fp = 2;
2356 goto invalid_fld;
2357 }
2358
2359 dpofua = 0;
2360 if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
2361 (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
2362 dpofua = 1 << 4;
2363
2364 if (six_byte) {
2365 rbuf[0] = p - rbuf - 1;
2366 rbuf[2] |= dpofua;
2367 if (ebd) {
2368 rbuf[3] = sizeof(sat_blk_desc);
2369 memcpy(rbuf + 4, sat_blk_desc, sizeof(sat_blk_desc));
2370 }
2371 } else {
2372 unsigned int output_len = p - rbuf - 2;
2373
2374 rbuf[0] = output_len >> 8;
2375 rbuf[1] = output_len;
2376 rbuf[3] |= dpofua;
2377 if (ebd) {
2378 rbuf[7] = sizeof(sat_blk_desc);
2379 memcpy(rbuf + 8, sat_blk_desc, sizeof(sat_blk_desc));
2380 }
2381 }
2382 return 0;
2383
2384invalid_fld:
2385 ata_scsi_set_invalid_field(dev, args->cmd, fp, bp);
2386 return 1;
2387
2388saving_not_supp:
2389 ata_scsi_set_sense(dev, args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
2390
2391 return 1;
2392}
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404static unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf)
2405{
2406 struct ata_device *dev = args->dev;
2407 u64 last_lba = dev->n_sectors - 1;
2408 u32 sector_size;
2409 u8 log2_per_phys;
2410 u16 lowest_aligned;
2411
2412 sector_size = ata_id_logical_sector_size(dev->id);
2413 log2_per_phys = ata_id_log2_per_physical_sector(dev->id);
2414 lowest_aligned = ata_id_logical_sector_offset(dev->id, log2_per_phys);
2415
2416 VPRINTK("ENTER\n");
2417
2418 if (args->cmd->cmnd[0] == READ_CAPACITY) {
2419 if (last_lba >= 0xffffffffULL)
2420 last_lba = 0xffffffff;
2421
2422
2423 rbuf[0] = last_lba >> (8 * 3);
2424 rbuf[1] = last_lba >> (8 * 2);
2425 rbuf[2] = last_lba >> (8 * 1);
2426 rbuf[3] = last_lba;
2427
2428
2429 rbuf[4] = sector_size >> (8 * 3);
2430 rbuf[5] = sector_size >> (8 * 2);
2431 rbuf[6] = sector_size >> (8 * 1);
2432 rbuf[7] = sector_size;
2433 } else {
2434
2435 rbuf[0] = last_lba >> (8 * 7);
2436 rbuf[1] = last_lba >> (8 * 6);
2437 rbuf[2] = last_lba >> (8 * 5);
2438 rbuf[3] = last_lba >> (8 * 4);
2439 rbuf[4] = last_lba >> (8 * 3);
2440 rbuf[5] = last_lba >> (8 * 2);
2441 rbuf[6] = last_lba >> (8 * 1);
2442 rbuf[7] = last_lba;
2443
2444
2445 rbuf[ 8] = sector_size >> (8 * 3);
2446 rbuf[ 9] = sector_size >> (8 * 2);
2447 rbuf[10] = sector_size >> (8 * 1);
2448 rbuf[11] = sector_size;
2449
2450 rbuf[12] = 0;
2451 rbuf[13] = log2_per_phys;
2452 rbuf[14] = (lowest_aligned >> 8) & 0x3f;
2453 rbuf[15] = lowest_aligned;
2454
2455 if (ata_id_has_trim(args->id) &&
2456 !(dev->horkage & ATA_HORKAGE_NOTRIM)) {
2457 rbuf[14] |= 0x80;
2458
2459 if (ata_id_has_zero_after_trim(args->id) &&
2460 dev->horkage & ATA_HORKAGE_ZERO_AFTER_TRIM) {
2461 ata_dev_info(dev, "Enabling discard_zeroes_data\n");
2462 rbuf[14] |= 0x40;
2463 }
2464 }
2465 if (ata_id_zoned_cap(args->id) ||
2466 args->dev->class == ATA_DEV_ZAC)
2467 rbuf[12] = (1 << 4);
2468 }
2469 return 0;
2470}
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482static unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf)
2483{
2484 VPRINTK("ENTER\n");
2485 rbuf[3] = 8;
2486
2487 return 0;
2488}
2489
2490static void atapi_sense_complete(struct ata_queued_cmd *qc)
2491{
2492 if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
2493
2494
2495
2496
2497
2498 ata_gen_passthru_sense(qc);
2499 }
2500
2501 ata_qc_done(qc);
2502}
2503
2504
2505static inline int ata_pio_use_silly(struct ata_port *ap)
2506{
2507 return (ap->flags & ATA_FLAG_PIO_DMA);
2508}
2509
2510static void atapi_request_sense(struct ata_queued_cmd *qc)
2511{
2512 struct ata_port *ap = qc->ap;
2513 struct scsi_cmnd *cmd = qc->scsicmd;
2514
2515 DPRINTK("ATAPI request sense\n");
2516
2517 memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
2518
2519#ifdef CONFIG_ATA_SFF
2520 if (ap->ops->sff_tf_read)
2521 ap->ops->sff_tf_read(ap, &qc->tf);
2522#endif
2523
2524
2525 cmd->sense_buffer[0] = 0x70;
2526 cmd->sense_buffer[2] = qc->tf.feature >> 4;
2527
2528 ata_qc_reinit(qc);
2529
2530
2531 sg_init_one(&qc->sgent, cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);
2532 ata_sg_init(qc, &qc->sgent, 1);
2533 qc->dma_dir = DMA_FROM_DEVICE;
2534
2535 memset(&qc->cdb, 0, qc->dev->cdb_len);
2536 qc->cdb[0] = REQUEST_SENSE;
2537 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2538
2539 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2540 qc->tf.command = ATA_CMD_PACKET;
2541
2542 if (ata_pio_use_silly(ap)) {
2543 qc->tf.protocol = ATAPI_PROT_DMA;
2544 qc->tf.feature |= ATAPI_PKT_DMA;
2545 } else {
2546 qc->tf.protocol = ATAPI_PROT_PIO;
2547 qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
2548 qc->tf.lbah = 0;
2549 }
2550 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2551
2552 qc->complete_fn = atapi_sense_complete;
2553
2554 ata_qc_issue(qc);
2555
2556 DPRINTK("EXIT\n");
2557}
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567static void atapi_fixup_inquiry(struct scsi_cmnd *cmd)
2568{
2569 u8 buf[4];
2570
2571 sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd), buf, 4);
2572 if (buf[2] == 0) {
2573 buf[2] = 0x5;
2574 buf[3] = 0x32;
2575 }
2576 sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd), buf, 4);
2577}
2578
2579static void atapi_qc_complete(struct ata_queued_cmd *qc)
2580{
2581 struct scsi_cmnd *cmd = qc->scsicmd;
2582 unsigned int err_mask = qc->err_mask;
2583
2584 VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
2585
2586
2587 if (unlikely(qc->ap->ops->error_handler &&
2588 (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
2589
2590 if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
2591
2592
2593
2594
2595
2596 ata_gen_passthru_sense(qc);
2597 }
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612 if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL && qc->dev->sdev)
2613 qc->dev->sdev->locked = 0;
2614
2615 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
2616 ata_qc_done(qc);
2617 return;
2618 }
2619
2620
2621 if (unlikely(err_mask & AC_ERR_DEV)) {
2622 cmd->result = SAM_STAT_CHECK_CONDITION;
2623 atapi_request_sense(qc);
2624 return;
2625 } else if (unlikely(err_mask)) {
2626
2627
2628
2629
2630
2631 ata_gen_passthru_sense(qc);
2632 } else {
2633 if (cmd->cmnd[0] == INQUIRY && (cmd->cmnd[1] & 0x03) == 0)
2634 atapi_fixup_inquiry(cmd);
2635 cmd->result = SAM_STAT_GOOD;
2636 }
2637
2638 ata_qc_done(qc);
2639}
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
2651{
2652 struct scsi_cmnd *scmd = qc->scsicmd;
2653 struct ata_device *dev = qc->dev;
2654 int nodata = (scmd->sc_data_direction == DMA_NONE);
2655 int using_pio = !nodata && (dev->flags & ATA_DFLAG_PIO);
2656 unsigned int nbytes;
2657
2658 memset(qc->cdb, 0, dev->cdb_len);
2659 memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
2660
2661 qc->complete_fn = atapi_qc_complete;
2662
2663 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2664 if (scmd->sc_data_direction == DMA_TO_DEVICE) {
2665 qc->tf.flags |= ATA_TFLAG_WRITE;
2666 DPRINTK("direction: write\n");
2667 }
2668
2669 qc->tf.command = ATA_CMD_PACKET;
2670 ata_qc_set_pc_nbytes(qc);
2671
2672
2673 if (!nodata && !using_pio && atapi_check_dma(qc))
2674 using_pio = 1;
2675
2676
2677
2678
2679
2680
2681 nbytes = min(ata_qc_raw_nbytes(qc), (unsigned int)63 * 1024);
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707 if (nbytes & 0x1)
2708 nbytes++;
2709
2710 qc->tf.lbam = (nbytes & 0xFF);
2711 qc->tf.lbah = (nbytes >> 8);
2712
2713 if (nodata)
2714 qc->tf.protocol = ATAPI_PROT_NODATA;
2715 else if (using_pio)
2716 qc->tf.protocol = ATAPI_PROT_PIO;
2717 else {
2718
2719 qc->tf.protocol = ATAPI_PROT_DMA;
2720 qc->tf.feature |= ATAPI_PKT_DMA;
2721
2722 if ((dev->flags & ATA_DFLAG_DMADIR) &&
2723 (scmd->sc_data_direction != DMA_TO_DEVICE))
2724
2725 qc->tf.feature |= ATAPI_DMADIR;
2726 }
2727
2728
2729
2730
2731 return 0;
2732}
2733
2734static struct ata_device *ata_find_dev(struct ata_port *ap, int devno)
2735{
2736 if (!sata_pmp_attached(ap)) {
2737 if (likely(devno >= 0 &&
2738 devno < ata_link_max_devices(&ap->link)))
2739 return &ap->link.device[devno];
2740 } else {
2741 if (likely(devno >= 0 &&
2742 devno < ap->nr_pmp_links))
2743 return &ap->pmp_link[devno].device[0];
2744 }
2745
2746 return NULL;
2747}
2748
2749static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
2750 const struct scsi_device *scsidev)
2751{
2752 int devno;
2753
2754
2755 if (!sata_pmp_attached(ap)) {
2756 if (unlikely(scsidev->channel || scsidev->lun))
2757 return NULL;
2758 devno = scsidev->id;
2759 } else {
2760 if (unlikely(scsidev->id || scsidev->lun))
2761 return NULL;
2762 devno = scsidev->channel;
2763 }
2764
2765 return ata_find_dev(ap, devno);
2766}
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784struct ata_device *
2785ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
2786{
2787 struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
2788
2789 if (unlikely(!dev || !ata_dev_enabled(dev)))
2790 return NULL;
2791
2792 return dev;
2793}
2794
2795
2796
2797
2798
2799
2800
2801
2802static u8
2803ata_scsi_map_proto(u8 byte1)
2804{
2805 switch((byte1 & 0x1e) >> 1) {
2806 case 3:
2807 return ATA_PROT_NODATA;
2808
2809 case 6:
2810 case 10:
2811 case 11:
2812 return ATA_PROT_DMA;
2813
2814 case 4:
2815 case 5:
2816 return ATA_PROT_PIO;
2817
2818 case 12:
2819 return ATA_PROT_NCQ;
2820
2821 case 0:
2822 case 1:
2823 case 8:
2824 case 9:
2825 case 7:
2826 case 15:
2827 default:
2828 break;
2829 }
2830
2831 return ATA_PROT_UNKNOWN;
2832}
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
2844{
2845 struct ata_taskfile *tf = &(qc->tf);
2846 struct scsi_cmnd *scmd = qc->scsicmd;
2847 struct ata_device *dev = qc->dev;
2848 const u8 *cdb = scmd->cmnd;
2849 u16 fp;
2850 u16 cdb_offset = 0;
2851
2852
2853 if (cdb[0] == VARIABLE_LENGTH_CMD)
2854 cdb_offset = 9;
2855
2856 tf->protocol = ata_scsi_map_proto(cdb[1 + cdb_offset]);
2857 if (tf->protocol == ATA_PROT_UNKNOWN) {
2858 fp = 1;
2859 goto invalid_fld;
2860 }
2861
2862 if ((cdb[2 + cdb_offset] & 0x3) == 0) {
2863
2864
2865
2866
2867 if (scmd->sc_data_direction != DMA_NONE) {
2868 fp = 2 + cdb_offset;
2869 goto invalid_fld;
2870 }
2871
2872 if (ata_is_ncq(tf->protocol))
2873 tf->protocol = ATA_PROT_NCQ_NODATA;
2874 }
2875
2876
2877 tf->flags |= ATA_TFLAG_LBA;
2878
2879
2880
2881
2882
2883 if (cdb[0] == ATA_16) {
2884
2885
2886
2887
2888
2889 if (cdb[1] & 0x01) {
2890 tf->hob_feature = cdb[3];
2891 tf->hob_nsect = cdb[5];
2892 tf->hob_lbal = cdb[7];
2893 tf->hob_lbam = cdb[9];
2894 tf->hob_lbah = cdb[11];
2895 tf->flags |= ATA_TFLAG_LBA48;
2896 } else
2897 tf->flags &= ~ATA_TFLAG_LBA48;
2898
2899
2900
2901
2902 tf->feature = cdb[4];
2903 tf->nsect = cdb[6];
2904 tf->lbal = cdb[8];
2905 tf->lbam = cdb[10];
2906 tf->lbah = cdb[12];
2907 tf->device = cdb[13];
2908 tf->command = cdb[14];
2909 } else if (cdb[0] == ATA_12) {
2910
2911
2912
2913 tf->flags &= ~ATA_TFLAG_LBA48;
2914
2915 tf->feature = cdb[3];
2916 tf->nsect = cdb[4];
2917 tf->lbal = cdb[5];
2918 tf->lbam = cdb[6];
2919 tf->lbah = cdb[7];
2920 tf->device = cdb[8];
2921 tf->command = cdb[9];
2922 } else {
2923
2924
2925
2926
2927
2928 if (cdb[10] & 0x01) {
2929 tf->hob_feature = cdb[20];
2930 tf->hob_nsect = cdb[22];
2931 tf->hob_lbal = cdb[16];
2932 tf->hob_lbam = cdb[15];
2933 tf->hob_lbah = cdb[14];
2934 tf->flags |= ATA_TFLAG_LBA48;
2935 } else
2936 tf->flags &= ~ATA_TFLAG_LBA48;
2937
2938 tf->feature = cdb[21];
2939 tf->nsect = cdb[23];
2940 tf->lbal = cdb[19];
2941 tf->lbam = cdb[18];
2942 tf->lbah = cdb[17];
2943 tf->device = cdb[24];
2944 tf->command = cdb[25];
2945 tf->auxiliary = get_unaligned_be32(&cdb[28]);
2946 }
2947
2948
2949 if (ata_is_ncq(tf->protocol))
2950 tf->nsect = qc->hw_tag << 3;
2951
2952
2953 tf->device = dev->devno ?
2954 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
2955
2956 switch (tf->command) {
2957
2958 case ATA_CMD_READ_LONG:
2959 case ATA_CMD_READ_LONG_ONCE:
2960 case ATA_CMD_WRITE_LONG:
2961 case ATA_CMD_WRITE_LONG_ONCE:
2962 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1) {
2963 fp = 1;
2964 goto invalid_fld;
2965 }
2966 qc->sect_size = scsi_bufflen(scmd);
2967 break;
2968
2969
2970 case ATA_CMD_CFA_WRITE_NE:
2971 case ATA_CMD_CFA_TRANS_SECT:
2972 case ATA_CMD_CFA_WRITE_MULT_NE:
2973
2974 case ATA_CMD_READ:
2975 case ATA_CMD_READ_EXT:
2976 case ATA_CMD_READ_QUEUED:
2977
2978 case ATA_CMD_FPDMA_READ:
2979 case ATA_CMD_READ_MULTI:
2980 case ATA_CMD_READ_MULTI_EXT:
2981 case ATA_CMD_PIO_READ:
2982 case ATA_CMD_PIO_READ_EXT:
2983 case ATA_CMD_READ_STREAM_DMA_EXT:
2984 case ATA_CMD_READ_STREAM_EXT:
2985 case ATA_CMD_VERIFY:
2986 case ATA_CMD_VERIFY_EXT:
2987 case ATA_CMD_WRITE:
2988 case ATA_CMD_WRITE_EXT:
2989 case ATA_CMD_WRITE_FUA_EXT:
2990 case ATA_CMD_WRITE_QUEUED:
2991 case ATA_CMD_WRITE_QUEUED_FUA_EXT:
2992 case ATA_CMD_FPDMA_WRITE:
2993 case ATA_CMD_WRITE_MULTI:
2994 case ATA_CMD_WRITE_MULTI_EXT:
2995 case ATA_CMD_WRITE_MULTI_FUA_EXT:
2996 case ATA_CMD_PIO_WRITE:
2997 case ATA_CMD_PIO_WRITE_EXT:
2998 case ATA_CMD_WRITE_STREAM_DMA_EXT:
2999 case ATA_CMD_WRITE_STREAM_EXT:
3000 qc->sect_size = scmd->device->sector_size;
3001 break;
3002
3003
3004 default:
3005 qc->sect_size = ATA_SECT_SIZE;
3006 }
3007
3008
3009
3010
3011
3012
3013 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3014 if (scmd->sc_data_direction == DMA_TO_DEVICE)
3015 tf->flags |= ATA_TFLAG_WRITE;
3016
3017 qc->flags |= ATA_QCFLAG_RESULT_TF | ATA_QCFLAG_QUIET;
3018
3019
3020
3021
3022
3023
3024
3025 ata_qc_set_pc_nbytes(qc);
3026
3027
3028 if (tf->protocol == ATA_PROT_DMA && !ata_dma_enabled(dev)) {
3029 fp = 1;
3030 goto invalid_fld;
3031 }
3032
3033
3034 if (ata_is_ncq(tf->protocol) && !ata_ncq_enabled(dev)) {
3035 fp = 1;
3036 goto invalid_fld;
3037 }
3038
3039
3040 if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf)) {
3041 fp = 1;
3042 goto invalid_fld;
3043 }
3044
3045 if (is_multi_taskfile(tf)) {
3046 unsigned int multi_count = 1 << (cdb[1] >> 5);
3047
3048
3049
3050
3051 if (multi_count != dev->multi_count)
3052 ata_dev_warn(dev, "invalid multi_count %u ignored\n",
3053 multi_count);
3054 }
3055
3056
3057
3058
3059
3060
3061
3062
3063 if (tf->command == ATA_CMD_SET_FEATURES &&
3064 tf->feature == SETFEATURES_XFER) {
3065 fp = (cdb[0] == ATA_16) ? 4 : 3;
3066 goto invalid_fld;
3067 }
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084 if (tf->command >= 0x5C && tf->command <= 0x5F && !libata_allow_tpm) {
3085 fp = (cdb[0] == ATA_16) ? 14 : 9;
3086 goto invalid_fld;
3087 }
3088
3089 return 0;
3090
3091 invalid_fld:
3092 ata_scsi_set_invalid_field(dev, scmd, fp, 0xff);
3093 return 1;
3094}
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117static size_t ata_format_dsm_trim_descr(struct scsi_cmnd *cmd, u32 trmax,
3118 u64 sector, u32 count)
3119{
3120 struct scsi_device *sdp = cmd->device;
3121 size_t len = sdp->sector_size;
3122 size_t r;
3123 __le64 *buf;
3124 u32 i = 0;
3125 unsigned long flags;
3126
3127 WARN_ON(len > ATA_SCSI_RBUF_SIZE);
3128
3129 if (len > ATA_SCSI_RBUF_SIZE)
3130 len = ATA_SCSI_RBUF_SIZE;
3131
3132 spin_lock_irqsave(&ata_scsi_rbuf_lock, flags);
3133 buf = ((void *)ata_scsi_rbuf);
3134 memset(buf, 0, len);
3135 while (i < trmax) {
3136 u64 entry = sector |
3137 ((u64)(count > 0xffff ? 0xffff : count) << 48);
3138 buf[i++] = __cpu_to_le64(entry);
3139 if (count <= 0xffff)
3140 break;
3141 count -= 0xffff;
3142 sector += 0xffff;
3143 }
3144 r = sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd), buf, len);
3145 spin_unlock_irqrestore(&ata_scsi_rbuf_lock, flags);
3146
3147 return r;
3148}
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161static unsigned int ata_scsi_write_same_xlat(struct ata_queued_cmd *qc)
3162{
3163 struct ata_taskfile *tf = &qc->tf;
3164 struct scsi_cmnd *scmd = qc->scsicmd;
3165 struct scsi_device *sdp = scmd->device;
3166 size_t len = sdp->sector_size;
3167 struct ata_device *dev = qc->dev;
3168 const u8 *cdb = scmd->cmnd;
3169 u64 block;
3170 u32 n_block;
3171 const u32 trmax = len >> 3;
3172 u32 size;
3173 u16 fp;
3174 u8 bp = 0xff;
3175 u8 unmap = cdb[1] & 0x8;
3176
3177
3178 if (unlikely(!ata_dma_enabled(dev)))
3179 goto invalid_opcode;
3180
3181
3182
3183
3184
3185
3186 if (unlikely(blk_rq_is_passthrough(scsi_cmd_to_rq(scmd))))
3187 goto invalid_opcode;
3188
3189 if (unlikely(scmd->cmd_len < 16)) {
3190 fp = 15;
3191 goto invalid_fld;
3192 }
3193 scsi_16_lba_len(cdb, &block, &n_block);
3194
3195 if (!unmap ||
3196 (dev->horkage & ATA_HORKAGE_NOTRIM) ||
3197 !ata_id_has_trim(dev->id)) {
3198 fp = 1;
3199 bp = 3;
3200 goto invalid_fld;
3201 }
3202
3203 if (n_block > 0xffff * trmax) {
3204 fp = 2;
3205 goto invalid_fld;
3206 }
3207
3208
3209
3210
3211
3212 if (!scsi_sg_count(scmd))
3213 goto invalid_param_len;
3214
3215
3216
3217
3218
3219
3220
3221 size = ata_format_dsm_trim_descr(scmd, trmax, block, n_block);
3222 if (size != len)
3223 goto invalid_param_len;
3224
3225 if (ata_ncq_enabled(dev) && ata_fpdma_dsm_supported(dev)) {
3226
3227 tf->protocol = ATA_PROT_NCQ;
3228 tf->command = ATA_CMD_FPDMA_SEND;
3229 tf->hob_nsect = ATA_SUBCMD_FPDMA_SEND_DSM & 0x1f;
3230 tf->nsect = qc->hw_tag << 3;
3231 tf->hob_feature = (size / 512) >> 8;
3232 tf->feature = size / 512;
3233
3234 tf->auxiliary = 1;
3235 } else {
3236 tf->protocol = ATA_PROT_DMA;
3237 tf->hob_feature = 0;
3238 tf->feature = ATA_DSM_TRIM;
3239 tf->hob_nsect = (size / 512) >> 8;
3240 tf->nsect = size / 512;
3241 tf->command = ATA_CMD_DSM;
3242 }
3243
3244 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48 |
3245 ATA_TFLAG_WRITE;
3246
3247 ata_qc_set_pc_nbytes(qc);
3248
3249 return 0;
3250
3251invalid_fld:
3252 ata_scsi_set_invalid_field(dev, scmd, fp, bp);
3253 return 1;
3254invalid_param_len:
3255
3256 ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
3257 return 1;
3258invalid_opcode:
3259
3260 ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
3261 return 1;
3262}
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274static unsigned int ata_scsiop_maint_in(struct ata_scsi_args *args, u8 *rbuf)
3275{
3276 struct ata_device *dev = args->dev;
3277 u8 *cdb = args->cmd->cmnd;
3278 u8 supported = 0;
3279 unsigned int err = 0;
3280
3281 if (cdb[2] != 1) {
3282 ata_dev_warn(dev, "invalid command format %d\n", cdb[2]);
3283 err = 2;
3284 goto out;
3285 }
3286 switch (cdb[3]) {
3287 case INQUIRY:
3288 case MODE_SENSE:
3289 case MODE_SENSE_10:
3290 case READ_CAPACITY:
3291 case SERVICE_ACTION_IN_16:
3292 case REPORT_LUNS:
3293 case REQUEST_SENSE:
3294 case SYNCHRONIZE_CACHE:
3295 case REZERO_UNIT:
3296 case SEEK_6:
3297 case SEEK_10:
3298 case TEST_UNIT_READY:
3299 case SEND_DIAGNOSTIC:
3300 case MAINTENANCE_IN:
3301 case READ_6:
3302 case READ_10:
3303 case READ_16:
3304 case WRITE_6:
3305 case WRITE_10:
3306 case WRITE_16:
3307 case ATA_12:
3308 case ATA_16:
3309 case VERIFY:
3310 case VERIFY_16:
3311 case MODE_SELECT:
3312 case MODE_SELECT_10:
3313 case START_STOP:
3314 supported = 3;
3315 break;
3316 case ZBC_IN:
3317 case ZBC_OUT:
3318 if (ata_id_zoned_cap(dev->id) ||
3319 dev->class == ATA_DEV_ZAC)
3320 supported = 3;
3321 break;
3322 case SECURITY_PROTOCOL_IN:
3323 case SECURITY_PROTOCOL_OUT:
3324 if (dev->flags & ATA_DFLAG_TRUSTED)
3325 supported = 3;
3326 break;
3327 default:
3328 break;
3329 }
3330out:
3331 rbuf[1] = supported;
3332 return err;
3333}
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343static void ata_scsi_report_zones_complete(struct ata_queued_cmd *qc)
3344{
3345 struct scsi_cmnd *scmd = qc->scsicmd;
3346 struct sg_mapping_iter miter;
3347 unsigned long flags;
3348 unsigned int bytes = 0;
3349
3350 sg_miter_start(&miter, scsi_sglist(scmd), scsi_sg_count(scmd),
3351 SG_MITER_TO_SG | SG_MITER_ATOMIC);
3352
3353 local_irq_save(flags);
3354 while (sg_miter_next(&miter)) {
3355 unsigned int offset = 0;
3356
3357 if (bytes == 0) {
3358 char *hdr;
3359 u32 list_length;
3360 u64 max_lba, opt_lba;
3361 u16 same;
3362
3363
3364 hdr = miter.addr;
3365 list_length = get_unaligned_le32(&hdr[0]);
3366 same = get_unaligned_le16(&hdr[4]);
3367 max_lba = get_unaligned_le64(&hdr[8]);
3368 opt_lba = get_unaligned_le64(&hdr[16]);
3369 put_unaligned_be32(list_length, &hdr[0]);
3370 hdr[4] = same & 0xf;
3371 put_unaligned_be64(max_lba, &hdr[8]);
3372 put_unaligned_be64(opt_lba, &hdr[16]);
3373 offset += 64;
3374 bytes += 64;
3375 }
3376 while (offset < miter.length) {
3377 char *rec;
3378 u8 cond, type, non_seq, reset;
3379 u64 size, start, wp;
3380
3381
3382 rec = miter.addr + offset;
3383 type = rec[0] & 0xf;
3384 cond = (rec[1] >> 4) & 0xf;
3385 non_seq = (rec[1] & 2);
3386 reset = (rec[1] & 1);
3387 size = get_unaligned_le64(&rec[8]);
3388 start = get_unaligned_le64(&rec[16]);
3389 wp = get_unaligned_le64(&rec[24]);
3390 rec[0] = type;
3391 rec[1] = (cond << 4) | non_seq | reset;
3392 put_unaligned_be64(size, &rec[8]);
3393 put_unaligned_be64(start, &rec[16]);
3394 put_unaligned_be64(wp, &rec[24]);
3395 WARN_ON(offset + 64 > miter.length);
3396 offset += 64;
3397 bytes += 64;
3398 }
3399 }
3400 sg_miter_stop(&miter);
3401 local_irq_restore(flags);
3402
3403 ata_scsi_qc_complete(qc);
3404}
3405
3406static unsigned int ata_scsi_zbc_in_xlat(struct ata_queued_cmd *qc)
3407{
3408 struct ata_taskfile *tf = &qc->tf;
3409 struct scsi_cmnd *scmd = qc->scsicmd;
3410 const u8 *cdb = scmd->cmnd;
3411 u16 sect, fp = (u16)-1;
3412 u8 sa, options, bp = 0xff;
3413 u64 block;
3414 u32 n_block;
3415
3416 if (unlikely(scmd->cmd_len < 16)) {
3417 ata_dev_warn(qc->dev, "invalid cdb length %d\n",
3418 scmd->cmd_len);
3419 fp = 15;
3420 goto invalid_fld;
3421 }
3422 scsi_16_lba_len(cdb, &block, &n_block);
3423 if (n_block != scsi_bufflen(scmd)) {
3424 ata_dev_warn(qc->dev, "non-matching transfer count (%d/%d)\n",
3425 n_block, scsi_bufflen(scmd));
3426 goto invalid_param_len;
3427 }
3428 sa = cdb[1] & 0x1f;
3429 if (sa != ZI_REPORT_ZONES) {
3430 ata_dev_warn(qc->dev, "invalid service action %d\n", sa);
3431 fp = 1;
3432 goto invalid_fld;
3433 }
3434
3435
3436
3437
3438 if ((n_block / 512) > 0xffff || n_block < 512 || (n_block % 512)) {
3439 ata_dev_warn(qc->dev, "invalid transfer count %d\n", n_block);
3440 goto invalid_param_len;
3441 }
3442 sect = n_block / 512;
3443 options = cdb[14] & 0xbf;
3444
3445 if (ata_ncq_enabled(qc->dev) &&
3446 ata_fpdma_zac_mgmt_in_supported(qc->dev)) {
3447 tf->protocol = ATA_PROT_NCQ;
3448 tf->command = ATA_CMD_FPDMA_RECV;
3449 tf->hob_nsect = ATA_SUBCMD_FPDMA_RECV_ZAC_MGMT_IN & 0x1f;
3450 tf->nsect = qc->hw_tag << 3;
3451 tf->feature = sect & 0xff;
3452 tf->hob_feature = (sect >> 8) & 0xff;
3453 tf->auxiliary = ATA_SUBCMD_ZAC_MGMT_IN_REPORT_ZONES | (options << 8);
3454 } else {
3455 tf->command = ATA_CMD_ZAC_MGMT_IN;
3456 tf->feature = ATA_SUBCMD_ZAC_MGMT_IN_REPORT_ZONES;
3457 tf->protocol = ATA_PROT_DMA;
3458 tf->hob_feature = options;
3459 tf->hob_nsect = (sect >> 8) & 0xff;
3460 tf->nsect = sect & 0xff;
3461 }
3462 tf->device = ATA_LBA;
3463 tf->lbah = (block >> 16) & 0xff;
3464 tf->lbam = (block >> 8) & 0xff;
3465 tf->lbal = block & 0xff;
3466 tf->hob_lbah = (block >> 40) & 0xff;
3467 tf->hob_lbam = (block >> 32) & 0xff;
3468 tf->hob_lbal = (block >> 24) & 0xff;
3469
3470 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48;
3471 qc->flags |= ATA_QCFLAG_RESULT_TF;
3472
3473 ata_qc_set_pc_nbytes(qc);
3474
3475 qc->complete_fn = ata_scsi_report_zones_complete;
3476
3477 return 0;
3478
3479invalid_fld:
3480 ata_scsi_set_invalid_field(qc->dev, scmd, fp, bp);
3481 return 1;
3482
3483invalid_param_len:
3484
3485 ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
3486 return 1;
3487}
3488
3489static unsigned int ata_scsi_zbc_out_xlat(struct ata_queued_cmd *qc)
3490{
3491 struct ata_taskfile *tf = &qc->tf;
3492 struct scsi_cmnd *scmd = qc->scsicmd;
3493 struct ata_device *dev = qc->dev;
3494 const u8 *cdb = scmd->cmnd;
3495 u8 all, sa;
3496 u64 block;
3497 u32 n_block;
3498 u16 fp = (u16)-1;
3499
3500 if (unlikely(scmd->cmd_len < 16)) {
3501 fp = 15;
3502 goto invalid_fld;
3503 }
3504
3505 sa = cdb[1] & 0x1f;
3506 if ((sa != ZO_CLOSE_ZONE) && (sa != ZO_FINISH_ZONE) &&
3507 (sa != ZO_OPEN_ZONE) && (sa != ZO_RESET_WRITE_POINTER)) {
3508 fp = 1;
3509 goto invalid_fld;
3510 }
3511
3512 scsi_16_lba_len(cdb, &block, &n_block);
3513 if (n_block) {
3514
3515
3516
3517 goto invalid_param_len;
3518 }
3519
3520 all = cdb[14] & 0x1;
3521 if (all) {
3522
3523
3524
3525 block = 0;
3526 } else if (block >= dev->n_sectors) {
3527
3528
3529
3530 fp = 2;
3531 goto invalid_fld;
3532 }
3533
3534 if (ata_ncq_enabled(qc->dev) &&
3535 ata_fpdma_zac_mgmt_out_supported(qc->dev)) {
3536 tf->protocol = ATA_PROT_NCQ_NODATA;
3537 tf->command = ATA_CMD_NCQ_NON_DATA;
3538 tf->feature = ATA_SUBCMD_NCQ_NON_DATA_ZAC_MGMT_OUT;
3539 tf->nsect = qc->hw_tag << 3;
3540 tf->auxiliary = sa | ((u16)all << 8);
3541 } else {
3542 tf->protocol = ATA_PROT_NODATA;
3543 tf->command = ATA_CMD_ZAC_MGMT_OUT;
3544 tf->feature = sa;
3545 tf->hob_feature = all;
3546 }
3547 tf->lbah = (block >> 16) & 0xff;
3548 tf->lbam = (block >> 8) & 0xff;
3549 tf->lbal = block & 0xff;
3550 tf->hob_lbah = (block >> 40) & 0xff;
3551 tf->hob_lbam = (block >> 32) & 0xff;
3552 tf->hob_lbal = (block >> 24) & 0xff;
3553 tf->device = ATA_LBA;
3554 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_LBA48;
3555
3556 return 0;
3557
3558 invalid_fld:
3559 ata_scsi_set_invalid_field(qc->dev, scmd, fp, 0xff);
3560 return 1;
3561invalid_param_len:
3562
3563 ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
3564 return 1;
3565}
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579static int ata_mselect_caching(struct ata_queued_cmd *qc,
3580 const u8 *buf, int len, u16 *fp)
3581{
3582 struct ata_taskfile *tf = &qc->tf;
3583 struct ata_device *dev = qc->dev;
3584 u8 mpage[CACHE_MPAGE_LEN];
3585 u8 wce;
3586 int i;
3587
3588
3589
3590
3591
3592
3593 if (len != CACHE_MPAGE_LEN - 2) {
3594 if (len < CACHE_MPAGE_LEN - 2)
3595 *fp = len;
3596 else
3597 *fp = CACHE_MPAGE_LEN - 2;
3598 return -EINVAL;
3599 }
3600
3601 wce = buf[0] & (1 << 2);
3602
3603
3604
3605
3606 ata_msense_caching(dev->id, mpage, false);
3607 for (i = 0; i < CACHE_MPAGE_LEN - 2; i++) {
3608 if (i == 0)
3609 continue;
3610 if (mpage[i + 2] != buf[i]) {
3611 *fp = i;
3612 return -EINVAL;
3613 }
3614 }
3615
3616 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
3617 tf->protocol = ATA_PROT_NODATA;
3618 tf->nsect = 0;
3619 tf->command = ATA_CMD_SET_FEATURES;
3620 tf->feature = wce ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
3621 return 0;
3622}
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636static int ata_mselect_control(struct ata_queued_cmd *qc,
3637 const u8 *buf, int len, u16 *fp)
3638{
3639 struct ata_device *dev = qc->dev;
3640 u8 mpage[CONTROL_MPAGE_LEN];
3641 u8 d_sense;
3642 int i;
3643
3644
3645
3646
3647
3648
3649 if (len != CONTROL_MPAGE_LEN - 2) {
3650 if (len < CONTROL_MPAGE_LEN - 2)
3651 *fp = len;
3652 else
3653 *fp = CONTROL_MPAGE_LEN - 2;
3654 return -EINVAL;
3655 }
3656
3657 d_sense = buf[0] & (1 << 2);
3658
3659
3660
3661
3662 ata_msense_control(dev, mpage, false);
3663 for (i = 0; i < CONTROL_MPAGE_LEN - 2; i++) {
3664 if (i == 0)
3665 continue;
3666 if (mpage[2 + i] != buf[i]) {
3667 *fp = i;
3668 return -EINVAL;
3669 }
3670 }
3671 if (d_sense & (1 << 2))
3672 dev->flags |= ATA_DFLAG_D_SENSE;
3673 else
3674 dev->flags &= ~ATA_DFLAG_D_SENSE;
3675 return 0;
3676}
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc)
3690{
3691 struct scsi_cmnd *scmd = qc->scsicmd;
3692 const u8 *cdb = scmd->cmnd;
3693 u8 pg, spg;
3694 unsigned six_byte, pg_len, hdr_len, bd_len;
3695 int len;
3696 u16 fp = (u16)-1;
3697 u8 bp = 0xff;
3698 u8 buffer[64];
3699 const u8 *p = buffer;
3700
3701 VPRINTK("ENTER\n");
3702
3703 six_byte = (cdb[0] == MODE_SELECT);
3704 if (six_byte) {
3705 if (scmd->cmd_len < 5) {
3706 fp = 4;
3707 goto invalid_fld;
3708 }
3709
3710 len = cdb[4];
3711 hdr_len = 4;
3712 } else {
3713 if (scmd->cmd_len < 9) {
3714 fp = 8;
3715 goto invalid_fld;
3716 }
3717
3718 len = (cdb[7] << 8) + cdb[8];
3719 hdr_len = 8;
3720 }
3721
3722
3723 if ((cdb[1] & 0x11) != 0x10) {
3724 fp = 1;
3725 bp = (cdb[1] & 0x01) ? 1 : 5;
3726 goto invalid_fld;
3727 }
3728
3729
3730 if (!scsi_sg_count(scmd) || scsi_sglist(scmd)->length < len)
3731 goto invalid_param_len;
3732
3733
3734 if (len < hdr_len)
3735 goto invalid_param_len;
3736
3737 if (!sg_copy_to_buffer(scsi_sglist(scmd), scsi_sg_count(scmd),
3738 buffer, sizeof(buffer)))
3739 goto invalid_param_len;
3740
3741 if (six_byte)
3742 bd_len = p[3];
3743 else
3744 bd_len = (p[6] << 8) + p[7];
3745
3746 len -= hdr_len;
3747 p += hdr_len;
3748 if (len < bd_len)
3749 goto invalid_param_len;
3750 if (bd_len != 0 && bd_len != 8) {
3751 fp = (six_byte) ? 3 : 6;
3752 fp += bd_len + hdr_len;
3753 goto invalid_param;
3754 }
3755
3756 len -= bd_len;
3757 p += bd_len;
3758 if (len == 0)
3759 goto skip;
3760
3761
3762 pg = p[0] & 0x3f;
3763 if (p[0] & 0x40) {
3764 if (len < 4)
3765 goto invalid_param_len;
3766
3767 spg = p[1];
3768 pg_len = (p[2] << 8) | p[3];
3769 p += 4;
3770 len -= 4;
3771 } else {
3772 if (len < 2)
3773 goto invalid_param_len;
3774
3775 spg = 0;
3776 pg_len = p[1];
3777 p += 2;
3778 len -= 2;
3779 }
3780
3781
3782
3783
3784
3785 if (spg && (spg != ALL_SUB_MPAGES)) {
3786 fp = (p[0] & 0x40) ? 1 : 0;
3787 fp += hdr_len + bd_len;
3788 goto invalid_param;
3789 }
3790 if (pg_len > len)
3791 goto invalid_param_len;
3792
3793 switch (pg) {
3794 case CACHE_MPAGE:
3795 if (ata_mselect_caching(qc, p, pg_len, &fp) < 0) {
3796 fp += hdr_len + bd_len;
3797 goto invalid_param;
3798 }
3799 break;
3800 case CONTROL_MPAGE:
3801 if (ata_mselect_control(qc, p, pg_len, &fp) < 0) {
3802 fp += hdr_len + bd_len;
3803 goto invalid_param;
3804 } else {
3805 goto skip;
3806 }
3807 break;
3808 default:
3809 fp = bd_len + hdr_len;
3810 goto invalid_param;
3811 }
3812
3813
3814
3815
3816
3817 if (len > pg_len)
3818 goto invalid_param;
3819
3820 return 0;
3821
3822 invalid_fld:
3823 ata_scsi_set_invalid_field(qc->dev, scmd, fp, bp);
3824 return 1;
3825
3826 invalid_param:
3827 ata_scsi_set_invalid_parameter(qc->dev, scmd, fp);
3828 return 1;
3829
3830 invalid_param_len:
3831
3832 ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
3833 return 1;
3834
3835 skip:
3836 scmd->result = SAM_STAT_GOOD;
3837 return 1;
3838}
3839
3840static u8 ata_scsi_trusted_op(u32 len, bool send, bool dma)
3841{
3842 if (len == 0)
3843 return ATA_CMD_TRUSTED_NONDATA;
3844 else if (send)
3845 return dma ? ATA_CMD_TRUSTED_SND_DMA : ATA_CMD_TRUSTED_SND;
3846 else
3847 return dma ? ATA_CMD_TRUSTED_RCV_DMA : ATA_CMD_TRUSTED_RCV;
3848}
3849
3850static unsigned int ata_scsi_security_inout_xlat(struct ata_queued_cmd *qc)
3851{
3852 struct scsi_cmnd *scmd = qc->scsicmd;
3853 const u8 *cdb = scmd->cmnd;
3854 struct ata_taskfile *tf = &qc->tf;
3855 u8 secp = cdb[1];
3856 bool send = (cdb[0] == SECURITY_PROTOCOL_OUT);
3857 u16 spsp = get_unaligned_be16(&cdb[2]);
3858 u32 len = get_unaligned_be32(&cdb[6]);
3859 bool dma = !(qc->dev->flags & ATA_DFLAG_PIO);
3860
3861
3862
3863
3864 if (secp == 0xef) {
3865 ata_scsi_set_invalid_field(qc->dev, scmd, 1, 0);
3866 return 1;
3867 }
3868
3869 if (cdb[4] & 7) {
3870 if (len > 0xffff) {
3871 ata_scsi_set_invalid_field(qc->dev, scmd, 6, 0);
3872 return 1;
3873 }
3874 } else {
3875 if (len > 0x01fffe00) {
3876 ata_scsi_set_invalid_field(qc->dev, scmd, 6, 0);
3877 return 1;
3878 }
3879
3880
3881 len = (len + 511) / 512;
3882 }
3883
3884 tf->protocol = dma ? ATA_PROT_DMA : ATA_PROT_PIO;
3885 tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR | ATA_TFLAG_LBA;
3886 if (send)
3887 tf->flags |= ATA_TFLAG_WRITE;
3888 tf->command = ata_scsi_trusted_op(len, send, dma);
3889 tf->feature = secp;
3890 tf->lbam = spsp & 0xff;
3891 tf->lbah = spsp >> 8;
3892
3893 if (len) {
3894 tf->nsect = len & 0xff;
3895 tf->lbal = len >> 8;
3896 } else {
3897 if (!send)
3898 tf->lbah = (1 << 7);
3899 }
3900
3901 ata_qc_set_pc_nbytes(qc);
3902 return 0;
3903}
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916static unsigned int ata_scsi_var_len_cdb_xlat(struct ata_queued_cmd *qc)
3917{
3918 struct scsi_cmnd *scmd = qc->scsicmd;
3919 const u8 *cdb = scmd->cmnd;
3920 const u16 sa = get_unaligned_be16(&cdb[8]);
3921
3922
3923
3924
3925
3926 if (sa == ATA_32)
3927 return ata_scsi_pass_thru(qc);
3928
3929
3930 return 1;
3931}
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
3946{
3947 switch (cmd) {
3948 case READ_6:
3949 case READ_10:
3950 case READ_16:
3951
3952 case WRITE_6:
3953 case WRITE_10:
3954 case WRITE_16:
3955 return ata_scsi_rw_xlat;
3956
3957 case WRITE_SAME_16:
3958 return ata_scsi_write_same_xlat;
3959
3960 case SYNCHRONIZE_CACHE:
3961 if (ata_try_flush_cache(dev))
3962 return ata_scsi_flush_xlat;
3963 break;
3964
3965 case VERIFY:
3966 case VERIFY_16:
3967 return ata_scsi_verify_xlat;
3968
3969 case ATA_12:
3970 case ATA_16:
3971 return ata_scsi_pass_thru;
3972
3973 case VARIABLE_LENGTH_CMD:
3974 return ata_scsi_var_len_cdb_xlat;
3975
3976 case MODE_SELECT:
3977 case MODE_SELECT_10:
3978 return ata_scsi_mode_select_xlat;
3979 break;
3980
3981 case ZBC_IN:
3982 return ata_scsi_zbc_in_xlat;
3983
3984 case ZBC_OUT:
3985 return ata_scsi_zbc_out_xlat;
3986
3987 case SECURITY_PROTOCOL_IN:
3988 case SECURITY_PROTOCOL_OUT:
3989 if (!(dev->flags & ATA_DFLAG_TRUSTED))
3990 break;
3991 return ata_scsi_security_inout_xlat;
3992
3993 case START_STOP:
3994 return ata_scsi_start_stop_xlat;
3995 }
3996
3997 return NULL;
3998}
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008void ata_scsi_dump_cdb(struct ata_port *ap, struct scsi_cmnd *cmd)
4009{
4010#ifdef ATA_VERBOSE_DEBUG
4011 struct scsi_device *scsidev = cmd->device;
4012
4013 VPRINTK("CDB (%u:%d,%d,%lld) %9ph\n",
4014 ap->print_id,
4015 scsidev->channel, scsidev->id, scsidev->lun,
4016 cmd->cmnd);
4017#endif
4018}
4019
4020int __ata_scsi_queuecmd(struct scsi_cmnd *scmd, struct ata_device *dev)
4021{
4022 u8 scsi_op = scmd->cmnd[0];
4023 ata_xlat_func_t xlat_func;
4024 int rc = 0;
4025
4026 if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
4027 if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
4028 goto bad_cdb_len;
4029
4030 xlat_func = ata_get_xlat_func(dev, scsi_op);
4031 } else {
4032 if (unlikely(!scmd->cmd_len))
4033 goto bad_cdb_len;
4034
4035 xlat_func = NULL;
4036 if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
4037
4038 int len = COMMAND_SIZE(scsi_op);
4039 if (unlikely(len > scmd->cmd_len ||
4040 len > dev->cdb_len ||
4041 scmd->cmd_len > ATAPI_CDB_LEN))
4042 goto bad_cdb_len;
4043
4044 xlat_func = atapi_xlat;
4045 } else {
4046
4047 if (unlikely(scmd->cmd_len > 16))
4048 goto bad_cdb_len;
4049
4050 xlat_func = ata_get_xlat_func(dev, scsi_op);
4051 }
4052 }
4053
4054 if (xlat_func)
4055 rc = ata_scsi_translate(dev, scmd, xlat_func);
4056 else
4057 ata_scsi_simulate(dev, scmd);
4058
4059 return rc;
4060
4061 bad_cdb_len:
4062 DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
4063 scmd->cmd_len, scsi_op, dev->cdb_len);
4064 scmd->result = DID_ERROR << 16;
4065 scsi_done(scmd);
4066 return 0;
4067}
4068
4069
4070
4071
4072
4073
4074
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086
4087
4088int ata_scsi_queuecmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
4089{
4090 struct ata_port *ap;
4091 struct ata_device *dev;
4092 struct scsi_device *scsidev = cmd->device;
4093 int rc = 0;
4094 unsigned long irq_flags;
4095
4096 ap = ata_shost_to_port(shost);
4097
4098 spin_lock_irqsave(ap->lock, irq_flags);
4099
4100 ata_scsi_dump_cdb(ap, cmd);
4101
4102 dev = ata_scsi_find_dev(ap, scsidev);
4103 if (likely(dev))
4104 rc = __ata_scsi_queuecmd(cmd, dev);
4105 else {
4106 cmd->result = (DID_BAD_TARGET << 16);
4107 scsi_done(cmd);
4108 }
4109
4110 spin_unlock_irqrestore(ap->lock, irq_flags);
4111
4112 return rc;
4113}
4114EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
4115
4116
4117
4118
4119
4120
4121
4122
4123
4124
4125
4126
4127
4128void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
4129{
4130 struct ata_scsi_args args;
4131 const u8 *scsicmd = cmd->cmnd;
4132 u8 tmp8;
4133
4134 args.dev = dev;
4135 args.id = dev->id;
4136 args.cmd = cmd;
4137
4138 switch(scsicmd[0]) {
4139 case INQUIRY:
4140 if (scsicmd[1] & 2)
4141 ata_scsi_set_invalid_field(dev, cmd, 1, 0xff);
4142 else if ((scsicmd[1] & 1) == 0)
4143 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
4144 else switch (scsicmd[2]) {
4145 case 0x00:
4146 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
4147 break;
4148 case 0x80:
4149 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
4150 break;
4151 case 0x83:
4152 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
4153 break;
4154 case 0x89:
4155 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
4156 break;
4157 case 0xb0:
4158 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b0);
4159 break;
4160 case 0xb1:
4161 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b1);
4162 break;
4163 case 0xb2:
4164 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b2);
4165 break;
4166 case 0xb6:
4167 if (dev->flags & ATA_DFLAG_ZAC)
4168 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b6);
4169 else
4170 ata_scsi_set_invalid_field(dev, cmd, 2, 0xff);
4171 break;
4172 case 0xb9:
4173 if (dev->cpr_log)
4174 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_b9);
4175 else
4176 ata_scsi_set_invalid_field(dev, cmd, 2, 0xff);
4177 break;
4178 default:
4179 ata_scsi_set_invalid_field(dev, cmd, 2, 0xff);
4180 break;
4181 }
4182 break;
4183
4184 case MODE_SENSE:
4185 case MODE_SENSE_10:
4186 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
4187 break;
4188
4189 case READ_CAPACITY:
4190 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
4191 break;
4192
4193 case SERVICE_ACTION_IN_16:
4194 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
4195 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
4196 else
4197 ata_scsi_set_invalid_field(dev, cmd, 1, 0xff);
4198 break;
4199
4200 case REPORT_LUNS:
4201 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
4202 break;
4203
4204 case REQUEST_SENSE:
4205 ata_scsi_set_sense(dev, cmd, 0, 0, 0);
4206 break;
4207
4208
4209
4210
4211 case SYNCHRONIZE_CACHE:
4212 fallthrough;
4213
4214
4215 case REZERO_UNIT:
4216 case SEEK_6:
4217 case SEEK_10:
4218 case TEST_UNIT_READY:
4219 break;
4220
4221 case SEND_DIAGNOSTIC:
4222 tmp8 = scsicmd[1] & ~(1 << 3);
4223 if (tmp8 != 0x4 || scsicmd[3] || scsicmd[4])
4224 ata_scsi_set_invalid_field(dev, cmd, 1, 0xff);
4225 break;
4226
4227 case MAINTENANCE_IN:
4228 if (scsicmd[1] == MI_REPORT_SUPPORTED_OPERATION_CODES)
4229 ata_scsi_rbuf_fill(&args, ata_scsiop_maint_in);
4230 else
4231 ata_scsi_set_invalid_field(dev, cmd, 1, 0xff);
4232 break;
4233
4234
4235 default:
4236 ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x20, 0x0);
4237
4238 break;
4239 }
4240
4241 scsi_done(cmd);
4242}
4243
4244int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
4245{
4246 int i, rc;
4247
4248 for (i = 0; i < host->n_ports; i++) {
4249 struct ata_port *ap = host->ports[i];
4250 struct Scsi_Host *shost;
4251
4252 rc = -ENOMEM;
4253 shost = scsi_host_alloc(sht, sizeof(struct ata_port *));
4254 if (!shost)
4255 goto err_alloc;
4256
4257 shost->eh_noresume = 1;
4258 *(struct ata_port **)&shost->hostdata[0] = ap;
4259 ap->scsi_host = shost;
4260
4261 shost->transportt = ata_scsi_transport_template;
4262 shost->unique_id = ap->print_id;
4263 shost->max_id = 16;
4264 shost->max_lun = 1;
4265 shost->max_channel = 1;
4266 shost->max_cmd_len = 32;
4267
4268
4269
4270
4271
4272
4273 shost->max_host_blocked = 1;
4274
4275 rc = scsi_add_host_with_dma(shost, &ap->tdev, ap->host->dev);
4276 if (rc)
4277 goto err_alloc;
4278 }
4279
4280 return 0;
4281
4282 err_alloc:
4283 while (--i >= 0) {
4284 struct Scsi_Host *shost = host->ports[i]->scsi_host;
4285
4286
4287 scsi_remove_host(shost);
4288 }
4289 return rc;
4290}
4291
4292#ifdef CONFIG_OF
4293static void ata_scsi_assign_ofnode(struct ata_device *dev, struct ata_port *ap)
4294{
4295 struct scsi_device *sdev = dev->sdev;
4296 struct device *d = ap->host->dev;
4297 struct device_node *np = d->of_node;
4298 struct device_node *child;
4299
4300 for_each_available_child_of_node(np, child) {
4301 int ret;
4302 u32 val;
4303
4304 ret = of_property_read_u32(child, "reg", &val);
4305 if (ret)
4306 continue;
4307 if (val == dev->devno) {
4308 dev_dbg(d, "found matching device node\n");
4309 sdev->sdev_gendev.of_node = child;
4310 return;
4311 }
4312 }
4313}
4314#else
4315static void ata_scsi_assign_ofnode(struct ata_device *dev, struct ata_port *ap)
4316{
4317}
4318#endif
4319
4320void ata_scsi_scan_host(struct ata_port *ap, int sync)
4321{
4322 int tries = 5;
4323 struct ata_device *last_failed_dev = NULL;
4324 struct ata_link *link;
4325 struct ata_device *dev;
4326
4327 repeat:
4328 ata_for_each_link(link, ap, EDGE) {
4329 ata_for_each_dev(dev, link, ENABLED) {
4330 struct scsi_device *sdev;
4331 int channel = 0, id = 0;
4332
4333 if (dev->sdev)
4334 continue;
4335
4336 if (ata_is_host_link(link))
4337 id = dev->devno;
4338 else
4339 channel = link->pmp;
4340
4341 sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
4342 NULL);
4343 if (!IS_ERR(sdev)) {
4344 dev->sdev = sdev;
4345 ata_scsi_assign_ofnode(dev, ap);
4346 scsi_device_put(sdev);
4347 } else {
4348 dev->sdev = NULL;
4349 }
4350 }
4351 }
4352
4353
4354
4355
4356
4357 ata_for_each_link(link, ap, EDGE) {
4358 ata_for_each_dev(dev, link, ENABLED) {
4359 if (!dev->sdev)
4360 goto exit_loop;
4361 }
4362 }
4363 exit_loop:
4364 if (!link)
4365 return;
4366
4367
4368 if (sync) {
4369
4370
4371
4372 if (dev != last_failed_dev) {
4373 msleep(100);
4374 last_failed_dev = dev;
4375 goto repeat;
4376 }
4377
4378
4379
4380
4381 if (--tries) {
4382 msleep(100);
4383 goto repeat;
4384 }
4385
4386 ata_port_err(ap,
4387 "WARNING: synchronous SCSI scan failed without making any progress, switching to async\n");
4388 }
4389
4390 queue_delayed_work(system_long_wq, &ap->hotplug_task,
4391 round_jiffies_relative(HZ));
4392}
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409int ata_scsi_offline_dev(struct ata_device *dev)
4410{
4411 if (dev->sdev) {
4412 scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
4413 return 1;
4414 }
4415 return 0;
4416}
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428static void ata_scsi_remove_dev(struct ata_device *dev)
4429{
4430 struct ata_port *ap = dev->link->ap;
4431 struct scsi_device *sdev;
4432 unsigned long flags;
4433
4434
4435
4436
4437
4438
4439
4440 mutex_lock(&ap->scsi_host->scan_mutex);
4441 spin_lock_irqsave(ap->lock, flags);
4442
4443
4444 sdev = dev->sdev;
4445 dev->sdev = NULL;
4446
4447 if (sdev) {
4448
4449
4450
4451
4452 if (scsi_device_get(sdev) == 0) {
4453
4454
4455
4456
4457
4458 scsi_device_set_state(sdev, SDEV_OFFLINE);
4459 } else {
4460 WARN_ON(1);
4461 sdev = NULL;
4462 }
4463 }
4464
4465 spin_unlock_irqrestore(ap->lock, flags);
4466 mutex_unlock(&ap->scsi_host->scan_mutex);
4467
4468 if (sdev) {
4469 ata_dev_info(dev, "detaching (SCSI %s)\n",
4470 dev_name(&sdev->sdev_gendev));
4471
4472 scsi_remove_device(sdev);
4473 scsi_device_put(sdev);
4474 }
4475}
4476
4477static void ata_scsi_handle_link_detach(struct ata_link *link)
4478{
4479 struct ata_port *ap = link->ap;
4480 struct ata_device *dev;
4481
4482 ata_for_each_dev(dev, link, ALL) {
4483 unsigned long flags;
4484
4485 if (!(dev->flags & ATA_DFLAG_DETACHED))
4486 continue;
4487
4488 spin_lock_irqsave(ap->lock, flags);
4489 dev->flags &= ~ATA_DFLAG_DETACHED;
4490 spin_unlock_irqrestore(ap->lock, flags);
4491
4492 if (zpodd_dev_enabled(dev))
4493 zpodd_exit(dev);
4494
4495 ata_scsi_remove_dev(dev);
4496 }
4497}
4498
4499
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509void ata_scsi_media_change_notify(struct ata_device *dev)
4510{
4511 if (dev->sdev)
4512 sdev_evt_send_simple(dev->sdev, SDEV_EVT_MEDIA_CHANGE,
4513 GFP_ATOMIC);
4514}
4515
4516
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
4528void ata_scsi_hotplug(struct work_struct *work)
4529{
4530 struct ata_port *ap =
4531 container_of(work, struct ata_port, hotplug_task.work);
4532 int i;
4533
4534 if (ap->pflags & ATA_PFLAG_UNLOADING) {
4535 DPRINTK("ENTER/EXIT - unloading\n");
4536 return;
4537 }
4538
4539 DPRINTK("ENTER\n");
4540 mutex_lock(&ap->scsi_scan_mutex);
4541
4542
4543
4544
4545
4546 ata_scsi_handle_link_detach(&ap->link);
4547 if (ap->pmp_link)
4548 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
4549 ata_scsi_handle_link_detach(&ap->pmp_link[i]);
4550
4551
4552 ata_scsi_scan_host(ap, 0);
4553
4554 mutex_unlock(&ap->scsi_scan_mutex);
4555 DPRINTK("EXIT\n");
4556}
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569
4570
4571
4572
4573
4574int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
4575 unsigned int id, u64 lun)
4576{
4577 struct ata_port *ap = ata_shost_to_port(shost);
4578 unsigned long flags;
4579 int devno, rc = 0;
4580
4581 if (!ap->ops->error_handler)
4582 return -EOPNOTSUPP;
4583
4584 if (lun != SCAN_WILD_CARD && lun)
4585 return -EINVAL;
4586
4587 if (!sata_pmp_attached(ap)) {
4588 if (channel != SCAN_WILD_CARD && channel)
4589 return -EINVAL;
4590 devno = id;
4591 } else {
4592 if (id != SCAN_WILD_CARD && id)
4593 return -EINVAL;
4594 devno = channel;
4595 }
4596
4597 spin_lock_irqsave(ap->lock, flags);
4598
4599 if (devno == SCAN_WILD_CARD) {
4600 struct ata_link *link;
4601
4602 ata_for_each_link(link, ap, EDGE) {
4603 struct ata_eh_info *ehi = &link->eh_info;
4604 ehi->probe_mask |= ATA_ALL_DEVICES;
4605 ehi->action |= ATA_EH_RESET;
4606 }
4607 } else {
4608 struct ata_device *dev = ata_find_dev(ap, devno);
4609
4610 if (dev) {
4611 struct ata_eh_info *ehi = &dev->link->eh_info;
4612 ehi->probe_mask |= 1 << dev->devno;
4613 ehi->action |= ATA_EH_RESET;
4614 } else
4615 rc = -EINVAL;
4616 }
4617
4618 if (rc == 0) {
4619 ata_port_schedule_eh(ap);
4620 spin_unlock_irqrestore(ap->lock, flags);
4621 ata_port_wait_eh(ap);
4622 } else
4623 spin_unlock_irqrestore(ap->lock, flags);
4624
4625 return rc;
4626}
4627
4628
4629
4630
4631
4632
4633
4634
4635
4636
4637
4638void ata_scsi_dev_rescan(struct work_struct *work)
4639{
4640 struct ata_port *ap =
4641 container_of(work, struct ata_port, scsi_rescan_task);
4642 struct ata_link *link;
4643 struct ata_device *dev;
4644 unsigned long flags;
4645
4646 mutex_lock(&ap->scsi_scan_mutex);
4647 spin_lock_irqsave(ap->lock, flags);
4648
4649 ata_for_each_link(link, ap, EDGE) {
4650 ata_for_each_dev(dev, link, ENABLED) {
4651 struct scsi_device *sdev = dev->sdev;
4652
4653 if (!sdev)
4654 continue;
4655 if (scsi_device_get(sdev))
4656 continue;
4657
4658 spin_unlock_irqrestore(ap->lock, flags);
4659 scsi_rescan_device(&(sdev->sdev_gendev));
4660 scsi_device_put(sdev);
4661 spin_lock_irqsave(ap->lock, flags);
4662 }
4663 }
4664
4665 spin_unlock_irqrestore(ap->lock, flags);
4666 mutex_unlock(&ap->scsi_scan_mutex);
4667}
4668