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