1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/kernel.h>
29#include <linux/module.h>
30#include <linux/pci.h>
31#include <linux/init.h>
32#include <linux/list.h>
33#include <linux/mm.h>
34#include <linux/spinlock.h>
35#include <linux/blkdev.h>
36#include <linux/delay.h>
37#include <linux/timer.h>
38#include <linux/time.h>
39#include <linux/interrupt.h>
40#include <linux/completion.h>
41#include <linux/suspend.h>
42#include <linux/workqueue.h>
43#include <linux/scatterlist.h>
44#include <linux/io.h>
45#include <linux/log2.h>
46#include <linux/slab.h>
47#include <linux/glob.h>
48#include <scsi/scsi.h>
49#include <scsi/scsi_cmnd.h>
50#include <scsi/scsi_host.h>
51#include <linux/libata.h>
52#include <asm/byteorder.h>
53#include <asm/unaligned.h>
54#include <linux/cdrom.h>
55#include <linux/ratelimit.h>
56#include <linux/leds.h>
57#include <linux/pm_runtime.h>
58#include <linux/platform_device.h>
59#include <asm/setup.h>
60
61#define CREATE_TRACE_POINTS
62#include <trace/events/libata.h>
63
64#include "libata.h"
65#include "libata-transport.h"
66
67const struct ata_port_operations ata_base_port_ops = {
68 .prereset = ata_std_prereset,
69 .postreset = ata_std_postreset,
70 .error_handler = ata_std_error_handler,
71 .sched_eh = ata_std_sched_eh,
72 .end_eh = ata_std_end_eh,
73};
74
75const struct ata_port_operations sata_port_ops = {
76 .inherits = &ata_base_port_ops,
77
78 .qc_defer = ata_std_qc_defer,
79 .hardreset = sata_std_hardreset,
80};
81EXPORT_SYMBOL_GPL(sata_port_ops);
82
83static unsigned int ata_dev_init_params(struct ata_device *dev,
84 u16 heads, u16 sectors);
85static unsigned int ata_dev_set_xfermode(struct ata_device *dev);
86static void ata_dev_xfermask(struct ata_device *dev);
87static unsigned long ata_dev_blacklisted(const struct ata_device *dev);
88
89atomic_t ata_print_id = ATOMIC_INIT(0);
90
91#ifdef CONFIG_ATA_FORCE
92struct ata_force_param {
93 const char *name;
94 u8 cbl;
95 u8 spd_limit;
96 unsigned long xfer_mask;
97 unsigned int horkage_on;
98 unsigned int horkage_off;
99 u16 lflags;
100};
101
102struct ata_force_ent {
103 int port;
104 int device;
105 struct ata_force_param param;
106};
107
108static struct ata_force_ent *ata_force_tbl;
109static int ata_force_tbl_size;
110
111static char ata_force_param_buf[COMMAND_LINE_SIZE] __initdata;
112
113module_param_string(force, ata_force_param_buf, sizeof(ata_force_param_buf), 0);
114MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link speed and transfer mode (see Documentation/admin-guide/kernel-parameters.rst for details)");
115#endif
116
117static int atapi_enabled = 1;
118module_param(atapi_enabled, int, 0444);
119MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on [default])");
120
121static int atapi_dmadir = 0;
122module_param(atapi_dmadir, int, 0444);
123MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off [default], 1=on)");
124
125int atapi_passthru16 = 1;
126module_param(atapi_passthru16, int, 0444);
127MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices (0=off, 1=on [default])");
128
129int libata_fua = 0;
130module_param_named(fua, libata_fua, int, 0444);
131MODULE_PARM_DESC(fua, "FUA support (0=off [default], 1=on)");
132
133static int ata_ignore_hpa;
134module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
135MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
136
137static int libata_dma_mask = ATA_DMA_MASK_ATA|ATA_DMA_MASK_ATAPI|ATA_DMA_MASK_CFA;
138module_param_named(dma, libata_dma_mask, int, 0444);
139MODULE_PARM_DESC(dma, "DMA enable/disable (0x1==ATA, 0x2==ATAPI, 0x4==CF)");
140
141static int ata_probe_timeout;
142module_param(ata_probe_timeout, int, 0444);
143MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
144
145int libata_noacpi = 0;
146module_param_named(noacpi, libata_noacpi, int, 0444);
147MODULE_PARM_DESC(noacpi, "Disable the use of ACPI in probe/suspend/resume (0=off [default], 1=on)");
148
149int libata_allow_tpm = 0;
150module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
151MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands (0=off [default], 1=on)");
152
153static int atapi_an;
154module_param(atapi_an, int, 0444);
155MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)");
156
157MODULE_AUTHOR("Jeff Garzik");
158MODULE_DESCRIPTION("Library module for ATA devices");
159MODULE_LICENSE("GPL");
160MODULE_VERSION(DRV_VERSION);
161
162static inline bool ata_dev_print_info(struct ata_device *dev)
163{
164 struct ata_eh_context *ehc = &dev->link->eh_context;
165
166 return ehc->i.flags & ATA_EHI_PRINTINFO;
167}
168
169static bool ata_sstatus_online(u32 sstatus)
170{
171 return (sstatus & 0xf) == 0x3;
172}
173
174
175
176
177
178
179
180
181
182
183
184
185
186struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
187 enum ata_link_iter_mode mode)
188{
189 BUG_ON(mode != ATA_LITER_EDGE &&
190 mode != ATA_LITER_PMP_FIRST && mode != ATA_LITER_HOST_FIRST);
191
192
193 if (!link)
194 switch (mode) {
195 case ATA_LITER_EDGE:
196 case ATA_LITER_PMP_FIRST:
197 if (sata_pmp_attached(ap))
198 return ap->pmp_link;
199 fallthrough;
200 case ATA_LITER_HOST_FIRST:
201 return &ap->link;
202 }
203
204
205 if (link == &ap->link)
206 switch (mode) {
207 case ATA_LITER_HOST_FIRST:
208 if (sata_pmp_attached(ap))
209 return ap->pmp_link;
210 fallthrough;
211 case ATA_LITER_PMP_FIRST:
212 if (unlikely(ap->slave_link))
213 return ap->slave_link;
214 fallthrough;
215 case ATA_LITER_EDGE:
216 return NULL;
217 }
218
219
220 if (unlikely(link == ap->slave_link))
221 return NULL;
222
223
224 if (++link < ap->pmp_link + ap->nr_pmp_links)
225 return link;
226
227 if (mode == ATA_LITER_PMP_FIRST)
228 return &ap->link;
229
230 return NULL;
231}
232EXPORT_SYMBOL_GPL(ata_link_next);
233
234
235
236
237
238
239
240
241
242
243
244
245
246struct ata_device *ata_dev_next(struct ata_device *dev, struct ata_link *link,
247 enum ata_dev_iter_mode mode)
248{
249 BUG_ON(mode != ATA_DITER_ENABLED && mode != ATA_DITER_ENABLED_REVERSE &&
250 mode != ATA_DITER_ALL && mode != ATA_DITER_ALL_REVERSE);
251
252
253 if (!dev)
254 switch (mode) {
255 case ATA_DITER_ENABLED:
256 case ATA_DITER_ALL:
257 dev = link->device;
258 goto check;
259 case ATA_DITER_ENABLED_REVERSE:
260 case ATA_DITER_ALL_REVERSE:
261 dev = link->device + ata_link_max_devices(link) - 1;
262 goto check;
263 }
264
265 next:
266
267 switch (mode) {
268 case ATA_DITER_ENABLED:
269 case ATA_DITER_ALL:
270 if (++dev < link->device + ata_link_max_devices(link))
271 goto check;
272 return NULL;
273 case ATA_DITER_ENABLED_REVERSE:
274 case ATA_DITER_ALL_REVERSE:
275 if (--dev >= link->device)
276 goto check;
277 return NULL;
278 }
279
280 check:
281 if ((mode == ATA_DITER_ENABLED || mode == ATA_DITER_ENABLED_REVERSE) &&
282 !ata_dev_enabled(dev))
283 goto next;
284 return dev;
285}
286EXPORT_SYMBOL_GPL(ata_dev_next);
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302struct ata_link *ata_dev_phys_link(struct ata_device *dev)
303{
304 struct ata_port *ap = dev->link->ap;
305
306 if (!ap->slave_link)
307 return dev->link;
308 if (!dev->devno)
309 return &ap->link;
310 return ap->slave_link;
311}
312
313#ifdef CONFIG_ATA_FORCE
314
315
316
317
318
319
320
321
322
323
324
325
326
327void ata_force_cbl(struct ata_port *ap)
328{
329 int i;
330
331 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
332 const struct ata_force_ent *fe = &ata_force_tbl[i];
333
334 if (fe->port != -1 && fe->port != ap->print_id)
335 continue;
336
337 if (fe->param.cbl == ATA_CBL_NONE)
338 continue;
339
340 ap->cbl = fe->param.cbl;
341 ata_port_notice(ap, "FORCE: cable set to %s\n", fe->param.name);
342 return;
343 }
344}
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362static void ata_force_link_limits(struct ata_link *link)
363{
364 bool did_spd = false;
365 int linkno = link->pmp;
366 int i;
367
368 if (ata_is_host_link(link))
369 linkno += 15;
370
371 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
372 const struct ata_force_ent *fe = &ata_force_tbl[i];
373
374 if (fe->port != -1 && fe->port != link->ap->print_id)
375 continue;
376
377 if (fe->device != -1 && fe->device != linkno)
378 continue;
379
380
381 if (!did_spd && fe->param.spd_limit) {
382 link->hw_sata_spd_limit = (1 << fe->param.spd_limit) - 1;
383 ata_link_notice(link, "FORCE: PHY spd limit set to %s\n",
384 fe->param.name);
385 did_spd = true;
386 }
387
388
389 if (fe->param.lflags) {
390 link->flags |= fe->param.lflags;
391 ata_link_notice(link,
392 "FORCE: link flag 0x%x forced -> 0x%x\n",
393 fe->param.lflags, link->flags);
394 }
395 }
396}
397
398
399
400
401
402
403
404
405
406
407
408
409static void ata_force_xfermask(struct ata_device *dev)
410{
411 int devno = dev->link->pmp + dev->devno;
412 int alt_devno = devno;
413 int i;
414
415
416 if (ata_is_host_link(dev->link))
417 alt_devno += 15;
418
419 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
420 const struct ata_force_ent *fe = &ata_force_tbl[i];
421 unsigned long pio_mask, mwdma_mask, udma_mask;
422
423 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
424 continue;
425
426 if (fe->device != -1 && fe->device != devno &&
427 fe->device != alt_devno)
428 continue;
429
430 if (!fe->param.xfer_mask)
431 continue;
432
433 ata_unpack_xfermask(fe->param.xfer_mask,
434 &pio_mask, &mwdma_mask, &udma_mask);
435 if (udma_mask)
436 dev->udma_mask = udma_mask;
437 else if (mwdma_mask) {
438 dev->udma_mask = 0;
439 dev->mwdma_mask = mwdma_mask;
440 } else {
441 dev->udma_mask = 0;
442 dev->mwdma_mask = 0;
443 dev->pio_mask = pio_mask;
444 }
445
446 ata_dev_notice(dev, "FORCE: xfer_mask set to %s\n",
447 fe->param.name);
448 return;
449 }
450}
451
452
453
454
455
456
457
458
459
460
461
462
463static void ata_force_horkage(struct ata_device *dev)
464{
465 int devno = dev->link->pmp + dev->devno;
466 int alt_devno = devno;
467 int i;
468
469
470 if (ata_is_host_link(dev->link))
471 alt_devno += 15;
472
473 for (i = 0; i < ata_force_tbl_size; i++) {
474 const struct ata_force_ent *fe = &ata_force_tbl[i];
475
476 if (fe->port != -1 && fe->port != dev->link->ap->print_id)
477 continue;
478
479 if (fe->device != -1 && fe->device != devno &&
480 fe->device != alt_devno)
481 continue;
482
483 if (!(~dev->horkage & fe->param.horkage_on) &&
484 !(dev->horkage & fe->param.horkage_off))
485 continue;
486
487 dev->horkage |= fe->param.horkage_on;
488 dev->horkage &= ~fe->param.horkage_off;
489
490 ata_dev_notice(dev, "FORCE: horkage modified (%s)\n",
491 fe->param.name);
492 }
493}
494#else
495static inline void ata_force_link_limits(struct ata_link *link) { }
496static inline void ata_force_xfermask(struct ata_device *dev) { }
497static inline void ata_force_horkage(struct ata_device *dev) { }
498#endif
499
500
501
502
503
504
505
506
507
508
509
510
511
512int atapi_cmd_type(u8 opcode)
513{
514 switch (opcode) {
515 case GPCMD_READ_10:
516 case GPCMD_READ_12:
517 return ATAPI_READ;
518
519 case GPCMD_WRITE_10:
520 case GPCMD_WRITE_12:
521 case GPCMD_WRITE_AND_VERIFY_10:
522 return ATAPI_WRITE;
523
524 case GPCMD_READ_CD:
525 case GPCMD_READ_CD_MSF:
526 return ATAPI_READ_CD;
527
528 case ATA_16:
529 case ATA_12:
530 if (atapi_passthru16)
531 return ATAPI_PASS_THRU;
532 fallthrough;
533 default:
534 return ATAPI_MISC;
535 }
536}
537EXPORT_SYMBOL_GPL(atapi_cmd_type);
538
539static const u8 ata_rw_cmds[] = {
540
541 ATA_CMD_READ_MULTI,
542 ATA_CMD_WRITE_MULTI,
543 ATA_CMD_READ_MULTI_EXT,
544 ATA_CMD_WRITE_MULTI_EXT,
545 0,
546 0,
547 0,
548 ATA_CMD_WRITE_MULTI_FUA_EXT,
549
550 ATA_CMD_PIO_READ,
551 ATA_CMD_PIO_WRITE,
552 ATA_CMD_PIO_READ_EXT,
553 ATA_CMD_PIO_WRITE_EXT,
554 0,
555 0,
556 0,
557 0,
558
559 ATA_CMD_READ,
560 ATA_CMD_WRITE,
561 ATA_CMD_READ_EXT,
562 ATA_CMD_WRITE_EXT,
563 0,
564 0,
565 0,
566 ATA_CMD_WRITE_FUA_EXT
567};
568
569
570
571
572
573
574
575
576
577
578
579
580static int ata_rwcmd_protocol(struct ata_taskfile *tf, struct ata_device *dev)
581{
582 u8 cmd;
583
584 int index, fua, lba48, write;
585
586 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
587 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
588 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
589
590 if (dev->flags & ATA_DFLAG_PIO) {
591 tf->protocol = ATA_PROT_PIO;
592 index = dev->multi_count ? 0 : 8;
593 } else if (lba48 && (dev->link->ap->flags & ATA_FLAG_PIO_LBA48)) {
594
595 tf->protocol = ATA_PROT_PIO;
596 index = dev->multi_count ? 0 : 8;
597 } else {
598 tf->protocol = ATA_PROT_DMA;
599 index = 16;
600 }
601
602 cmd = ata_rw_cmds[index + fua + lba48 + write];
603 if (cmd) {
604 tf->command = cmd;
605 return 0;
606 }
607 return -1;
608}
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev)
626{
627 u64 block = 0;
628
629 if (tf->flags & ATA_TFLAG_LBA) {
630 if (tf->flags & ATA_TFLAG_LBA48) {
631 block |= (u64)tf->hob_lbah << 40;
632 block |= (u64)tf->hob_lbam << 32;
633 block |= (u64)tf->hob_lbal << 24;
634 } else
635 block |= (tf->device & 0xf) << 24;
636
637 block |= tf->lbah << 16;
638 block |= tf->lbam << 8;
639 block |= tf->lbal;
640 } else {
641 u32 cyl, head, sect;
642
643 cyl = tf->lbam | (tf->lbah << 8);
644 head = tf->device & 0xf;
645 sect = tf->lbal;
646
647 if (!sect) {
648 ata_dev_warn(dev,
649 "device reported invalid CHS sector 0\n");
650 return U64_MAX;
651 }
652
653 block = (cyl * dev->heads + head) * dev->sectors + sect - 1;
654 }
655
656 return block;
657}
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
681 u64 block, u32 n_block, unsigned int tf_flags,
682 unsigned int tag, int class)
683{
684 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
685 tf->flags |= tf_flags;
686
687 if (ata_ncq_enabled(dev) && !ata_tag_internal(tag)) {
688
689 if (!lba_48_ok(block, n_block))
690 return -ERANGE;
691
692 tf->protocol = ATA_PROT_NCQ;
693 tf->flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
694
695 if (tf->flags & ATA_TFLAG_WRITE)
696 tf->command = ATA_CMD_FPDMA_WRITE;
697 else
698 tf->command = ATA_CMD_FPDMA_READ;
699
700 tf->nsect = tag << 3;
701 tf->hob_feature = (n_block >> 8) & 0xff;
702 tf->feature = n_block & 0xff;
703
704 tf->hob_lbah = (block >> 40) & 0xff;
705 tf->hob_lbam = (block >> 32) & 0xff;
706 tf->hob_lbal = (block >> 24) & 0xff;
707 tf->lbah = (block >> 16) & 0xff;
708 tf->lbam = (block >> 8) & 0xff;
709 tf->lbal = block & 0xff;
710
711 tf->device = ATA_LBA;
712 if (tf->flags & ATA_TFLAG_FUA)
713 tf->device |= 1 << 7;
714
715 if (dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLE &&
716 class == IOPRIO_CLASS_RT)
717 tf->hob_nsect |= ATA_PRIO_HIGH << ATA_SHIFT_PRIO;
718 } else if (dev->flags & ATA_DFLAG_LBA) {
719 tf->flags |= ATA_TFLAG_LBA;
720
721 if (lba_28_ok(block, n_block)) {
722
723 tf->device |= (block >> 24) & 0xf;
724 } else if (lba_48_ok(block, n_block)) {
725 if (!(dev->flags & ATA_DFLAG_LBA48))
726 return -ERANGE;
727
728
729 tf->flags |= ATA_TFLAG_LBA48;
730
731 tf->hob_nsect = (n_block >> 8) & 0xff;
732
733 tf->hob_lbah = (block >> 40) & 0xff;
734 tf->hob_lbam = (block >> 32) & 0xff;
735 tf->hob_lbal = (block >> 24) & 0xff;
736 } else
737
738 return -ERANGE;
739
740 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
741 return -EINVAL;
742
743 tf->nsect = n_block & 0xff;
744
745 tf->lbah = (block >> 16) & 0xff;
746 tf->lbam = (block >> 8) & 0xff;
747 tf->lbal = block & 0xff;
748
749 tf->device |= ATA_LBA;
750 } else {
751
752 u32 sect, head, cyl, track;
753
754
755 if (!lba_28_ok(block, n_block))
756 return -ERANGE;
757
758 if (unlikely(ata_rwcmd_protocol(tf, dev) < 0))
759 return -EINVAL;
760
761
762 track = (u32)block / dev->sectors;
763 cyl = track / dev->heads;
764 head = track % dev->heads;
765 sect = (u32)block % dev->sectors + 1;
766
767 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
768 (u32)block, track, cyl, head, sect);
769
770
771
772
773
774 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
775 return -ERANGE;
776
777 tf->nsect = n_block & 0xff;
778 tf->lbal = sect;
779 tf->lbam = cyl;
780 tf->lbah = cyl >> 8;
781 tf->device |= head;
782 }
783
784 return 0;
785}
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802unsigned long ata_pack_xfermask(unsigned long pio_mask,
803 unsigned long mwdma_mask,
804 unsigned long udma_mask)
805{
806 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
807 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
808 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
809}
810EXPORT_SYMBOL_GPL(ata_pack_xfermask);
811
812
813
814
815
816
817
818
819
820
821
822void ata_unpack_xfermask(unsigned long xfer_mask, unsigned long *pio_mask,
823 unsigned long *mwdma_mask, unsigned long *udma_mask)
824{
825 if (pio_mask)
826 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
827 if (mwdma_mask)
828 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
829 if (udma_mask)
830 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
831}
832
833static const struct ata_xfer_ent {
834 int shift, bits;
835 u8 base;
836} ata_xfer_tbl[] = {
837 { ATA_SHIFT_PIO, ATA_NR_PIO_MODES, XFER_PIO_0 },
838 { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 },
839 { ATA_SHIFT_UDMA, ATA_NR_UDMA_MODES, XFER_UDMA_0 },
840 { -1, },
841};
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856u8 ata_xfer_mask2mode(unsigned long xfer_mask)
857{
858 int highbit = fls(xfer_mask) - 1;
859 const struct ata_xfer_ent *ent;
860
861 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
862 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
863 return ent->base + highbit - ent->shift;
864 return 0xff;
865}
866EXPORT_SYMBOL_GPL(ata_xfer_mask2mode);
867
868
869
870
871
872
873
874
875
876
877
878
879
880unsigned long ata_xfer_mode2mask(u8 xfer_mode)
881{
882 const struct ata_xfer_ent *ent;
883
884 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
885 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
886 return ((2 << (ent->shift + xfer_mode - ent->base)) - 1)
887 & ~((1 << ent->shift) - 1);
888 return 0;
889}
890EXPORT_SYMBOL_GPL(ata_xfer_mode2mask);
891
892
893
894
895
896
897
898
899
900
901
902
903
904int ata_xfer_mode2shift(unsigned long xfer_mode)
905{
906 const struct ata_xfer_ent *ent;
907
908 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
909 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
910 return ent->shift;
911 return -1;
912}
913EXPORT_SYMBOL_GPL(ata_xfer_mode2shift);
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929const char *ata_mode_string(unsigned long xfer_mask)
930{
931 static const char * const xfer_mode_str[] = {
932 "PIO0",
933 "PIO1",
934 "PIO2",
935 "PIO3",
936 "PIO4",
937 "PIO5",
938 "PIO6",
939 "MWDMA0",
940 "MWDMA1",
941 "MWDMA2",
942 "MWDMA3",
943 "MWDMA4",
944 "UDMA/16",
945 "UDMA/25",
946 "UDMA/33",
947 "UDMA/44",
948 "UDMA/66",
949 "UDMA/100",
950 "UDMA/133",
951 "UDMA7",
952 };
953 int highbit;
954
955 highbit = fls(xfer_mask) - 1;
956 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
957 return xfer_mode_str[highbit];
958 return "<n/a>";
959}
960EXPORT_SYMBOL_GPL(ata_mode_string);
961
962const char *sata_spd_string(unsigned int spd)
963{
964 static const char * const spd_str[] = {
965 "1.5 Gbps",
966 "3.0 Gbps",
967 "6.0 Gbps",
968 };
969
970 if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
971 return "<unknown>";
972 return spd_str[spd - 1];
973}
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990unsigned int ata_dev_classify(const struct ata_taskfile *tf)
991{
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013 if ((tf->lbam == 0) && (tf->lbah == 0)) {
1014 DPRINTK("found ATA device by sig\n");
1015 return ATA_DEV_ATA;
1016 }
1017
1018 if ((tf->lbam == 0x14) && (tf->lbah == 0xeb)) {
1019 DPRINTK("found ATAPI device by sig\n");
1020 return ATA_DEV_ATAPI;
1021 }
1022
1023 if ((tf->lbam == 0x69) && (tf->lbah == 0x96)) {
1024 DPRINTK("found PMP device by sig\n");
1025 return ATA_DEV_PMP;
1026 }
1027
1028 if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
1029 DPRINTK("found SEMB device by sig (could be ATA device)\n");
1030 return ATA_DEV_SEMB;
1031 }
1032
1033 if ((tf->lbam == 0xcd) && (tf->lbah == 0xab)) {
1034 DPRINTK("found ZAC device by sig\n");
1035 return ATA_DEV_ZAC;
1036 }
1037
1038 DPRINTK("unknown device\n");
1039 return ATA_DEV_UNKNOWN;
1040}
1041EXPORT_SYMBOL_GPL(ata_dev_classify);
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058void ata_id_string(const u16 *id, unsigned char *s,
1059 unsigned int ofs, unsigned int len)
1060{
1061 unsigned int c;
1062
1063 BUG_ON(len & 1);
1064
1065 while (len > 0) {
1066 c = id[ofs] >> 8;
1067 *s = c;
1068 s++;
1069
1070 c = id[ofs] & 0xff;
1071 *s = c;
1072 s++;
1073
1074 ofs++;
1075 len -= 2;
1076 }
1077}
1078EXPORT_SYMBOL_GPL(ata_id_string);
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094void ata_id_c_string(const u16 *id, unsigned char *s,
1095 unsigned int ofs, unsigned int len)
1096{
1097 unsigned char *p;
1098
1099 ata_id_string(id, s, ofs, len - 1);
1100
1101 p = s + strnlen(s, len - 1);
1102 while (p > s && p[-1] == ' ')
1103 p--;
1104 *p = '\0';
1105}
1106EXPORT_SYMBOL_GPL(ata_id_c_string);
1107
1108static u64 ata_id_n_sectors(const u16 *id)
1109{
1110 if (ata_id_has_lba(id)) {
1111 if (ata_id_has_lba48(id))
1112 return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
1113 else
1114 return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
1115 } else {
1116 if (ata_id_current_chs_valid(id))
1117 return id[ATA_ID_CUR_CYLS] * id[ATA_ID_CUR_HEADS] *
1118 id[ATA_ID_CUR_SECTORS];
1119 else
1120 return id[ATA_ID_CYLS] * id[ATA_ID_HEADS] *
1121 id[ATA_ID_SECTORS];
1122 }
1123}
1124
1125u64 ata_tf_to_lba48(const struct ata_taskfile *tf)
1126{
1127 u64 sectors = 0;
1128
1129 sectors |= ((u64)(tf->hob_lbah & 0xff)) << 40;
1130 sectors |= ((u64)(tf->hob_lbam & 0xff)) << 32;
1131 sectors |= ((u64)(tf->hob_lbal & 0xff)) << 24;
1132 sectors |= (tf->lbah & 0xff) << 16;
1133 sectors |= (tf->lbam & 0xff) << 8;
1134 sectors |= (tf->lbal & 0xff);
1135
1136 return sectors;
1137}
1138
1139u64 ata_tf_to_lba(const struct ata_taskfile *tf)
1140{
1141 u64 sectors = 0;
1142
1143 sectors |= (tf->device & 0x0f) << 24;
1144 sectors |= (tf->lbah & 0xff) << 16;
1145 sectors |= (tf->lbam & 0xff) << 8;
1146 sectors |= (tf->lbal & 0xff);
1147
1148 return sectors;
1149}
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
1164{
1165 unsigned int err_mask;
1166 struct ata_taskfile tf;
1167 int lba48 = ata_id_has_lba48(dev->id);
1168
1169 ata_tf_init(dev, &tf);
1170
1171
1172 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1173
1174 if (lba48) {
1175 tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
1176 tf.flags |= ATA_TFLAG_LBA48;
1177 } else
1178 tf.command = ATA_CMD_READ_NATIVE_MAX;
1179
1180 tf.protocol = ATA_PROT_NODATA;
1181 tf.device |= ATA_LBA;
1182
1183 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1184 if (err_mask) {
1185 ata_dev_warn(dev,
1186 "failed to read native max address (err_mask=0x%x)\n",
1187 err_mask);
1188 if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
1189 return -EACCES;
1190 return -EIO;
1191 }
1192
1193 if (lba48)
1194 *max_sectors = ata_tf_to_lba48(&tf) + 1;
1195 else
1196 *max_sectors = ata_tf_to_lba(&tf) + 1;
1197 if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
1198 (*max_sectors)--;
1199 return 0;
1200}
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214static int ata_set_max_sectors(struct ata_device *dev, u64 new_sectors)
1215{
1216 unsigned int err_mask;
1217 struct ata_taskfile tf;
1218 int lba48 = ata_id_has_lba48(dev->id);
1219
1220 new_sectors--;
1221
1222 ata_tf_init(dev, &tf);
1223
1224 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
1225
1226 if (lba48) {
1227 tf.command = ATA_CMD_SET_MAX_EXT;
1228 tf.flags |= ATA_TFLAG_LBA48;
1229
1230 tf.hob_lbal = (new_sectors >> 24) & 0xff;
1231 tf.hob_lbam = (new_sectors >> 32) & 0xff;
1232 tf.hob_lbah = (new_sectors >> 40) & 0xff;
1233 } else {
1234 tf.command = ATA_CMD_SET_MAX;
1235
1236 tf.device |= (new_sectors >> 24) & 0xf;
1237 }
1238
1239 tf.protocol = ATA_PROT_NODATA;
1240 tf.device |= ATA_LBA;
1241
1242 tf.lbal = (new_sectors >> 0) & 0xff;
1243 tf.lbam = (new_sectors >> 8) & 0xff;
1244 tf.lbah = (new_sectors >> 16) & 0xff;
1245
1246 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1247 if (err_mask) {
1248 ata_dev_warn(dev,
1249 "failed to set max address (err_mask=0x%x)\n",
1250 err_mask);
1251 if (err_mask == AC_ERR_DEV &&
1252 (tf.feature & (ATA_ABORTED | ATA_IDNF)))
1253 return -EACCES;
1254 return -EIO;
1255 }
1256
1257 return 0;
1258}
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271static int ata_hpa_resize(struct ata_device *dev)
1272{
1273 bool print_info = ata_dev_print_info(dev);
1274 bool unlock_hpa = ata_ignore_hpa || dev->flags & ATA_DFLAG_UNLOCK_HPA;
1275 u64 sectors = ata_id_n_sectors(dev->id);
1276 u64 native_sectors;
1277 int rc;
1278
1279
1280 if ((dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ZAC) ||
1281 !ata_id_has_lba(dev->id) || !ata_id_hpa_enabled(dev->id) ||
1282 (dev->horkage & ATA_HORKAGE_BROKEN_HPA))
1283 return 0;
1284
1285
1286 rc = ata_read_native_max_address(dev, &native_sectors);
1287 if (rc) {
1288
1289
1290
1291 if (rc == -EACCES || !unlock_hpa) {
1292 ata_dev_warn(dev,
1293 "HPA support seems broken, skipping HPA handling\n");
1294 dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1295
1296
1297 if (rc == -EACCES)
1298 rc = 0;
1299 }
1300
1301 return rc;
1302 }
1303 dev->n_native_sectors = native_sectors;
1304
1305
1306 if (native_sectors <= sectors || !unlock_hpa) {
1307 if (!print_info || native_sectors == sectors)
1308 return 0;
1309
1310 if (native_sectors > sectors)
1311 ata_dev_info(dev,
1312 "HPA detected: current %llu, native %llu\n",
1313 (unsigned long long)sectors,
1314 (unsigned long long)native_sectors);
1315 else if (native_sectors < sectors)
1316 ata_dev_warn(dev,
1317 "native sectors (%llu) is smaller than sectors (%llu)\n",
1318 (unsigned long long)native_sectors,
1319 (unsigned long long)sectors);
1320 return 0;
1321 }
1322
1323
1324 rc = ata_set_max_sectors(dev, native_sectors);
1325 if (rc == -EACCES) {
1326
1327 ata_dev_warn(dev,
1328 "device aborted resize (%llu -> %llu), skipping HPA handling\n",
1329 (unsigned long long)sectors,
1330 (unsigned long long)native_sectors);
1331 dev->horkage |= ATA_HORKAGE_BROKEN_HPA;
1332 return 0;
1333 } else if (rc)
1334 return rc;
1335
1336
1337 rc = ata_dev_reread_id(dev, 0);
1338 if (rc) {
1339 ata_dev_err(dev,
1340 "failed to re-read IDENTIFY data after HPA resizing\n");
1341 return rc;
1342 }
1343
1344 if (print_info) {
1345 u64 new_sectors = ata_id_n_sectors(dev->id);
1346 ata_dev_info(dev,
1347 "HPA unlocked: %llu -> %llu, native %llu\n",
1348 (unsigned long long)sectors,
1349 (unsigned long long)new_sectors,
1350 (unsigned long long)native_sectors);
1351 }
1352
1353 return 0;
1354}
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367static inline void ata_dump_id(const u16 *id)
1368{
1369 DPRINTK("49==0x%04x "
1370 "53==0x%04x "
1371 "63==0x%04x "
1372 "64==0x%04x "
1373 "75==0x%04x \n",
1374 id[49],
1375 id[53],
1376 id[63],
1377 id[64],
1378 id[75]);
1379 DPRINTK("80==0x%04x "
1380 "81==0x%04x "
1381 "82==0x%04x "
1382 "83==0x%04x "
1383 "84==0x%04x \n",
1384 id[80],
1385 id[81],
1386 id[82],
1387 id[83],
1388 id[84]);
1389 DPRINTK("88==0x%04x "
1390 "93==0x%04x\n",
1391 id[88],
1392 id[93]);
1393}
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410unsigned long ata_id_xfermask(const u16 *id)
1411{
1412 unsigned long pio_mask, mwdma_mask, udma_mask;
1413
1414
1415 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
1416 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
1417 pio_mask <<= 3;
1418 pio_mask |= 0x7;
1419 } else {
1420
1421
1422
1423
1424 u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
1425 if (mode < 5)
1426 pio_mask = (2 << mode) - 1;
1427 else
1428 pio_mask = 1;
1429
1430
1431
1432
1433
1434
1435
1436 }
1437
1438 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
1439
1440 if (ata_id_is_cfa(id)) {
1441
1442
1443
1444 int pio = (id[ATA_ID_CFA_MODES] >> 0) & 0x7;
1445 int dma = (id[ATA_ID_CFA_MODES] >> 3) & 0x7;
1446
1447 if (pio)
1448 pio_mask |= (1 << 5);
1449 if (pio > 1)
1450 pio_mask |= (1 << 6);
1451 if (dma)
1452 mwdma_mask |= (1 << 3);
1453 if (dma > 1)
1454 mwdma_mask |= (1 << 4);
1455 }
1456
1457 udma_mask = 0;
1458 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
1459 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
1460
1461 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
1462}
1463EXPORT_SYMBOL_GPL(ata_id_xfermask);
1464
1465static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
1466{
1467 struct completion *waiting = qc->private_data;
1468
1469 complete(waiting);
1470}
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494unsigned ata_exec_internal_sg(struct ata_device *dev,
1495 struct ata_taskfile *tf, const u8 *cdb,
1496 int dma_dir, struct scatterlist *sgl,
1497 unsigned int n_elem, unsigned long timeout)
1498{
1499 struct ata_link *link = dev->link;
1500 struct ata_port *ap = link->ap;
1501 u8 command = tf->command;
1502 int auto_timeout = 0;
1503 struct ata_queued_cmd *qc;
1504 unsigned int preempted_tag;
1505 u32 preempted_sactive;
1506 u64 preempted_qc_active;
1507 int preempted_nr_active_links;
1508 DECLARE_COMPLETION_ONSTACK(wait);
1509 unsigned long flags;
1510 unsigned int err_mask;
1511 int rc;
1512
1513 spin_lock_irqsave(ap->lock, flags);
1514
1515
1516 if (ap->pflags & ATA_PFLAG_FROZEN) {
1517 spin_unlock_irqrestore(ap->lock, flags);
1518 return AC_ERR_SYSTEM;
1519 }
1520
1521
1522 qc = __ata_qc_from_tag(ap, ATA_TAG_INTERNAL);
1523
1524 qc->tag = ATA_TAG_INTERNAL;
1525 qc->hw_tag = 0;
1526 qc->scsicmd = NULL;
1527 qc->ap = ap;
1528 qc->dev = dev;
1529 ata_qc_reinit(qc);
1530
1531 preempted_tag = link->active_tag;
1532 preempted_sactive = link->sactive;
1533 preempted_qc_active = ap->qc_active;
1534 preempted_nr_active_links = ap->nr_active_links;
1535 link->active_tag = ATA_TAG_POISON;
1536 link->sactive = 0;
1537 ap->qc_active = 0;
1538 ap->nr_active_links = 0;
1539
1540
1541 qc->tf = *tf;
1542 if (cdb)
1543 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1544
1545
1546 if (tf->protocol == ATAPI_PROT_DMA && (dev->flags & ATA_DFLAG_DMADIR) &&
1547 dma_dir == DMA_FROM_DEVICE)
1548 qc->tf.feature |= ATAPI_DMADIR;
1549
1550 qc->flags |= ATA_QCFLAG_RESULT_TF;
1551 qc->dma_dir = dma_dir;
1552 if (dma_dir != DMA_NONE) {
1553 unsigned int i, buflen = 0;
1554 struct scatterlist *sg;
1555
1556 for_each_sg(sgl, sg, n_elem, i)
1557 buflen += sg->length;
1558
1559 ata_sg_init(qc, sgl, n_elem);
1560 qc->nbytes = buflen;
1561 }
1562
1563 qc->private_data = &wait;
1564 qc->complete_fn = ata_qc_complete_internal;
1565
1566 ata_qc_issue(qc);
1567
1568 spin_unlock_irqrestore(ap->lock, flags);
1569
1570 if (!timeout) {
1571 if (ata_probe_timeout)
1572 timeout = ata_probe_timeout * 1000;
1573 else {
1574 timeout = ata_internal_cmd_timeout(dev, command);
1575 auto_timeout = 1;
1576 }
1577 }
1578
1579 if (ap->ops->error_handler)
1580 ata_eh_release(ap);
1581
1582 rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));
1583
1584 if (ap->ops->error_handler)
1585 ata_eh_acquire(ap);
1586
1587 ata_sff_flush_pio_task(ap);
1588
1589 if (!rc) {
1590 spin_lock_irqsave(ap->lock, flags);
1591
1592
1593
1594
1595
1596
1597 if (qc->flags & ATA_QCFLAG_ACTIVE) {
1598 qc->err_mask |= AC_ERR_TIMEOUT;
1599
1600 if (ap->ops->error_handler)
1601 ata_port_freeze(ap);
1602 else
1603 ata_qc_complete(qc);
1604
1605 if (ata_msg_warn(ap))
1606 ata_dev_warn(dev, "qc timeout (cmd 0x%x)\n",
1607 command);
1608 }
1609
1610 spin_unlock_irqrestore(ap->lock, flags);
1611 }
1612
1613
1614 if (ap->ops->post_internal_cmd)
1615 ap->ops->post_internal_cmd(qc);
1616
1617
1618 if (qc->flags & ATA_QCFLAG_FAILED) {
1619 if (qc->result_tf.command & (ATA_ERR | ATA_DF))
1620 qc->err_mask |= AC_ERR_DEV;
1621
1622 if (!qc->err_mask)
1623 qc->err_mask |= AC_ERR_OTHER;
1624
1625 if (qc->err_mask & ~AC_ERR_OTHER)
1626 qc->err_mask &= ~AC_ERR_OTHER;
1627 } else if (qc->tf.command == ATA_CMD_REQ_SENSE_DATA) {
1628 qc->result_tf.command |= ATA_SENSE;
1629 }
1630
1631
1632 spin_lock_irqsave(ap->lock, flags);
1633
1634 *tf = qc->result_tf;
1635 err_mask = qc->err_mask;
1636
1637 ata_qc_free(qc);
1638 link->active_tag = preempted_tag;
1639 link->sactive = preempted_sactive;
1640 ap->qc_active = preempted_qc_active;
1641 ap->nr_active_links = preempted_nr_active_links;
1642
1643 spin_unlock_irqrestore(ap->lock, flags);
1644
1645 if ((err_mask & AC_ERR_TIMEOUT) && auto_timeout)
1646 ata_internal_cmd_timed_out(dev, command);
1647
1648 return err_mask;
1649}
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670unsigned ata_exec_internal(struct ata_device *dev,
1671 struct ata_taskfile *tf, const u8 *cdb,
1672 int dma_dir, void *buf, unsigned int buflen,
1673 unsigned long timeout)
1674{
1675 struct scatterlist *psg = NULL, sg;
1676 unsigned int n_elem = 0;
1677
1678 if (dma_dir != DMA_NONE) {
1679 WARN_ON(!buf);
1680 sg_init_one(&sg, buf, buflen);
1681 psg = &sg;
1682 n_elem++;
1683 }
1684
1685 return ata_exec_internal_sg(dev, tf, cdb, dma_dir, psg, n_elem,
1686 timeout);
1687}
1688
1689
1690
1691
1692
1693
1694
1695
1696unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1697{
1698
1699
1700
1701
1702 if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
1703 return 0;
1704
1705
1706
1707 if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
1708 return 0;
1709
1710 if (ata_id_is_cfa(adev->id)
1711 && (adev->pio_mode == XFER_PIO_5 || adev->pio_mode == XFER_PIO_6))
1712 return 0;
1713
1714 if (adev->pio_mode > XFER_PIO_2)
1715 return 1;
1716
1717 if (ata_id_has_iordy(adev->id))
1718 return 1;
1719 return 0;
1720}
1721EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
1722
1723
1724
1725
1726
1727
1728
1729
1730static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
1731{
1732
1733 if (adev->id[ATA_ID_FIELD_VALID] & 2) {
1734 u16 pio = adev->id[ATA_ID_EIDE_PIO];
1735
1736 if (pio) {
1737
1738 if (pio > 240)
1739 return 3 << ATA_SHIFT_PIO;
1740 return 7 << ATA_SHIFT_PIO;
1741 }
1742 }
1743 return 3 << ATA_SHIFT_PIO;
1744}
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756unsigned int ata_do_dev_read_id(struct ata_device *dev,
1757 struct ata_taskfile *tf, u16 *id)
1758{
1759 return ata_exec_internal(dev, tf, NULL, DMA_FROM_DEVICE,
1760 id, sizeof(id[0]) * ATA_ID_WORDS, 0);
1761}
1762EXPORT_SYMBOL_GPL(ata_do_dev_read_id);
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
1786 unsigned int flags, u16 *id)
1787{
1788 struct ata_port *ap = dev->link->ap;
1789 unsigned int class = *p_class;
1790 struct ata_taskfile tf;
1791 unsigned int err_mask = 0;
1792 const char *reason;
1793 bool is_semb = class == ATA_DEV_SEMB;
1794 int may_fallback = 1, tried_spinup = 0;
1795 int rc;
1796
1797 if (ata_msg_ctl(ap))
1798 ata_dev_dbg(dev, "%s: ENTER\n", __func__);
1799
1800retry:
1801 ata_tf_init(dev, &tf);
1802
1803 switch (class) {
1804 case ATA_DEV_SEMB:
1805 class = ATA_DEV_ATA;
1806 fallthrough;
1807 case ATA_DEV_ATA:
1808 case ATA_DEV_ZAC:
1809 tf.command = ATA_CMD_ID_ATA;
1810 break;
1811 case ATA_DEV_ATAPI:
1812 tf.command = ATA_CMD_ID_ATAPI;
1813 break;
1814 default:
1815 rc = -ENODEV;
1816 reason = "unsupported class";
1817 goto err_out;
1818 }
1819
1820 tf.protocol = ATA_PROT_PIO;
1821
1822
1823
1824
1825 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1826
1827
1828
1829
1830 tf.flags |= ATA_TFLAG_POLLING;
1831
1832 if (ap->ops->read_id)
1833 err_mask = ap->ops->read_id(dev, &tf, id);
1834 else
1835 err_mask = ata_do_dev_read_id(dev, &tf, id);
1836
1837 if (err_mask) {
1838 if (err_mask & AC_ERR_NODEV_HINT) {
1839 ata_dev_dbg(dev, "NODEV after polling detection\n");
1840 return -ENOENT;
1841 }
1842
1843 if (is_semb) {
1844 ata_dev_info(dev,
1845 "IDENTIFY failed on device w/ SEMB sig, disabled\n");
1846
1847 *p_class = ATA_DEV_SEMB_UNSUP;
1848 return 0;
1849 }
1850
1851 if ((err_mask == AC_ERR_DEV) && (tf.feature & ATA_ABORTED)) {
1852
1853
1854
1855
1856
1857 if (may_fallback) {
1858 may_fallback = 0;
1859
1860 if (class == ATA_DEV_ATA)
1861 class = ATA_DEV_ATAPI;
1862 else
1863 class = ATA_DEV_ATA;
1864 goto retry;
1865 }
1866
1867
1868
1869
1870
1871 ata_dev_dbg(dev,
1872 "both IDENTIFYs aborted, assuming NODEV\n");
1873 return -ENOENT;
1874 }
1875
1876 rc = -EIO;
1877 reason = "I/O error";
1878 goto err_out;
1879 }
1880
1881 if (dev->horkage & ATA_HORKAGE_DUMP_ID) {
1882 ata_dev_dbg(dev, "dumping IDENTIFY data, "
1883 "class=%d may_fallback=%d tried_spinup=%d\n",
1884 class, may_fallback, tried_spinup);
1885 print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
1886 16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
1887 }
1888
1889
1890
1891
1892 may_fallback = 0;
1893
1894 swap_buf_le16(id, ATA_ID_WORDS);
1895
1896
1897 rc = -EINVAL;
1898 reason = "device reports invalid type";
1899
1900 if (class == ATA_DEV_ATA || class == ATA_DEV_ZAC) {
1901 if (!ata_id_is_ata(id) && !ata_id_is_cfa(id))
1902 goto err_out;
1903 if (ap->host->flags & ATA_HOST_IGNORE_ATA &&
1904 ata_id_is_ata(id)) {
1905 ata_dev_dbg(dev,
1906 "host indicates ignore ATA devices, ignored\n");
1907 return -ENOENT;
1908 }
1909 } else {
1910 if (ata_id_is_ata(id))
1911 goto err_out;
1912 }
1913
1914 if (!tried_spinup && (id[2] == 0x37c8 || id[2] == 0x738c)) {
1915 tried_spinup = 1;
1916
1917
1918
1919
1920
1921 err_mask = ata_dev_set_feature(dev, SETFEATURES_SPINUP, 0);
1922 if (err_mask && id[2] != 0x738c) {
1923 rc = -EIO;
1924 reason = "SPINUP failed";
1925 goto err_out;
1926 }
1927
1928
1929
1930
1931 if (id[2] == 0x37c8)
1932 goto retry;
1933 }
1934
1935 if ((flags & ATA_READID_POSTRESET) &&
1936 (class == ATA_DEV_ATA || class == ATA_DEV_ZAC)) {
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
1949 err_mask = ata_dev_init_params(dev, id[3], id[6]);
1950 if (err_mask) {
1951 rc = -EIO;
1952 reason = "INIT_DEV_PARAMS failed";
1953 goto err_out;
1954 }
1955
1956
1957
1958
1959 flags &= ~ATA_READID_POSTRESET;
1960 goto retry;
1961 }
1962 }
1963
1964 *p_class = class;
1965
1966 return 0;
1967
1968 err_out:
1969 if (ata_msg_warn(ap))
1970 ata_dev_warn(dev, "failed to IDENTIFY (%s, err_mask=0x%x)\n",
1971 reason, err_mask);
1972 return rc;
1973}
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
1992 u8 page, void *buf, unsigned int sectors)
1993{
1994 unsigned long ap_flags = dev->link->ap->flags;
1995 struct ata_taskfile tf;
1996 unsigned int err_mask;
1997 bool dma = false;
1998
1999 DPRINTK("read log page - log 0x%x, page 0x%x\n", log, page);
2000
2001
2002
2003
2004
2005 if (ap_flags & ATA_FLAG_NO_LOG_PAGE)
2006 return AC_ERR_DEV;
2007
2008retry:
2009 ata_tf_init(dev, &tf);
2010 if (ata_dma_enabled(dev) && ata_id_has_read_log_dma_ext(dev->id) &&
2011 !(dev->horkage & ATA_HORKAGE_NO_DMA_LOG)) {
2012 tf.command = ATA_CMD_READ_LOG_DMA_EXT;
2013 tf.protocol = ATA_PROT_DMA;
2014 dma = true;
2015 } else {
2016 tf.command = ATA_CMD_READ_LOG_EXT;
2017 tf.protocol = ATA_PROT_PIO;
2018 dma = false;
2019 }
2020 tf.lbal = log;
2021 tf.lbam = page;
2022 tf.nsect = sectors;
2023 tf.hob_nsect = sectors >> 8;
2024 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
2025
2026 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
2027 buf, sectors * ATA_SECT_SIZE, 0);
2028
2029 if (err_mask) {
2030 if (dma) {
2031 dev->horkage |= ATA_HORKAGE_NO_DMA_LOG;
2032 goto retry;
2033 }
2034 ata_dev_err(dev,
2035 "Read log 0x%02x page 0x%02x failed, Emask 0x%x\n",
2036 (unsigned int)log, (unsigned int)page, err_mask);
2037 }
2038
2039 return err_mask;
2040}
2041
2042static bool ata_log_supported(struct ata_device *dev, u8 log)
2043{
2044 struct ata_port *ap = dev->link->ap;
2045
2046 if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
2047 return false;
2048 return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
2049}
2050
2051static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
2052{
2053 struct ata_port *ap = dev->link->ap;
2054 unsigned int err, i;
2055
2056 if (dev->horkage & ATA_HORKAGE_NO_ID_DEV_LOG)
2057 return false;
2058
2059 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE)) {
2060
2061
2062
2063
2064
2065 if (ata_id_major_version(dev->id) >= 10)
2066 ata_dev_warn(dev,
2067 "ATA Identify Device Log not supported\n");
2068 dev->horkage |= ATA_HORKAGE_NO_ID_DEV_LOG;
2069 return false;
2070 }
2071
2072
2073
2074
2075
2076 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, 0, ap->sector_buf,
2077 1);
2078 if (err)
2079 return false;
2080
2081 for (i = 0; i < ap->sector_buf[8]; i++) {
2082 if (ap->sector_buf[9 + i] == page)
2083 return true;
2084 }
2085
2086 return false;
2087}
2088
2089static int ata_do_link_spd_horkage(struct ata_device *dev)
2090{
2091 struct ata_link *plink = ata_dev_phys_link(dev);
2092 u32 target, target_limit;
2093
2094 if (!sata_scr_valid(plink))
2095 return 0;
2096
2097 if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
2098 target = 1;
2099 else
2100 return 0;
2101
2102 target_limit = (1 << target) - 1;
2103
2104
2105 if (plink->sata_spd_limit <= target_limit)
2106 return 0;
2107
2108 plink->sata_spd_limit = target_limit;
2109
2110
2111
2112
2113
2114 if (plink->sata_spd > target) {
2115 ata_dev_info(dev, "applying link speed limit horkage to %s\n",
2116 sata_spd_string(target));
2117 return -EAGAIN;
2118 }
2119 return 0;
2120}
2121
2122static inline u8 ata_dev_knobble(struct ata_device *dev)
2123{
2124 struct ata_port *ap = dev->link->ap;
2125
2126 if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK)
2127 return 0;
2128
2129 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
2130}
2131
2132static void ata_dev_config_ncq_send_recv(struct ata_device *dev)
2133{
2134 struct ata_port *ap = dev->link->ap;
2135 unsigned int err_mask;
2136
2137 if (!ata_log_supported(dev, ATA_LOG_NCQ_SEND_RECV)) {
2138 ata_dev_warn(dev, "NCQ Send/Recv Log not supported\n");
2139 return;
2140 }
2141 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_SEND_RECV,
2142 0, ap->sector_buf, 1);
2143 if (!err_mask) {
2144 u8 *cmds = dev->ncq_send_recv_cmds;
2145
2146 dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
2147 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);
2148
2149 if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) {
2150 ata_dev_dbg(dev, "disabling queued TRIM support\n");
2151 cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
2152 ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
2153 }
2154 }
2155}
2156
2157static void ata_dev_config_ncq_non_data(struct ata_device *dev)
2158{
2159 struct ata_port *ap = dev->link->ap;
2160 unsigned int err_mask;
2161
2162 if (!ata_log_supported(dev, ATA_LOG_NCQ_NON_DATA)) {
2163 ata_dev_warn(dev,
2164 "NCQ Send/Recv Log not supported\n");
2165 return;
2166 }
2167 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_NON_DATA,
2168 0, ap->sector_buf, 1);
2169 if (!err_mask) {
2170 u8 *cmds = dev->ncq_non_data_cmds;
2171
2172 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_NON_DATA_SIZE);
2173 }
2174}
2175
2176static void ata_dev_config_ncq_prio(struct ata_device *dev)
2177{
2178 struct ata_port *ap = dev->link->ap;
2179 unsigned int err_mask;
2180
2181 if (!ata_identify_page_supported(dev, ATA_LOG_SATA_SETTINGS))
2182 return;
2183
2184 err_mask = ata_read_log_page(dev,
2185 ATA_LOG_IDENTIFY_DEVICE,
2186 ATA_LOG_SATA_SETTINGS,
2187 ap->sector_buf,
2188 1);
2189 if (err_mask)
2190 goto not_supported;
2191
2192 if (!(ap->sector_buf[ATA_LOG_NCQ_PRIO_OFFSET] & BIT(3)))
2193 goto not_supported;
2194
2195 dev->flags |= ATA_DFLAG_NCQ_PRIO;
2196
2197 return;
2198
2199not_supported:
2200 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLE;
2201 dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
2202}
2203
2204static bool ata_dev_check_adapter(struct ata_device *dev,
2205 unsigned short vendor_id)
2206{
2207 struct pci_dev *pcidev = NULL;
2208 struct device *parent_dev = NULL;
2209
2210 for (parent_dev = dev->tdev.parent; parent_dev != NULL;
2211 parent_dev = parent_dev->parent) {
2212 if (dev_is_pci(parent_dev)) {
2213 pcidev = to_pci_dev(parent_dev);
2214 if (pcidev->vendor == vendor_id)
2215 return true;
2216 break;
2217 }
2218 }
2219
2220 return false;
2221}
2222
2223static int ata_dev_config_ncq(struct ata_device *dev,
2224 char *desc, size_t desc_sz)
2225{
2226 struct ata_port *ap = dev->link->ap;
2227 int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
2228 unsigned int err_mask;
2229 char *aa_desc = "";
2230
2231 if (!ata_id_has_ncq(dev->id)) {
2232 desc[0] = '\0';
2233 return 0;
2234 }
2235 if (!IS_ENABLED(CONFIG_SATA_HOST))
2236 return 0;
2237 if (dev->horkage & ATA_HORKAGE_NONCQ) {
2238 snprintf(desc, desc_sz, "NCQ (not used)");
2239 return 0;
2240 }
2241
2242 if (dev->horkage & ATA_HORKAGE_NO_NCQ_ON_ATI &&
2243 ata_dev_check_adapter(dev, PCI_VENDOR_ID_ATI)) {
2244 snprintf(desc, desc_sz, "NCQ (not used)");
2245 return 0;
2246 }
2247
2248 if (ap->flags & ATA_FLAG_NCQ) {
2249 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE);
2250 dev->flags |= ATA_DFLAG_NCQ;
2251 }
2252
2253 if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
2254 (ap->flags & ATA_FLAG_FPDMA_AA) &&
2255 ata_id_has_fpdma_aa(dev->id)) {
2256 err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
2257 SATA_FPDMA_AA);
2258 if (err_mask) {
2259 ata_dev_err(dev,
2260 "failed to enable AA (error_mask=0x%x)\n",
2261 err_mask);
2262 if (err_mask != AC_ERR_DEV) {
2263 dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
2264 return -EIO;
2265 }
2266 } else
2267 aa_desc = ", AA";
2268 }
2269
2270 if (hdepth >= ddepth)
2271 snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
2272 else
2273 snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
2274 ddepth, aa_desc);
2275
2276 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
2277 if (ata_id_has_ncq_send_and_recv(dev->id))
2278 ata_dev_config_ncq_send_recv(dev);
2279 if (ata_id_has_ncq_non_data(dev->id))
2280 ata_dev_config_ncq_non_data(dev);
2281 if (ata_id_has_ncq_prio(dev->id))
2282 ata_dev_config_ncq_prio(dev);
2283 }
2284
2285 return 0;
2286}
2287
2288static void ata_dev_config_sense_reporting(struct ata_device *dev)
2289{
2290 unsigned int err_mask;
2291
2292 if (!ata_id_has_sense_reporting(dev->id))
2293 return;
2294
2295 if (ata_id_sense_reporting_enabled(dev->id))
2296 return;
2297
2298 err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA, 0x1);
2299 if (err_mask) {
2300 ata_dev_dbg(dev,
2301 "failed to enable Sense Data Reporting, Emask 0x%x\n",
2302 err_mask);
2303 }
2304}
2305
2306static void ata_dev_config_zac(struct ata_device *dev)
2307{
2308 struct ata_port *ap = dev->link->ap;
2309 unsigned int err_mask;
2310 u8 *identify_buf = ap->sector_buf;
2311
2312 dev->zac_zones_optimal_open = U32_MAX;
2313 dev->zac_zones_optimal_nonseq = U32_MAX;
2314 dev->zac_zones_max_open = U32_MAX;
2315
2316
2317
2318
2319 if (dev->class == ATA_DEV_ZAC)
2320 dev->flags |= ATA_DFLAG_ZAC;
2321 else if (ata_id_zoned_cap(dev->id) == 0x01)
2322
2323
2324
2325 dev->flags |= ATA_DFLAG_ZAC;
2326
2327 if (!(dev->flags & ATA_DFLAG_ZAC))
2328 return;
2329
2330 if (!ata_identify_page_supported(dev, ATA_LOG_ZONED_INFORMATION)) {
2331 ata_dev_warn(dev,
2332 "ATA Zoned Information Log not supported\n");
2333 return;
2334 }
2335
2336
2337
2338
2339 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2340 ATA_LOG_ZONED_INFORMATION,
2341 identify_buf, 1);
2342 if (!err_mask) {
2343 u64 zoned_cap, opt_open, opt_nonseq, max_open;
2344
2345 zoned_cap = get_unaligned_le64(&identify_buf[8]);
2346 if ((zoned_cap >> 63))
2347 dev->zac_zoned_cap = (zoned_cap & 1);
2348 opt_open = get_unaligned_le64(&identify_buf[24]);
2349 if ((opt_open >> 63))
2350 dev->zac_zones_optimal_open = (u32)opt_open;
2351 opt_nonseq = get_unaligned_le64(&identify_buf[32]);
2352 if ((opt_nonseq >> 63))
2353 dev->zac_zones_optimal_nonseq = (u32)opt_nonseq;
2354 max_open = get_unaligned_le64(&identify_buf[40]);
2355 if ((max_open >> 63))
2356 dev->zac_zones_max_open = (u32)max_open;
2357 }
2358}
2359
2360static void ata_dev_config_trusted(struct ata_device *dev)
2361{
2362 struct ata_port *ap = dev->link->ap;
2363 u64 trusted_cap;
2364 unsigned int err;
2365
2366 if (!ata_id_has_trusted(dev->id))
2367 return;
2368
2369 if (!ata_identify_page_supported(dev, ATA_LOG_SECURITY)) {
2370 ata_dev_warn(dev,
2371 "Security Log not supported\n");
2372 return;
2373 }
2374
2375 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, ATA_LOG_SECURITY,
2376 ap->sector_buf, 1);
2377 if (err)
2378 return;
2379
2380 trusted_cap = get_unaligned_le64(&ap->sector_buf[40]);
2381 if (!(trusted_cap & (1ULL << 63))) {
2382 ata_dev_dbg(dev,
2383 "Trusted Computing capability qword not valid!\n");
2384 return;
2385 }
2386
2387 if (trusted_cap & (1 << 0))
2388 dev->flags |= ATA_DFLAG_TRUSTED;
2389}
2390
2391static int ata_dev_config_lba(struct ata_device *dev)
2392{
2393 struct ata_port *ap = dev->link->ap;
2394 const u16 *id = dev->id;
2395 const char *lba_desc;
2396 char ncq_desc[24];
2397 int ret;
2398
2399 dev->flags |= ATA_DFLAG_LBA;
2400
2401 if (ata_id_has_lba48(id)) {
2402 lba_desc = "LBA48";
2403 dev->flags |= ATA_DFLAG_LBA48;
2404 if (dev->n_sectors >= (1UL << 28) &&
2405 ata_id_has_flush_ext(id))
2406 dev->flags |= ATA_DFLAG_FLUSH_EXT;
2407 } else {
2408 lba_desc = "LBA";
2409 }
2410
2411
2412 ret = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
2413
2414
2415 if (ata_msg_drv(ap) && ata_dev_print_info(dev))
2416 ata_dev_info(dev,
2417 "%llu sectors, multi %u: %s %s\n",
2418 (unsigned long long)dev->n_sectors,
2419 dev->multi_count, lba_desc, ncq_desc);
2420
2421 return ret;
2422}
2423
2424static void ata_dev_config_chs(struct ata_device *dev)
2425{
2426 struct ata_port *ap = dev->link->ap;
2427 const u16 *id = dev->id;
2428
2429 if (ata_id_current_chs_valid(id)) {
2430
2431 dev->cylinders = id[54];
2432 dev->heads = id[55];
2433 dev->sectors = id[56];
2434 } else {
2435
2436 dev->cylinders = id[1];
2437 dev->heads = id[3];
2438 dev->sectors = id[6];
2439 }
2440
2441
2442 if (ata_msg_drv(ap) && ata_dev_print_info(dev))
2443 ata_dev_info(dev,
2444 "%llu sectors, multi %u, CHS %u/%u/%u\n",
2445 (unsigned long long)dev->n_sectors,
2446 dev->multi_count, dev->cylinders,
2447 dev->heads, dev->sectors);
2448}
2449
2450static void ata_dev_config_devslp(struct ata_device *dev)
2451{
2452 u8 *sata_setting = dev->link->ap->sector_buf;
2453 unsigned int err_mask;
2454 int i, j;
2455
2456
2457
2458
2459
2460 if (!ata_id_has_devslp(dev->id) ||
2461 !ata_identify_page_supported(dev, ATA_LOG_SATA_SETTINGS))
2462 return;
2463
2464 err_mask = ata_read_log_page(dev,
2465 ATA_LOG_IDENTIFY_DEVICE,
2466 ATA_LOG_SATA_SETTINGS,
2467 sata_setting, 1);
2468 if (err_mask)
2469 return;
2470
2471 dev->flags |= ATA_DFLAG_DEVSLP;
2472 for (i = 0; i < ATA_LOG_DEVSLP_SIZE; i++) {
2473 j = ATA_LOG_DEVSLP_OFFSET + i;
2474 dev->devslp_timing[i] = sata_setting[j];
2475 }
2476}
2477
2478static void ata_dev_config_cpr(struct ata_device *dev)
2479{
2480 unsigned int err_mask;
2481 size_t buf_len;
2482 int i, nr_cpr = 0;
2483 struct ata_cpr_log *cpr_log = NULL;
2484 u8 *desc, *buf = NULL;
2485
2486 if (!ata_identify_page_supported(dev,
2487 ATA_LOG_CONCURRENT_POSITIONING_RANGES))
2488 goto out;
2489
2490
2491
2492
2493
2494
2495 buf_len = (64 + 255 * 32 + 511) & ~511;
2496 buf = kzalloc(buf_len, GFP_KERNEL);
2497 if (!buf)
2498 goto out;
2499
2500 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2501 ATA_LOG_CONCURRENT_POSITIONING_RANGES,
2502 buf, buf_len >> 9);
2503 if (err_mask)
2504 goto out;
2505
2506 nr_cpr = buf[0];
2507 if (!nr_cpr)
2508 goto out;
2509
2510 cpr_log = kzalloc(struct_size(cpr_log, cpr, nr_cpr), GFP_KERNEL);
2511 if (!cpr_log)
2512 goto out;
2513
2514 cpr_log->nr_cpr = nr_cpr;
2515 desc = &buf[64];
2516 for (i = 0; i < nr_cpr; i++, desc += 32) {
2517 cpr_log->cpr[i].num = desc[0];
2518 cpr_log->cpr[i].num_storage_elements = desc[1];
2519 cpr_log->cpr[i].start_lba = get_unaligned_le64(&desc[8]);
2520 cpr_log->cpr[i].num_lbas = get_unaligned_le64(&desc[16]);
2521 }
2522
2523out:
2524 swap(dev->cpr_log, cpr_log);
2525 kfree(cpr_log);
2526 kfree(buf);
2527}
2528
2529static void ata_dev_print_features(struct ata_device *dev)
2530{
2531 if (!(dev->flags & ATA_DFLAG_FEATURES_MASK))
2532 return;
2533
2534 ata_dev_info(dev,
2535 "Features:%s%s%s%s%s%s\n",
2536 dev->flags & ATA_DFLAG_TRUSTED ? " Trust" : "",
2537 dev->flags & ATA_DFLAG_DA ? " Dev-Attention" : "",
2538 dev->flags & ATA_DFLAG_DEVSLP ? " Dev-Sleep" : "",
2539 dev->flags & ATA_DFLAG_NCQ_SEND_RECV ? " NCQ-sndrcv" : "",
2540 dev->flags & ATA_DFLAG_NCQ_PRIO ? " NCQ-prio" : "",
2541 dev->cpr_log ? " CPR" : "");
2542}
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557int ata_dev_configure(struct ata_device *dev)
2558{
2559 struct ata_port *ap = dev->link->ap;
2560 bool print_info = ata_dev_print_info(dev);
2561 const u16 *id = dev->id;
2562 unsigned long xfer_mask;
2563 unsigned int err_mask;
2564 char revbuf[7];
2565 char fwrevbuf[ATA_ID_FW_REV_LEN+1];
2566 char modelbuf[ATA_ID_PROD_LEN+1];
2567 int rc;
2568
2569 if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
2570 ata_dev_info(dev, "%s: ENTER/EXIT -- nodev\n", __func__);
2571 return 0;
2572 }
2573
2574 if (ata_msg_probe(ap))
2575 ata_dev_dbg(dev, "%s: ENTER\n", __func__);
2576
2577
2578 dev->horkage |= ata_dev_blacklisted(dev);
2579 ata_force_horkage(dev);
2580
2581 if (dev->horkage & ATA_HORKAGE_DISABLE) {
2582 ata_dev_info(dev, "unsupported device, disabling\n");
2583 ata_dev_disable(dev);
2584 return 0;
2585 }
2586
2587 if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
2588 dev->class == ATA_DEV_ATAPI) {
2589 ata_dev_warn(dev, "WARNING: ATAPI is %s, device ignored\n",
2590 atapi_enabled ? "not supported with this driver"
2591 : "disabled");
2592 ata_dev_disable(dev);
2593 return 0;
2594 }
2595
2596 rc = ata_do_link_spd_horkage(dev);
2597 if (rc)
2598 return rc;
2599
2600
2601 if ((dev->horkage & ATA_HORKAGE_WD_BROKEN_LPM) &&
2602 (id[ATA_ID_SATA_CAPABILITY] & 0xe) == 0x2)
2603 dev->horkage |= ATA_HORKAGE_NOLPM;
2604
2605 if (ap->flags & ATA_FLAG_NO_LPM)
2606 dev->horkage |= ATA_HORKAGE_NOLPM;
2607
2608 if (dev->horkage & ATA_HORKAGE_NOLPM) {
2609 ata_dev_warn(dev, "LPM support broken, forcing max_power\n");
2610 dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2611 }
2612
2613
2614 rc = ata_acpi_on_devcfg(dev);
2615 if (rc)
2616 return rc;
2617
2618
2619 rc = ata_hpa_resize(dev);
2620 if (rc)
2621 return rc;
2622
2623
2624 if (ata_msg_probe(ap))
2625 ata_dev_dbg(dev,
2626 "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
2627 "85:%04x 86:%04x 87:%04x 88:%04x\n",
2628 __func__,
2629 id[49], id[82], id[83], id[84],
2630 id[85], id[86], id[87], id[88]);
2631
2632
2633 dev->flags &= ~ATA_DFLAG_CFG_MASK;
2634 dev->max_sectors = 0;
2635 dev->cdb_len = 0;
2636 dev->n_sectors = 0;
2637 dev->cylinders = 0;
2638 dev->heads = 0;
2639 dev->sectors = 0;
2640 dev->multi_count = 0;
2641
2642
2643
2644
2645
2646
2647 xfer_mask = ata_id_xfermask(id);
2648
2649 if (ata_msg_probe(ap))
2650 ata_dump_id(id);
2651
2652
2653 ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
2654 sizeof(fwrevbuf));
2655
2656 ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
2657 sizeof(modelbuf));
2658
2659
2660 if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
2661 if (ata_id_is_cfa(id)) {
2662
2663 if (id[ATA_ID_CFA_KEY_MGMT] & 1)
2664 ata_dev_warn(dev,
2665 "supports DRM functions and may not be fully accessible\n");
2666 snprintf(revbuf, 7, "CFA");
2667 } else {
2668 snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
2669
2670 if (ata_id_has_tpm(id))
2671 ata_dev_warn(dev,
2672 "supports DRM functions and may not be fully accessible\n");
2673 }
2674
2675 dev->n_sectors = ata_id_n_sectors(id);
2676
2677
2678 if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
2679 unsigned int max = dev->id[47] & 0xff;
2680 unsigned int cnt = dev->id[59] & 0xff;
2681
2682 if (is_power_of_2(max) && is_power_of_2(cnt))
2683 if (cnt <= max)
2684 dev->multi_count = cnt;
2685 }
2686
2687
2688 if (ata_msg_drv(ap) && print_info)
2689 ata_dev_info(dev, "%s: %s, %s, max %s\n",
2690 revbuf, modelbuf, fwrevbuf,
2691 ata_mode_string(xfer_mask));
2692
2693 if (ata_id_has_lba(id)) {
2694 rc = ata_dev_config_lba(dev);
2695 if (rc)
2696 return rc;
2697 } else {
2698 ata_dev_config_chs(dev);
2699 }
2700
2701 ata_dev_config_devslp(dev);
2702 ata_dev_config_sense_reporting(dev);
2703 ata_dev_config_zac(dev);
2704 ata_dev_config_trusted(dev);
2705 ata_dev_config_cpr(dev);
2706 dev->cdb_len = 32;
2707
2708 if (ata_msg_drv(ap) && print_info)
2709 ata_dev_print_features(dev);
2710 }
2711
2712
2713 else if (dev->class == ATA_DEV_ATAPI) {
2714 const char *cdb_intr_string = "";
2715 const char *atapi_an_string = "";
2716 const char *dma_dir_string = "";
2717 u32 sntf;
2718
2719 rc = atapi_cdb_len(id);
2720 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
2721 if (ata_msg_warn(ap))
2722 ata_dev_warn(dev, "unsupported CDB len\n");
2723 rc = -EINVAL;
2724 goto err_out_nosup;
2725 }
2726 dev->cdb_len = (unsigned int) rc;
2727
2728
2729
2730
2731
2732
2733 if (atapi_an &&
2734 (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
2735 (!sata_pmp_attached(ap) ||
2736 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
2737
2738 err_mask = ata_dev_set_feature(dev,
2739 SETFEATURES_SATA_ENABLE, SATA_AN);
2740 if (err_mask)
2741 ata_dev_err(dev,
2742 "failed to enable ATAPI AN (err_mask=0x%x)\n",
2743 err_mask);
2744 else {
2745 dev->flags |= ATA_DFLAG_AN;
2746 atapi_an_string = ", ATAPI AN";
2747 }
2748 }
2749
2750 if (ata_id_cdb_intr(dev->id)) {
2751 dev->flags |= ATA_DFLAG_CDB_INTR;
2752 cdb_intr_string = ", CDB intr";
2753 }
2754
2755 if (atapi_dmadir || (dev->horkage & ATA_HORKAGE_ATAPI_DMADIR) || atapi_id_dmadir(dev->id)) {
2756 dev->flags |= ATA_DFLAG_DMADIR;
2757 dma_dir_string = ", DMADIR";
2758 }
2759
2760 if (ata_id_has_da(dev->id)) {
2761 dev->flags |= ATA_DFLAG_DA;
2762 zpodd_init(dev);
2763 }
2764
2765
2766 if (ata_msg_drv(ap) && print_info)
2767 ata_dev_info(dev,
2768 "ATAPI: %s, %s, max %s%s%s%s\n",
2769 modelbuf, fwrevbuf,
2770 ata_mode_string(xfer_mask),
2771 cdb_intr_string, atapi_an_string,
2772 dma_dir_string);
2773 }
2774
2775
2776 dev->max_sectors = ATA_MAX_SECTORS;
2777 if (dev->flags & ATA_DFLAG_LBA48)
2778 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2779
2780
2781
2782 if (ata_dev_knobble(dev)) {
2783 if (ata_msg_drv(ap) && print_info)
2784 ata_dev_info(dev, "applying bridge limits\n");
2785 dev->udma_mask &= ATA_UDMA5;
2786 dev->max_sectors = ATA_MAX_SECTORS;
2787 }
2788
2789 if ((dev->class == ATA_DEV_ATAPI) &&
2790 (atapi_command_packet_set(id) == TYPE_TAPE)) {
2791 dev->max_sectors = ATA_MAX_SECTORS_TAPE;
2792 dev->horkage |= ATA_HORKAGE_STUCK_ERR;
2793 }
2794
2795 if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
2796 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
2797 dev->max_sectors);
2798
2799 if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024)
2800 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
2801 dev->max_sectors);
2802
2803 if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48)
2804 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2805
2806 if (ap->ops->dev_config)
2807 ap->ops->dev_config(dev);
2808
2809 if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
2810
2811
2812
2813
2814
2815
2816 if (print_info) {
2817 ata_dev_warn(dev,
2818"Drive reports diagnostics failure. This may indicate a drive\n");
2819 ata_dev_warn(dev,
2820"fault or invalid emulation. Contact drive vendor for information.\n");
2821 }
2822 }
2823
2824 if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) {
2825 ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n");
2826 ata_dev_warn(dev, " contact the vendor or visit http://ata.wiki.kernel.org\n");
2827 }
2828
2829 return 0;
2830
2831err_out_nosup:
2832 if (ata_msg_probe(ap))
2833 ata_dev_dbg(dev, "%s: EXIT, err\n", __func__);
2834 return rc;
2835}
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845int ata_cable_40wire(struct ata_port *ap)
2846{
2847 return ATA_CBL_PATA40;
2848}
2849EXPORT_SYMBOL_GPL(ata_cable_40wire);
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859int ata_cable_80wire(struct ata_port *ap)
2860{
2861 return ATA_CBL_PATA80;
2862}
2863EXPORT_SYMBOL_GPL(ata_cable_80wire);
2864
2865
2866
2867
2868
2869
2870
2871
2872int ata_cable_unknown(struct ata_port *ap)
2873{
2874 return ATA_CBL_PATA_UNK;
2875}
2876EXPORT_SYMBOL_GPL(ata_cable_unknown);
2877
2878
2879
2880
2881
2882
2883
2884
2885int ata_cable_ignore(struct ata_port *ap)
2886{
2887 return ATA_CBL_PATA_IGN;
2888}
2889EXPORT_SYMBOL_GPL(ata_cable_ignore);
2890
2891
2892
2893
2894
2895
2896
2897
2898int ata_cable_sata(struct ata_port *ap)
2899{
2900 return ATA_CBL_SATA;
2901}
2902EXPORT_SYMBOL_GPL(ata_cable_sata);
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919int ata_bus_probe(struct ata_port *ap)
2920{
2921 unsigned int classes[ATA_MAX_DEVICES];
2922 int tries[ATA_MAX_DEVICES];
2923 int rc;
2924 struct ata_device *dev;
2925
2926 ata_for_each_dev(dev, &ap->link, ALL)
2927 tries[dev->devno] = ATA_PROBE_MAX_TRIES;
2928
2929 retry:
2930 ata_for_each_dev(dev, &ap->link, ALL) {
2931
2932
2933
2934
2935
2936
2937
2938 dev->pio_mode = XFER_PIO_0;
2939 dev->dma_mode = 0xff;
2940
2941
2942
2943
2944
2945
2946 if (ap->ops->set_piomode)
2947 ap->ops->set_piomode(ap, dev);
2948 }
2949
2950
2951 ap->ops->phy_reset(ap);
2952
2953 ata_for_each_dev(dev, &ap->link, ALL) {
2954 if (dev->class != ATA_DEV_UNKNOWN)
2955 classes[dev->devno] = dev->class;
2956 else
2957 classes[dev->devno] = ATA_DEV_NONE;
2958
2959 dev->class = ATA_DEV_UNKNOWN;
2960 }
2961
2962
2963
2964
2965
2966 ata_for_each_dev(dev, &ap->link, ALL_REVERSE) {
2967 if (tries[dev->devno])
2968 dev->class = classes[dev->devno];
2969
2970 if (!ata_dev_enabled(dev))
2971 continue;
2972
2973 rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET,
2974 dev->id);
2975 if (rc)
2976 goto fail;
2977 }
2978
2979
2980 if (ap->ops->cable_detect)
2981 ap->cbl = ap->ops->cable_detect(ap);
2982
2983
2984
2985
2986
2987
2988 ata_for_each_dev(dev, &ap->link, ENABLED)
2989 if (ata_id_is_sata(dev->id))
2990 ap->cbl = ATA_CBL_SATA;
2991
2992
2993
2994
2995 ata_for_each_dev(dev, &ap->link, ENABLED) {
2996 ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
2997 rc = ata_dev_configure(dev);
2998 ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
2999 if (rc)
3000 goto fail;
3001 }
3002
3003
3004 rc = ata_set_mode(&ap->link, &dev);
3005 if (rc)
3006 goto fail;
3007
3008 ata_for_each_dev(dev, &ap->link, ENABLED)
3009 return 0;
3010
3011 return -ENODEV;
3012
3013 fail:
3014 tries[dev->devno]--;
3015
3016 switch (rc) {
3017 case -EINVAL:
3018
3019 tries[dev->devno] = 0;
3020 break;
3021
3022 case -ENODEV:
3023
3024 tries[dev->devno] = min(tries[dev->devno], 1);
3025 fallthrough;
3026 case -EIO:
3027 if (tries[dev->devno] == 1) {
3028
3029
3030
3031 sata_down_spd_limit(&ap->link, 0);
3032 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
3033 }
3034 }
3035
3036 if (!tries[dev->devno])
3037 ata_dev_disable(dev);
3038
3039 goto retry;
3040}
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051static void sata_print_link_status(struct ata_link *link)
3052{
3053 u32 sstatus, scontrol, tmp;
3054
3055 if (sata_scr_read(link, SCR_STATUS, &sstatus))
3056 return;
3057 sata_scr_read(link, SCR_CONTROL, &scontrol);
3058
3059 if (ata_phys_link_online(link)) {
3060 tmp = (sstatus >> 4) & 0xf;
3061 ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
3062 sata_spd_string(tmp), sstatus, scontrol);
3063 } else {
3064 ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
3065 sstatus, scontrol);
3066 }
3067}
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077struct ata_device *ata_dev_pair(struct ata_device *adev)
3078{
3079 struct ata_link *link = adev->link;
3080 struct ata_device *pair = &link->device[1 - adev->devno];
3081 if (!ata_dev_enabled(pair))
3082 return NULL;
3083 return pair;
3084}
3085EXPORT_SYMBOL_GPL(ata_dev_pair);
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
3108{
3109 u32 sstatus, spd, mask;
3110 int rc, bit;
3111
3112 if (!sata_scr_valid(link))
3113 return -EOPNOTSUPP;
3114
3115
3116
3117
3118 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
3119 if (rc == 0 && ata_sstatus_online(sstatus))
3120 spd = (sstatus >> 4) & 0xf;
3121 else
3122 spd = link->sata_spd;
3123
3124 mask = link->sata_spd_limit;
3125 if (mask <= 1)
3126 return -EINVAL;
3127
3128
3129 bit = fls(mask) - 1;
3130 mask &= ~(1 << bit);
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141 if (spd > 1)
3142 mask &= (1 << (spd - 1)) - 1;
3143 else
3144 return -EINVAL;
3145
3146
3147 if (!mask)
3148 return -EINVAL;
3149
3150 if (spd_limit) {
3151 if (mask & ((1 << spd_limit) - 1))
3152 mask &= (1 << spd_limit) - 1;
3153 else {
3154 bit = ffs(mask) - 1;
3155 mask = 1 << bit;
3156 }
3157 }
3158
3159 link->sata_spd_limit = mask;
3160
3161 ata_link_warn(link, "limiting SATA link speed to %s\n",
3162 sata_spd_string(fls(mask)));
3163
3164 return 0;
3165}
3166
3167#ifdef CONFIG_ATA_ACPI
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle)
3185{
3186 u8 base_mode = 0xff, last_mode = 0xff;
3187 const struct ata_xfer_ent *ent;
3188 const struct ata_timing *t;
3189
3190 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
3191 if (ent->shift == xfer_shift)
3192 base_mode = ent->base;
3193
3194 for (t = ata_timing_find_mode(base_mode);
3195 t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) {
3196 unsigned short this_cycle;
3197
3198 switch (xfer_shift) {
3199 case ATA_SHIFT_PIO:
3200 case ATA_SHIFT_MWDMA:
3201 this_cycle = t->cycle;
3202 break;
3203 case ATA_SHIFT_UDMA:
3204 this_cycle = t->udma;
3205 break;
3206 default:
3207 return 0xff;
3208 }
3209
3210 if (cycle > this_cycle)
3211 break;
3212
3213 last_mode = t->mode;
3214 }
3215
3216 return last_mode;
3217}
3218#endif
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
3236{
3237 char buf[32];
3238 unsigned long orig_mask, xfer_mask;
3239 unsigned long pio_mask, mwdma_mask, udma_mask;
3240 int quiet, highbit;
3241
3242 quiet = !!(sel & ATA_DNXFER_QUIET);
3243 sel &= ~ATA_DNXFER_QUIET;
3244
3245 xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
3246 dev->mwdma_mask,
3247 dev->udma_mask);
3248 ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
3249
3250 switch (sel) {
3251 case ATA_DNXFER_PIO:
3252 highbit = fls(pio_mask) - 1;
3253 pio_mask &= ~(1 << highbit);
3254 break;
3255
3256 case ATA_DNXFER_DMA:
3257 if (udma_mask) {
3258 highbit = fls(udma_mask) - 1;
3259 udma_mask &= ~(1 << highbit);
3260 if (!udma_mask)
3261 return -ENOENT;
3262 } else if (mwdma_mask) {
3263 highbit = fls(mwdma_mask) - 1;
3264 mwdma_mask &= ~(1 << highbit);
3265 if (!mwdma_mask)
3266 return -ENOENT;
3267 }
3268 break;
3269
3270 case ATA_DNXFER_40C:
3271 udma_mask &= ATA_UDMA_MASK_40C;
3272 break;
3273
3274 case ATA_DNXFER_FORCE_PIO0:
3275 pio_mask &= 1;
3276 fallthrough;
3277 case ATA_DNXFER_FORCE_PIO:
3278 mwdma_mask = 0;
3279 udma_mask = 0;
3280 break;
3281
3282 default:
3283 BUG();
3284 }
3285
3286 xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
3287
3288 if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
3289 return -ENOENT;
3290
3291 if (!quiet) {
3292 if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
3293 snprintf(buf, sizeof(buf), "%s:%s",
3294 ata_mode_string(xfer_mask),
3295 ata_mode_string(xfer_mask & ATA_MASK_PIO));
3296 else
3297 snprintf(buf, sizeof(buf), "%s",
3298 ata_mode_string(xfer_mask));
3299
3300 ata_dev_warn(dev, "limiting speed to %s\n", buf);
3301 }
3302
3303 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
3304 &dev->udma_mask);
3305
3306 return 0;
3307}
3308
3309static int ata_dev_set_mode(struct ata_device *dev)
3310{
3311 struct ata_port *ap = dev->link->ap;
3312 struct ata_eh_context *ehc = &dev->link->eh_context;
3313 const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER;
3314 const char *dev_err_whine = "";
3315 int ign_dev_err = 0;
3316 unsigned int err_mask = 0;
3317 int rc;
3318
3319 dev->flags &= ~ATA_DFLAG_PIO;
3320 if (dev->xfer_shift == ATA_SHIFT_PIO)
3321 dev->flags |= ATA_DFLAG_PIO;
3322
3323 if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
3324 dev_err_whine = " (SET_XFERMODE skipped)";
3325 else {
3326 if (nosetxfer)
3327 ata_dev_warn(dev,
3328 "NOSETXFER but PATA detected - can't "
3329 "skip SETXFER, might malfunction\n");
3330 err_mask = ata_dev_set_xfermode(dev);
3331 }
3332
3333 if (err_mask & ~AC_ERR_DEV)
3334 goto fail;
3335
3336
3337 ehc->i.flags |= ATA_EHI_POST_SETMODE;
3338 rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
3339 ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
3340 if (rc)
3341 return rc;
3342
3343 if (dev->xfer_shift == ATA_SHIFT_PIO) {
3344
3345 if (ata_id_is_cfa(dev->id))
3346 ign_dev_err = 1;
3347
3348
3349 if (ata_id_major_version(dev->id) == 0 &&
3350 dev->pio_mode <= XFER_PIO_2)
3351 ign_dev_err = 1;
3352
3353
3354
3355 if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2)
3356 ign_dev_err = 1;
3357 }
3358
3359
3360 if (dev->xfer_shift == ATA_SHIFT_MWDMA &&
3361 dev->dma_mode == XFER_MW_DMA_0 &&
3362 (dev->id[63] >> 8) & 1)
3363 ign_dev_err = 1;
3364
3365
3366 if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id)))
3367 ign_dev_err = 1;
3368
3369 if (err_mask & AC_ERR_DEV) {
3370 if (!ign_dev_err)
3371 goto fail;
3372 else
3373 dev_err_whine = " (device error ignored)";
3374 }
3375
3376 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
3377 dev->xfer_shift, (int)dev->xfer_mode);
3378
3379 if (!(ehc->i.flags & ATA_EHI_QUIET) ||
3380 ehc->i.flags & ATA_EHI_DID_HARDRESET)
3381 ata_dev_info(dev, "configured for %s%s\n",
3382 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
3383 dev_err_whine);
3384
3385 return 0;
3386
3387 fail:
3388 ata_dev_err(dev, "failed to set xfermode (err_mask=0x%x)\n", err_mask);
3389 return -EIO;
3390}
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3410{
3411 struct ata_port *ap = link->ap;
3412 struct ata_device *dev;
3413 int rc = 0, used_dma = 0, found = 0;
3414
3415
3416 ata_for_each_dev(dev, link, ENABLED) {
3417 unsigned long pio_mask, dma_mask;
3418 unsigned int mode_mask;
3419
3420 mode_mask = ATA_DMA_MASK_ATA;
3421 if (dev->class == ATA_DEV_ATAPI)
3422 mode_mask = ATA_DMA_MASK_ATAPI;
3423 else if (ata_id_is_cfa(dev->id))
3424 mode_mask = ATA_DMA_MASK_CFA;
3425
3426 ata_dev_xfermask(dev);
3427 ata_force_xfermask(dev);
3428
3429 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
3430
3431 if (libata_dma_mask & mode_mask)
3432 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask,
3433 dev->udma_mask);
3434 else
3435 dma_mask = 0;
3436
3437 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
3438 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
3439
3440 found = 1;
3441 if (ata_dma_enabled(dev))
3442 used_dma = 1;
3443 }
3444 if (!found)
3445 goto out;
3446
3447
3448 ata_for_each_dev(dev, link, ENABLED) {
3449 if (dev->pio_mode == 0xff) {
3450 ata_dev_warn(dev, "no PIO support\n");
3451 rc = -EINVAL;
3452 goto out;
3453 }
3454
3455 dev->xfer_mode = dev->pio_mode;
3456 dev->xfer_shift = ATA_SHIFT_PIO;
3457 if (ap->ops->set_piomode)
3458 ap->ops->set_piomode(ap, dev);
3459 }
3460
3461
3462 ata_for_each_dev(dev, link, ENABLED) {
3463 if (!ata_dma_enabled(dev))
3464 continue;
3465
3466 dev->xfer_mode = dev->dma_mode;
3467 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
3468 if (ap->ops->set_dmamode)
3469 ap->ops->set_dmamode(ap, dev);
3470 }
3471
3472
3473 ata_for_each_dev(dev, link, ENABLED) {
3474 rc = ata_dev_set_mode(dev);
3475 if (rc)
3476 goto out;
3477 }
3478
3479
3480
3481
3482 if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
3483 ap->host->simplex_claimed = ap;
3484
3485 out:
3486 if (rc)
3487 *r_failed_dev = dev;
3488 return rc;
3489}
3490EXPORT_SYMBOL_GPL(ata_do_set_mode);
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3513 int (*check_ready)(struct ata_link *link))
3514{
3515 unsigned long start = jiffies;
3516 unsigned long nodev_deadline;
3517 int warned = 0;
3518
3519
3520 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3521 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT_LONG);
3522 else
3523 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
3524
3525
3526
3527
3528
3529 WARN_ON(link == link->ap->slave_link);
3530
3531 if (time_after(nodev_deadline, deadline))
3532 nodev_deadline = deadline;
3533
3534 while (1) {
3535 unsigned long now = jiffies;
3536 int ready, tmp;
3537
3538 ready = tmp = check_ready(link);
3539 if (ready > 0)
3540 return 0;
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553 if (ready == -ENODEV) {
3554 if (ata_link_online(link))
3555 ready = 0;
3556 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3557 !ata_link_offline(link) &&
3558 time_before(now, nodev_deadline))
3559 ready = 0;
3560 }
3561
3562 if (ready)
3563 return ready;
3564 if (time_after(now, deadline))
3565 return -EBUSY;
3566
3567 if (!warned && time_after(now, start + 5 * HZ) &&
3568 (deadline - now > 3 * HZ)) {
3569 ata_link_warn(link,
3570 "link is slow to respond, please be patient "
3571 "(ready=%d)\n", tmp);
3572 warned = 1;
3573 }
3574
3575 ata_msleep(link->ap, 50);
3576 }
3577}
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
3594 int (*check_ready)(struct ata_link *link))
3595{
3596 ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
3597
3598 return ata_wait_ready(link, deadline, check_ready);
3599}
3600EXPORT_SYMBOL_GPL(ata_wait_after_reset);
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619int ata_std_prereset(struct ata_link *link, unsigned long deadline)
3620{
3621 struct ata_port *ap = link->ap;
3622 struct ata_eh_context *ehc = &link->eh_context;
3623 const unsigned long *timing = sata_ehc_deb_timing(ehc);
3624 int rc;
3625
3626
3627 if (ehc->i.action & ATA_EH_HARDRESET)
3628 return 0;
3629
3630
3631 if (ap->flags & ATA_FLAG_SATA) {
3632 rc = sata_link_resume(link, timing, deadline);
3633
3634 if (rc && rc != -EOPNOTSUPP)
3635 ata_link_warn(link,
3636 "failed to resume link for reset (errno=%d)\n",
3637 rc);
3638 }
3639
3640
3641 if (ata_phys_link_offline(link))
3642 ehc->i.action &= ~ATA_EH_SOFTRESET;
3643
3644 return 0;
3645}
3646EXPORT_SYMBOL_GPL(ata_std_prereset);
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3663 unsigned long deadline)
3664{
3665 const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
3666 bool online;
3667 int rc;
3668
3669
3670 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
3671 return online ? -EAGAIN : rc;
3672}
3673EXPORT_SYMBOL_GPL(sata_std_hardreset);
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687void ata_std_postreset(struct ata_link *link, unsigned int *classes)
3688{
3689 u32 serror;
3690
3691 DPRINTK("ENTER\n");
3692
3693
3694 if (!sata_scr_read(link, SCR_ERROR, &serror))
3695 sata_scr_write(link, SCR_ERROR, serror);
3696
3697
3698 sata_print_link_status(link);
3699
3700 DPRINTK("EXIT\n");
3701}
3702EXPORT_SYMBOL_GPL(ata_std_postreset);
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
3721 const u16 *new_id)
3722{
3723 const u16 *old_id = dev->id;
3724 unsigned char model[2][ATA_ID_PROD_LEN + 1];
3725 unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
3726
3727 if (dev->class != new_class) {
3728 ata_dev_info(dev, "class mismatch %d != %d\n",
3729 dev->class, new_class);
3730 return 0;
3731 }
3732
3733 ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
3734 ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
3735 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
3736 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
3737
3738 if (strcmp(model[0], model[1])) {
3739 ata_dev_info(dev, "model number mismatch '%s' != '%s'\n",
3740 model[0], model[1]);
3741 return 0;
3742 }
3743
3744 if (strcmp(serial[0], serial[1])) {
3745 ata_dev_info(dev, "serial number mismatch '%s' != '%s'\n",
3746 serial[0], serial[1]);
3747 return 0;
3748 }
3749
3750 return 1;
3751}
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
3768{
3769 unsigned int class = dev->class;
3770 u16 *id = (void *)dev->link->ap->sector_buf;
3771 int rc;
3772
3773
3774 rc = ata_dev_read_id(dev, &class, readid_flags, id);
3775 if (rc)
3776 return rc;
3777
3778
3779 if (!ata_dev_same_device(dev, class, id))
3780 return -ENODEV;
3781
3782 memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
3783 return 0;
3784}
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
3802 unsigned int readid_flags)
3803{
3804 u64 n_sectors = dev->n_sectors;
3805 u64 n_native_sectors = dev->n_native_sectors;
3806 int rc;
3807
3808 if (!ata_dev_enabled(dev))
3809 return -ENODEV;
3810
3811
3812 if (ata_class_enabled(new_class) &&
3813 new_class != ATA_DEV_ATA &&
3814 new_class != ATA_DEV_ATAPI &&
3815 new_class != ATA_DEV_ZAC &&
3816 new_class != ATA_DEV_SEMB) {
3817 ata_dev_info(dev, "class mismatch %u != %u\n",
3818 dev->class, new_class);
3819 rc = -ENODEV;
3820 goto fail;
3821 }
3822
3823
3824 rc = ata_dev_reread_id(dev, readid_flags);
3825 if (rc)
3826 goto fail;
3827
3828
3829 rc = ata_dev_configure(dev);
3830 if (rc)
3831 goto fail;
3832
3833
3834 if (dev->class != ATA_DEV_ATA || !n_sectors ||
3835 dev->n_sectors == n_sectors)
3836 return 0;
3837
3838
3839 ata_dev_warn(dev, "n_sectors mismatch %llu != %llu\n",
3840 (unsigned long long)n_sectors,
3841 (unsigned long long)dev->n_sectors);
3842
3843
3844
3845
3846
3847
3848 if (dev->n_native_sectors == n_native_sectors &&
3849 dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
3850 ata_dev_warn(dev,
3851 "new n_sectors matches native, probably "
3852 "late HPA unlock, n_sectors updated\n");
3853
3854 return 0;
3855 }
3856
3857
3858
3859
3860
3861
3862
3863 if (dev->n_native_sectors == n_native_sectors &&
3864 dev->n_sectors < n_sectors && n_sectors == n_native_sectors &&
3865 !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) {
3866 ata_dev_warn(dev,
3867 "old n_sectors matches native, probably "
3868 "late HPA lock, will try to unlock HPA\n");
3869
3870 dev->flags |= ATA_DFLAG_UNLOCK_HPA;
3871 rc = -EIO;
3872 } else
3873 rc = -ENODEV;
3874
3875
3876 dev->n_native_sectors = n_native_sectors;
3877 dev->n_sectors = n_sectors;
3878 fail:
3879 ata_dev_err(dev, "revalidation failed (errno=%d)\n", rc);
3880 return rc;
3881}
3882
3883struct ata_blacklist_entry {
3884 const char *model_num;
3885 const char *model_rev;
3886 unsigned long horkage;
3887};
3888
3889static const struct ata_blacklist_entry ata_device_blacklist [] = {
3890
3891 { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA },
3892 { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA },
3893 { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA },
3894 { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA },
3895 { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA },
3896 { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA },
3897 { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA },
3898 { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA },
3899 { "CRD-8400B", NULL, ATA_HORKAGE_NODMA },
3900 { "CRD-848[02]B", NULL, ATA_HORKAGE_NODMA },
3901 { "CRD-84", NULL, ATA_HORKAGE_NODMA },
3902 { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA },
3903 { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA },
3904 { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA },
3905 { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA },
3906 { "HITACHI CDR-8[34]35",NULL, ATA_HORKAGE_NODMA },
3907 { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA },
3908 { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA },
3909 { "CD-532E-A", NULL, ATA_HORKAGE_NODMA },
3910 { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA },
3911 { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA },
3912 { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA },
3913 { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA },
3914 { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA },
3915 { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
3916 { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA },
3917 { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA },
3918 { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA },
3919 { " 2GB ATA Flash Disk", "ADMA428M", ATA_HORKAGE_NODMA },
3920 { "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },
3921
3922 { "Config Disk", NULL, ATA_HORKAGE_DISABLE },
3923
3924 { "ASMT109x- Config", NULL, ATA_HORKAGE_DISABLE },
3925
3926
3927 { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },
3928 { "QUANTUM DAT DAT72-000", NULL, ATA_HORKAGE_ATAPI_MOD16_DMA },
3929 { "Slimtype DVD A DS8A8SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
3930 { "Slimtype DVD A DS8A9SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
3931
3932
3933
3934
3935
3936 { "ST380013AS", "3.20", ATA_HORKAGE_MAX_SEC_1024 },
3937
3938
3939
3940
3941
3942 { "LITEON CX1-JB*-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 },
3943 { "LITEON EP1-*", NULL, ATA_HORKAGE_MAX_SEC_1024 },
3944
3945
3946
3947
3948
3949 { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ },
3950 { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ, },
3951
3952 { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ },
3953
3954 { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ },
3955 { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ },
3956 { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ },
3957 { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ },
3958 { "OCZ CORE_SSD", "02.10104", ATA_HORKAGE_NONCQ },
3959
3960
3961 { "ST31500341AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3962 ATA_HORKAGE_FIRMWARE_WARN },
3963
3964 { "ST31000333AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3965 ATA_HORKAGE_FIRMWARE_WARN },
3966
3967 { "ST3640[36]23AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3968 ATA_HORKAGE_FIRMWARE_WARN },
3969
3970 { "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3971 ATA_HORKAGE_FIRMWARE_WARN },
3972
3973
3974
3975 { "ST1000LM024 HN-M101MBB", NULL, ATA_HORKAGE_BROKEN_FPDMA_AA |
3976 ATA_HORKAGE_NOLPM, },
3977 { "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA },
3978
3979
3980
3981 { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, },
3982 { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, },
3983 { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, },
3984
3985
3986 { "C300-CTFDDAC128MAG", "0001", ATA_HORKAGE_NONCQ, },
3987
3988
3989 { "SanDisk SD[789]*", NULL, ATA_HORKAGE_MAX_TRIM_128M, },
3990
3991
3992 { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, },
3993 { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
3994 { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
3995 { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA },
3996
3997
3998 { "OCZ-VERTEX", "1.30", ATA_HORKAGE_BROKEN_HPA },
3999
4000
4001 { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE, },
4002 { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE, },
4003 { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE, },
4004
4005
4006 { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, },
4007
4008 { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]", ATA_HORKAGE_IVB, },
4009
4010
4011 { "MTRON MSP-SATA*", NULL, ATA_HORKAGE_BRIDGE_OK, },
4012 { "BUFFALO HD-QSU2/R5", NULL, ATA_HORKAGE_BRIDGE_OK, },
4013
4014
4015 { "WD My Book", NULL, ATA_HORKAGE_1_5_GBPS, },
4016 { "Seagate FreeAgent GoFlex", NULL, ATA_HORKAGE_1_5_GBPS, },
4017
4018
4019
4020
4021
4022 { "PIONEER DVD-RW DVRTD08", NULL, ATA_HORKAGE_NOSETXFER },
4023 { "PIONEER DVD-RW DVRTD08A", NULL, ATA_HORKAGE_NOSETXFER },
4024 { "PIONEER DVD-RW DVR-215", NULL, ATA_HORKAGE_NOSETXFER },
4025 { "PIONEER DVD-RW DVR-212D", NULL, ATA_HORKAGE_NOSETXFER },
4026 { "PIONEER DVD-RW DVR-216D", NULL, ATA_HORKAGE_NOSETXFER },
4027
4028
4029 { "CT500BX100SSD1", NULL, ATA_HORKAGE_NOLPM },
4030
4031
4032 { "Crucial_CT512MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
4033 ATA_HORKAGE_ZERO_AFTER_TRIM |
4034 ATA_HORKAGE_NOLPM, },
4035
4036 { "Crucial_CT512MX100*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM |
4037 ATA_HORKAGE_NOLPM, },
4038
4039
4040 { "Crucial_CT480M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4041 ATA_HORKAGE_ZERO_AFTER_TRIM |
4042 ATA_HORKAGE_NOLPM, },
4043 { "Crucial_CT960M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4044 ATA_HORKAGE_ZERO_AFTER_TRIM |
4045 ATA_HORKAGE_NOLPM, },
4046
4047
4048 { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_HORKAGE_NOLPM, },
4049 { "SAMSUNG SSD PM830 mSATA *", "CXM13D1Q", ATA_HORKAGE_NOLPM, },
4050 { "SAMSUNG MZ7TD256HAFV-000L9", NULL, ATA_HORKAGE_NOLPM, },
4051 { "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_HORKAGE_NOLPM, },
4052
4053
4054 { "Micron_M500IT_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
4055 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4056 { "Micron_M500_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4057 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4058 { "Crucial_CT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4059 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4060 { "Micron_M5[15]0_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
4061 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4062 { "Crucial_CT*M550*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
4063 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4064 { "Crucial_CT*MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
4065 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4066 { "Samsung SSD 840*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4067 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4068 { "Samsung SSD 850*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4069 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4070 { "Samsung SSD 860*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4071 ATA_HORKAGE_ZERO_AFTER_TRIM |
4072 ATA_HORKAGE_NO_NCQ_ON_ATI, },
4073 { "Samsung SSD 870*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4074 ATA_HORKAGE_ZERO_AFTER_TRIM |
4075 ATA_HORKAGE_NO_NCQ_ON_ATI, },
4076 { "FCCT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4077 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4078
4079
4080 { "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM, },
4081
4082
4083
4084
4085
4086
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098 { "INTEL*SSDSC2MH*", NULL, 0, },
4099
4100 { "Micron*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4101 { "Crucial*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4102 { "INTEL*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4103 { "SSD*INTEL*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4104 { "Samsung*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4105 { "SAMSUNG*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4106 { "SAMSUNG*MZ7KM*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4107 { "ST[1248][0248]0[FH]*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118 { "WDC WD800JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4119 { "WDC WD1200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4120 { "WDC WD1600JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4121 { "WDC WD2000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4122 { "WDC WD2500JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4123 { "WDC WD3000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4124 { "WDC WD3200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4125
4126
4127 { }
4128};
4129
4130static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
4131{
4132 unsigned char model_num[ATA_ID_PROD_LEN + 1];
4133 unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
4134 const struct ata_blacklist_entry *ad = ata_device_blacklist;
4135
4136 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
4137 ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
4138
4139 while (ad->model_num) {
4140 if (glob_match(ad->model_num, model_num)) {
4141 if (ad->model_rev == NULL)
4142 return ad->horkage;
4143 if (glob_match(ad->model_rev, model_rev))
4144 return ad->horkage;
4145 }
4146 ad++;
4147 }
4148 return 0;
4149}
4150
4151static int ata_dma_blacklisted(const struct ata_device *dev)
4152{
4153
4154
4155
4156
4157 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4158 (dev->flags & ATA_DFLAG_CDB_INTR))
4159 return 1;
4160 return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
4161}
4162
4163
4164
4165
4166
4167
4168
4169
4170
4171static int ata_is_40wire(struct ata_device *dev)
4172{
4173 if (dev->horkage & ATA_HORKAGE_IVB)
4174 return ata_drive_40wire_relaxed(dev->id);
4175 return ata_drive_40wire(dev->id);
4176}
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189
4190
4191static int cable_is_40wire(struct ata_port *ap)
4192{
4193 struct ata_link *link;
4194 struct ata_device *dev;
4195
4196
4197 if (ap->cbl == ATA_CBL_PATA40)
4198 return 1;
4199
4200
4201 if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA)
4202 return 0;
4203
4204
4205
4206
4207
4208 if (ap->cbl == ATA_CBL_PATA40_SHORT)
4209 return 0;
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220 ata_for_each_link(link, ap, EDGE) {
4221 ata_for_each_dev(dev, link, ENABLED) {
4222 if (!ata_is_40wire(dev))
4223 return 0;
4224 }
4225 }
4226 return 1;
4227}
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241static void ata_dev_xfermask(struct ata_device *dev)
4242{
4243 struct ata_link *link = dev->link;
4244 struct ata_port *ap = link->ap;
4245 struct ata_host *host = ap->host;
4246 unsigned long xfer_mask;
4247
4248
4249 xfer_mask = ata_pack_xfermask(ap->pio_mask,
4250 ap->mwdma_mask, ap->udma_mask);
4251
4252
4253 xfer_mask &= ata_pack_xfermask(dev->pio_mask,
4254 dev->mwdma_mask, dev->udma_mask);
4255 xfer_mask &= ata_id_xfermask(dev->id);
4256
4257
4258
4259
4260
4261 if (ata_dev_pair(dev)) {
4262
4263 xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
4264
4265 xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
4266 }
4267
4268 if (ata_dma_blacklisted(dev)) {
4269 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4270 ata_dev_warn(dev,
4271 "device is on DMA blacklist, disabling DMA\n");
4272 }
4273
4274 if ((host->flags & ATA_HOST_SIMPLEX) &&
4275 host->simplex_claimed && host->simplex_claimed != ap) {
4276 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4277 ata_dev_warn(dev,
4278 "simplex DMA is claimed by other device, disabling DMA\n");
4279 }
4280
4281 if (ap->flags & ATA_FLAG_NO_IORDY)
4282 xfer_mask &= ata_pio_mask_no_iordy(dev);
4283
4284 if (ap->ops->mode_filter)
4285 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
4286
4287
4288
4289
4290
4291
4292
4293
4294
4295 if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
4296
4297 if (cable_is_40wire(ap)) {
4298 ata_dev_warn(dev,
4299 "limited to UDMA/33 due to 40-wire cable\n");
4300 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
4301 }
4302
4303 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
4304 &dev->mwdma_mask, &dev->udma_mask);
4305}
4306
4307
4308
4309
4310
4311
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
4322{
4323 struct ata_taskfile tf;
4324 unsigned int err_mask;
4325
4326
4327 DPRINTK("set features - xfer mode\n");
4328
4329
4330
4331
4332 ata_tf_init(dev, &tf);
4333 tf.command = ATA_CMD_SET_FEATURES;
4334 tf.feature = SETFEATURES_XFER;
4335 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
4336 tf.protocol = ATA_PROT_NODATA;
4337
4338 if (ata_pio_need_iordy(dev))
4339 tf.nsect = dev->xfer_mode;
4340
4341 else if (ata_id_has_iordy(dev->id))
4342 tf.nsect = 0x01;
4343 else
4344 return 0;
4345
4346
4347 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
4348
4349 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4350 return err_mask;
4351}
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, u8 feature)
4369{
4370 struct ata_taskfile tf;
4371 unsigned int err_mask;
4372 unsigned long timeout = 0;
4373
4374
4375 DPRINTK("set features - SATA features\n");
4376
4377 ata_tf_init(dev, &tf);
4378 tf.command = ATA_CMD_SET_FEATURES;
4379 tf.feature = enable;
4380 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4381 tf.protocol = ATA_PROT_NODATA;
4382 tf.nsect = feature;
4383
4384 if (enable == SETFEATURES_SPINUP)
4385 timeout = ata_probe_timeout ?
4386 ata_probe_timeout * 1000 : SETFEATURES_SPINUP_TIMEOUT;
4387 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, timeout);
4388
4389 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4390 return err_mask;
4391}
4392EXPORT_SYMBOL_GPL(ata_dev_set_feature);
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406static unsigned int ata_dev_init_params(struct ata_device *dev,
4407 u16 heads, u16 sectors)
4408{
4409 struct ata_taskfile tf;
4410 unsigned int err_mask;
4411
4412
4413 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
4414 return AC_ERR_INVALID;
4415
4416
4417 DPRINTK("init dev params \n");
4418
4419 ata_tf_init(dev, &tf);
4420 tf.command = ATA_CMD_INIT_DEV_PARAMS;
4421 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4422 tf.protocol = ATA_PROT_NODATA;
4423 tf.nsect = sectors;
4424 tf.device |= (heads - 1) & 0x0f;
4425
4426 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4427
4428
4429
4430 if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
4431 err_mask = 0;
4432
4433 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4434 return err_mask;
4435}
4436
4437
4438
4439
4440
4441
4442
4443
4444
4445
4446
4447
4448
4449
4450
4451int atapi_check_dma(struct ata_queued_cmd *qc)
4452{
4453 struct ata_port *ap = qc->ap;
4454
4455
4456
4457
4458 if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) &&
4459 unlikely(qc->nbytes & 15))
4460 return 1;
4461
4462 if (ap->ops->check_atapi_dma)
4463 return ap->ops->check_atapi_dma(qc);
4464
4465 return 0;
4466}
4467
4468
4469
4470
4471
4472
4473
4474
4475
4476
4477
4478
4479
4480
4481
4482
4483int ata_std_qc_defer(struct ata_queued_cmd *qc)
4484{
4485 struct ata_link *link = qc->dev->link;
4486
4487 if (ata_is_ncq(qc->tf.protocol)) {
4488 if (!ata_tag_valid(link->active_tag))
4489 return 0;
4490 } else {
4491 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4492 return 0;
4493 }
4494
4495 return ATA_DEFER_LINK;
4496}
4497EXPORT_SYMBOL_GPL(ata_std_qc_defer);
4498
4499enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc)
4500{
4501 return AC_ERR_OK;
4502}
4503EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
4504
4505
4506
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
4517
4518void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
4519 unsigned int n_elem)
4520{
4521 qc->sg = sg;
4522 qc->n_elem = n_elem;
4523 qc->cursg = qc->sg;
4524}
4525
4526#ifdef CONFIG_HAS_DMA
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537static void ata_sg_clean(struct ata_queued_cmd *qc)
4538{
4539 struct ata_port *ap = qc->ap;
4540 struct scatterlist *sg = qc->sg;
4541 int dir = qc->dma_dir;
4542
4543 WARN_ON_ONCE(sg == NULL);
4544
4545 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
4546
4547 if (qc->n_elem)
4548 dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
4549
4550 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4551 qc->sg = NULL;
4552}
4553
4554
4555
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567static int ata_sg_setup(struct ata_queued_cmd *qc)
4568{
4569 struct ata_port *ap = qc->ap;
4570 unsigned int n_elem;
4571
4572 VPRINTK("ENTER, ata%u\n", ap->print_id);
4573
4574 n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
4575 if (n_elem < 1)
4576 return -1;
4577
4578 VPRINTK("%d sg elements mapped\n", n_elem);
4579 qc->orig_n_elem = qc->n_elem;
4580 qc->n_elem = n_elem;
4581 qc->flags |= ATA_QCFLAG_DMAMAP;
4582
4583 return 0;
4584}
4585
4586#else
4587
4588static inline void ata_sg_clean(struct ata_queued_cmd *qc) {}
4589static inline int ata_sg_setup(struct ata_queued_cmd *qc) { return -1; }
4590
4591#endif
4592
4593
4594
4595
4596
4597
4598
4599
4600
4601
4602
4603
4604
4605void swap_buf_le16(u16 *buf, unsigned int buf_words)
4606{
4607#ifdef __BIG_ENDIAN
4608 unsigned int i;
4609
4610 for (i = 0; i < buf_words; i++)
4611 buf[i] = le16_to_cpu(buf[i]);
4612#endif
4613}
4614
4615
4616
4617
4618
4619
4620
4621
4622
4623
4624struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev, int tag)
4625{
4626 struct ata_port *ap = dev->link->ap;
4627 struct ata_queued_cmd *qc;
4628
4629
4630 if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
4631 return NULL;
4632
4633
4634 if (ap->flags & ATA_FLAG_SAS_HOST) {
4635 tag = ata_sas_allocate_tag(ap);
4636 if (tag < 0)
4637 return NULL;
4638 }
4639
4640 qc = __ata_qc_from_tag(ap, tag);
4641 qc->tag = qc->hw_tag = tag;
4642 qc->scsicmd = NULL;
4643 qc->ap = ap;
4644 qc->dev = dev;
4645
4646 ata_qc_reinit(qc);
4647
4648 return qc;
4649}
4650
4651
4652
4653
4654
4655
4656
4657
4658
4659
4660
4661void ata_qc_free(struct ata_queued_cmd *qc)
4662{
4663 struct ata_port *ap;
4664 unsigned int tag;
4665
4666 WARN_ON_ONCE(qc == NULL);
4667 ap = qc->ap;
4668
4669 qc->flags = 0;
4670 tag = qc->tag;
4671 if (ata_tag_valid(tag)) {
4672 qc->tag = ATA_TAG_POISON;
4673 if (ap->flags & ATA_FLAG_SAS_HOST)
4674 ata_sas_free_tag(tag, ap);
4675 }
4676}
4677
4678void __ata_qc_complete(struct ata_queued_cmd *qc)
4679{
4680 struct ata_port *ap;
4681 struct ata_link *link;
4682
4683 WARN_ON_ONCE(qc == NULL);
4684 WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE));
4685 ap = qc->ap;
4686 link = qc->dev->link;
4687
4688 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4689 ata_sg_clean(qc);
4690
4691
4692 if (ata_is_ncq(qc->tf.protocol)) {
4693 link->sactive &= ~(1 << qc->hw_tag);
4694 if (!link->sactive)
4695 ap->nr_active_links--;
4696 } else {
4697 link->active_tag = ATA_TAG_POISON;
4698 ap->nr_active_links--;
4699 }
4700
4701
4702 if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
4703 ap->excl_link == link))
4704 ap->excl_link = NULL;
4705
4706
4707
4708
4709
4710 qc->flags &= ~ATA_QCFLAG_ACTIVE;
4711 ap->qc_active &= ~(1ULL << qc->tag);
4712
4713
4714 qc->complete_fn(qc);
4715}
4716
4717static void fill_result_tf(struct ata_queued_cmd *qc)
4718{
4719 struct ata_port *ap = qc->ap;
4720
4721 qc->result_tf.flags = qc->tf.flags;
4722 ap->ops->qc_fill_rtf(qc);
4723}
4724
4725static void ata_verify_xfer(struct ata_queued_cmd *qc)
4726{
4727 struct ata_device *dev = qc->dev;
4728
4729 if (!ata_is_data(qc->tf.protocol))
4730 return;
4731
4732 if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol))
4733 return;
4734
4735 dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER;
4736}
4737
4738
4739
4740
4741
4742
4743
4744
4745
4746
4747
4748
4749
4750
4751
4752
4753void ata_qc_complete(struct ata_queued_cmd *qc)
4754{
4755 struct ata_port *ap = qc->ap;
4756
4757
4758 ledtrig_disk_activity(!!(qc->tf.flags & ATA_TFLAG_WRITE));
4759
4760
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773 if (ap->ops->error_handler) {
4774 struct ata_device *dev = qc->dev;
4775 struct ata_eh_info *ehi = &dev->link->eh_info;
4776
4777 if (unlikely(qc->err_mask))
4778 qc->flags |= ATA_QCFLAG_FAILED;
4779
4780
4781
4782
4783
4784 if (unlikely(ata_tag_internal(qc->tag))) {
4785 fill_result_tf(qc);
4786 trace_ata_qc_complete_internal(qc);
4787 __ata_qc_complete(qc);
4788 return;
4789 }
4790
4791
4792
4793
4794
4795 if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
4796 fill_result_tf(qc);
4797 trace_ata_qc_complete_failed(qc);
4798 ata_qc_schedule_eh(qc);
4799 return;
4800 }
4801
4802 WARN_ON_ONCE(ap->pflags & ATA_PFLAG_FROZEN);
4803
4804
4805 if (qc->flags & ATA_QCFLAG_RESULT_TF)
4806 fill_result_tf(qc);
4807
4808 trace_ata_qc_complete_done(qc);
4809
4810
4811
4812 switch (qc->tf.command) {
4813 case ATA_CMD_SET_FEATURES:
4814 if (qc->tf.feature != SETFEATURES_WC_ON &&
4815 qc->tf.feature != SETFEATURES_WC_OFF &&
4816 qc->tf.feature != SETFEATURES_RA_ON &&
4817 qc->tf.feature != SETFEATURES_RA_OFF)
4818 break;
4819 fallthrough;
4820 case ATA_CMD_INIT_DEV_PARAMS:
4821 case ATA_CMD_SET_MULTI:
4822
4823 ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE;
4824 ata_port_schedule_eh(ap);
4825 break;
4826
4827 case ATA_CMD_SLEEP:
4828 dev->flags |= ATA_DFLAG_SLEEPING;
4829 break;
4830 }
4831
4832 if (unlikely(dev->flags & ATA_DFLAG_DUBIOUS_XFER))
4833 ata_verify_xfer(qc);
4834
4835 __ata_qc_complete(qc);
4836 } else {
4837 if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
4838 return;
4839
4840
4841 if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
4842 fill_result_tf(qc);
4843
4844 __ata_qc_complete(qc);
4845 }
4846}
4847EXPORT_SYMBOL_GPL(ata_qc_complete);
4848
4849
4850
4851
4852
4853
4854
4855
4856
4857
4858
4859u64 ata_qc_get_active(struct ata_port *ap)
4860{
4861 u64 qc_active = ap->qc_active;
4862
4863
4864 if (qc_active & (1ULL << ATA_TAG_INTERNAL)) {
4865 qc_active |= (1 << 0);
4866 qc_active &= ~(1ULL << ATA_TAG_INTERNAL);
4867 }
4868
4869 return qc_active;
4870}
4871EXPORT_SYMBOL_GPL(ata_qc_get_active);
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885void ata_qc_issue(struct ata_queued_cmd *qc)
4886{
4887 struct ata_port *ap = qc->ap;
4888 struct ata_link *link = qc->dev->link;
4889 u8 prot = qc->tf.protocol;
4890
4891
4892
4893
4894
4895 WARN_ON_ONCE(ap->ops->error_handler && ata_tag_valid(link->active_tag));
4896
4897 if (ata_is_ncq(prot)) {
4898 WARN_ON_ONCE(link->sactive & (1 << qc->hw_tag));
4899
4900 if (!link->sactive)
4901 ap->nr_active_links++;
4902 link->sactive |= 1 << qc->hw_tag;
4903 } else {
4904 WARN_ON_ONCE(link->sactive);
4905
4906 ap->nr_active_links++;
4907 link->active_tag = qc->tag;
4908 }
4909
4910 qc->flags |= ATA_QCFLAG_ACTIVE;
4911 ap->qc_active |= 1ULL << qc->tag;
4912
4913
4914
4915
4916
4917 if (ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes))
4918 goto sys_err;
4919
4920 if (ata_is_dma(prot) || (ata_is_pio(prot) &&
4921 (ap->flags & ATA_FLAG_PIO_DMA)))
4922 if (ata_sg_setup(qc))
4923 goto sys_err;
4924
4925
4926 if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
4927 link->eh_info.action |= ATA_EH_RESET;
4928 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
4929 ata_link_abort(link);
4930 return;
4931 }
4932
4933 qc->err_mask |= ap->ops->qc_prep(qc);
4934 if (unlikely(qc->err_mask))
4935 goto err;
4936 trace_ata_qc_issue(qc);
4937 qc->err_mask |= ap->ops->qc_issue(qc);
4938 if (unlikely(qc->err_mask))
4939 goto err;
4940 return;
4941
4942sys_err:
4943 qc->err_mask |= AC_ERR_SYSTEM;
4944err:
4945 ata_qc_complete(qc);
4946}
4947
4948
4949
4950
4951
4952
4953
4954
4955
4956
4957
4958
4959
4960
4961
4962bool ata_phys_link_online(struct ata_link *link)
4963{
4964 u32 sstatus;
4965
4966 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
4967 ata_sstatus_online(sstatus))
4968 return true;
4969 return false;
4970}
4971
4972
4973
4974
4975
4976
4977
4978
4979
4980
4981
4982
4983
4984
4985
4986bool ata_phys_link_offline(struct ata_link *link)
4987{
4988 u32 sstatus;
4989
4990 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
4991 !ata_sstatus_online(sstatus))
4992 return true;
4993 return false;
4994}
4995
4996
4997
4998
4999
5000
5001
5002
5003
5004
5005
5006
5007
5008
5009
5010
5011
5012bool ata_link_online(struct ata_link *link)
5013{
5014 struct ata_link *slave = link->ap->slave_link;
5015
5016 WARN_ON(link == slave);
5017
5018 return ata_phys_link_online(link) ||
5019 (slave && ata_phys_link_online(slave));
5020}
5021EXPORT_SYMBOL_GPL(ata_link_online);
5022
5023
5024
5025
5026
5027
5028
5029
5030
5031
5032
5033
5034
5035
5036
5037
5038
5039bool ata_link_offline(struct ata_link *link)
5040{
5041 struct ata_link *slave = link->ap->slave_link;
5042
5043 WARN_ON(link == slave);
5044
5045 return ata_phys_link_offline(link) &&
5046 (!slave || ata_phys_link_offline(slave));
5047}
5048EXPORT_SYMBOL_GPL(ata_link_offline);
5049
5050#ifdef CONFIG_PM
5051static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
5052 unsigned int action, unsigned int ehi_flags,
5053 bool async)
5054{
5055 struct ata_link *link;
5056 unsigned long flags;
5057
5058
5059
5060
5061 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
5062 ata_port_wait_eh(ap);
5063 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5064 }
5065
5066
5067 spin_lock_irqsave(ap->lock, flags);
5068
5069 ap->pm_mesg = mesg;
5070 ap->pflags |= ATA_PFLAG_PM_PENDING;
5071 ata_for_each_link(link, ap, HOST_FIRST) {
5072 link->eh_info.action |= action;
5073 link->eh_info.flags |= ehi_flags;
5074 }
5075
5076 ata_port_schedule_eh(ap);
5077
5078 spin_unlock_irqrestore(ap->lock, flags);
5079
5080 if (!async) {
5081 ata_port_wait_eh(ap);
5082 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5083 }
5084}
5085
5086
5087
5088
5089
5090
5091
5092
5093static const unsigned int ata_port_suspend_ehi = ATA_EHI_QUIET
5094 | ATA_EHI_NO_AUTOPSY
5095 | ATA_EHI_NO_RECOVERY;
5096
5097static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg)
5098{
5099 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, false);
5100}
5101
5102static void ata_port_suspend_async(struct ata_port *ap, pm_message_t mesg)
5103{
5104 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, true);
5105}
5106
5107static int ata_port_pm_suspend(struct device *dev)
5108{
5109 struct ata_port *ap = to_ata_port(dev);
5110
5111 if (pm_runtime_suspended(dev))
5112 return 0;
5113
5114 ata_port_suspend(ap, PMSG_SUSPEND);
5115 return 0;
5116}
5117
5118static int ata_port_pm_freeze(struct device *dev)
5119{
5120 struct ata_port *ap = to_ata_port(dev);
5121
5122 if (pm_runtime_suspended(dev))
5123 return 0;
5124
5125 ata_port_suspend(ap, PMSG_FREEZE);
5126 return 0;
5127}
5128
5129static int ata_port_pm_poweroff(struct device *dev)
5130{
5131 ata_port_suspend(to_ata_port(dev), PMSG_HIBERNATE);
5132 return 0;
5133}
5134
5135static const unsigned int ata_port_resume_ehi = ATA_EHI_NO_AUTOPSY
5136 | ATA_EHI_QUIET;
5137
5138static void ata_port_resume(struct ata_port *ap, pm_message_t mesg)
5139{
5140 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, false);
5141}
5142
5143static void ata_port_resume_async(struct ata_port *ap, pm_message_t mesg)
5144{
5145 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, true);
5146}
5147
5148static int ata_port_pm_resume(struct device *dev)
5149{
5150 ata_port_resume_async(to_ata_port(dev), PMSG_RESUME);
5151 pm_runtime_disable(dev);
5152 pm_runtime_set_active(dev);
5153 pm_runtime_enable(dev);
5154 return 0;
5155}
5156
5157
5158
5159
5160
5161
5162
5163
5164
5165static int ata_port_runtime_idle(struct device *dev)
5166{
5167 struct ata_port *ap = to_ata_port(dev);
5168 struct ata_link *link;
5169 struct ata_device *adev;
5170
5171 ata_for_each_link(link, ap, HOST_FIRST) {
5172 ata_for_each_dev(adev, link, ENABLED)
5173 if (adev->class == ATA_DEV_ATAPI &&
5174 !zpodd_dev_enabled(adev))
5175 return -EBUSY;
5176 }
5177
5178 return 0;
5179}
5180
5181static int ata_port_runtime_suspend(struct device *dev)
5182{
5183 ata_port_suspend(to_ata_port(dev), PMSG_AUTO_SUSPEND);
5184 return 0;
5185}
5186
5187static int ata_port_runtime_resume(struct device *dev)
5188{
5189 ata_port_resume(to_ata_port(dev), PMSG_AUTO_RESUME);
5190 return 0;
5191}
5192
5193static const struct dev_pm_ops ata_port_pm_ops = {
5194 .suspend = ata_port_pm_suspend,
5195 .resume = ata_port_pm_resume,
5196 .freeze = ata_port_pm_freeze,
5197 .thaw = ata_port_pm_resume,
5198 .poweroff = ata_port_pm_poweroff,
5199 .restore = ata_port_pm_resume,
5200
5201 .runtime_suspend = ata_port_runtime_suspend,
5202 .runtime_resume = ata_port_runtime_resume,
5203 .runtime_idle = ata_port_runtime_idle,
5204};
5205
5206
5207
5208
5209
5210
5211void ata_sas_port_suspend(struct ata_port *ap)
5212{
5213 ata_port_suspend_async(ap, PMSG_SUSPEND);
5214}
5215EXPORT_SYMBOL_GPL(ata_sas_port_suspend);
5216
5217void ata_sas_port_resume(struct ata_port *ap)
5218{
5219 ata_port_resume_async(ap, PMSG_RESUME);
5220}
5221EXPORT_SYMBOL_GPL(ata_sas_port_resume);
5222
5223
5224
5225
5226
5227
5228
5229
5230int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
5231{
5232 host->dev->power.power_state = mesg;
5233 return 0;
5234}
5235EXPORT_SYMBOL_GPL(ata_host_suspend);
5236
5237
5238
5239
5240
5241
5242
5243void ata_host_resume(struct ata_host *host)
5244{
5245 host->dev->power.power_state = PMSG_ON;
5246}
5247EXPORT_SYMBOL_GPL(ata_host_resume);
5248#endif
5249
5250const struct device_type ata_port_type = {
5251 .name = "ata_port",
5252#ifdef CONFIG_PM
5253 .pm = &ata_port_pm_ops,
5254#endif
5255};
5256
5257
5258
5259
5260
5261
5262
5263
5264
5265
5266void ata_dev_init(struct ata_device *dev)
5267{
5268 struct ata_link *link = ata_dev_phys_link(dev);
5269 struct ata_port *ap = link->ap;
5270 unsigned long flags;
5271
5272
5273 link->sata_spd_limit = link->hw_sata_spd_limit;
5274 link->sata_spd = 0;
5275
5276
5277
5278
5279
5280 spin_lock_irqsave(ap->lock, flags);
5281 dev->flags &= ~ATA_DFLAG_INIT_MASK;
5282 dev->horkage = 0;
5283 spin_unlock_irqrestore(ap->lock, flags);
5284
5285 memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0,
5286 ATA_DEVICE_CLEAR_END - ATA_DEVICE_CLEAR_BEGIN);
5287 dev->pio_mask = UINT_MAX;
5288 dev->mwdma_mask = UINT_MAX;
5289 dev->udma_mask = UINT_MAX;
5290}
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
5304{
5305 int i;
5306
5307
5308 memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
5309 ATA_LINK_CLEAR_END - ATA_LINK_CLEAR_BEGIN);
5310
5311 link->ap = ap;
5312 link->pmp = pmp;
5313 link->active_tag = ATA_TAG_POISON;
5314 link->hw_sata_spd_limit = UINT_MAX;
5315
5316
5317 for (i = 0; i < ATA_MAX_DEVICES; i++) {
5318 struct ata_device *dev = &link->device[i];
5319
5320 dev->link = link;
5321 dev->devno = dev - link->device;
5322#ifdef CONFIG_ATA_ACPI
5323 dev->gtf_filter = ata_acpi_gtf_filter;
5324#endif
5325 ata_dev_init(dev);
5326 }
5327}
5328
5329
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342int sata_link_init_spd(struct ata_link *link)
5343{
5344 u8 spd;
5345 int rc;
5346
5347 rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol);
5348 if (rc)
5349 return rc;
5350
5351 spd = (link->saved_scontrol >> 4) & 0xf;
5352 if (spd)
5353 link->hw_sata_spd_limit &= (1 << spd) - 1;
5354
5355 ata_force_link_limits(link);
5356
5357 link->sata_spd_limit = link->hw_sata_spd_limit;
5358
5359 return 0;
5360}
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374struct ata_port *ata_port_alloc(struct ata_host *host)
5375{
5376 struct ata_port *ap;
5377
5378 DPRINTK("ENTER\n");
5379
5380 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
5381 if (!ap)
5382 return NULL;
5383
5384 ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
5385 ap->lock = &host->lock;
5386 ap->print_id = -1;
5387 ap->local_port_no = -1;
5388 ap->host = host;
5389 ap->dev = host->dev;
5390
5391#if defined(ATA_VERBOSE_DEBUG)
5392
5393 ap->msg_enable = 0x00FF;
5394#elif defined(ATA_DEBUG)
5395 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
5396#else
5397 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
5398#endif
5399
5400 mutex_init(&ap->scsi_scan_mutex);
5401 INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
5402 INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
5403 INIT_LIST_HEAD(&ap->eh_done_q);
5404 init_waitqueue_head(&ap->eh_wait_q);
5405 init_completion(&ap->park_req_pending);
5406 timer_setup(&ap->fastdrain_timer, ata_eh_fastdrain_timerfn,
5407 TIMER_DEFERRABLE);
5408
5409 ap->cbl = ATA_CBL_NONE;
5410
5411 ata_link_init(ap, &ap->link, 0);
5412
5413#ifdef ATA_IRQ_TRAP
5414 ap->stats.unhandled_irq = 1;
5415 ap->stats.idle_irq = 1;
5416#endif
5417 ata_sff_port_init(ap);
5418
5419 return ap;
5420}
5421
5422static void ata_devres_release(struct device *gendev, void *res)
5423{
5424 struct ata_host *host = dev_get_drvdata(gendev);
5425 int i;
5426
5427 for (i = 0; i < host->n_ports; i++) {
5428 struct ata_port *ap = host->ports[i];
5429
5430 if (!ap)
5431 continue;
5432
5433 if (ap->scsi_host)
5434 scsi_host_put(ap->scsi_host);
5435
5436 }
5437
5438 dev_set_drvdata(gendev, NULL);
5439 ata_host_put(host);
5440}
5441
5442static void ata_host_release(struct kref *kref)
5443{
5444 struct ata_host *host = container_of(kref, struct ata_host, kref);
5445 int i;
5446
5447 for (i = 0; i < host->n_ports; i++) {
5448 struct ata_port *ap = host->ports[i];
5449
5450 kfree(ap->pmp_link);
5451 kfree(ap->slave_link);
5452 kfree(ap);
5453 host->ports[i] = NULL;
5454 }
5455 kfree(host);
5456}
5457
5458void ata_host_get(struct ata_host *host)
5459{
5460 kref_get(&host->kref);
5461}
5462
5463void ata_host_put(struct ata_host *host)
5464{
5465 kref_put(&host->kref, ata_host_release);
5466}
5467EXPORT_SYMBOL_GPL(ata_host_put);
5468
5469
5470
5471
5472
5473
5474
5475
5476
5477
5478
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488
5489struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
5490{
5491 struct ata_host *host;
5492 size_t sz;
5493 int i;
5494 void *dr;
5495
5496 DPRINTK("ENTER\n");
5497
5498
5499 sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *);
5500 host = kzalloc(sz, GFP_KERNEL);
5501 if (!host)
5502 return NULL;
5503
5504 if (!devres_open_group(dev, NULL, GFP_KERNEL))
5505 goto err_free;
5506
5507 dr = devres_alloc(ata_devres_release, 0, GFP_KERNEL);
5508 if (!dr)
5509 goto err_out;
5510
5511 devres_add(dev, dr);
5512 dev_set_drvdata(dev, host);
5513
5514 spin_lock_init(&host->lock);
5515 mutex_init(&host->eh_mutex);
5516 host->dev = dev;
5517 host->n_ports = max_ports;
5518 kref_init(&host->kref);
5519
5520
5521 for (i = 0; i < max_ports; i++) {
5522 struct ata_port *ap;
5523
5524 ap = ata_port_alloc(host);
5525 if (!ap)
5526 goto err_out;
5527
5528 ap->port_no = i;
5529 host->ports[i] = ap;
5530 }
5531
5532 devres_remove_group(dev, NULL);
5533 return host;
5534
5535 err_out:
5536 devres_release_group(dev, NULL);
5537 err_free:
5538 kfree(host);
5539 return NULL;
5540}
5541EXPORT_SYMBOL_GPL(ata_host_alloc);
5542
5543
5544
5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
5555
5556
5557
5558
5559struct ata_host *ata_host_alloc_pinfo(struct device *dev,
5560 const struct ata_port_info * const * ppi,
5561 int n_ports)
5562{
5563 const struct ata_port_info *pi;
5564 struct ata_host *host;
5565 int i, j;
5566
5567 host = ata_host_alloc(dev, n_ports);
5568 if (!host)
5569 return NULL;
5570
5571 for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) {
5572 struct ata_port *ap = host->ports[i];
5573
5574 if (ppi[j])
5575 pi = ppi[j++];
5576
5577 ap->pio_mask = pi->pio_mask;
5578 ap->mwdma_mask = pi->mwdma_mask;
5579 ap->udma_mask = pi->udma_mask;
5580 ap->flags |= pi->flags;
5581 ap->link.flags |= pi->link_flags;
5582 ap->ops = pi->port_ops;
5583
5584 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
5585 host->ops = pi->port_ops;
5586 }
5587
5588 return host;
5589}
5590EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
5591
5592static void ata_host_stop(struct device *gendev, void *res)
5593{
5594 struct ata_host *host = dev_get_drvdata(gendev);
5595 int i;
5596
5597 WARN_ON(!(host->flags & ATA_HOST_STARTED));
5598
5599 for (i = 0; i < host->n_ports; i++) {
5600 struct ata_port *ap = host->ports[i];
5601
5602 if (ap->ops->port_stop)
5603 ap->ops->port_stop(ap);
5604 }
5605
5606 if (host->ops->host_stop)
5607 host->ops->host_stop(host);
5608}
5609
5610
5611
5612
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628
5629
5630static void ata_finalize_port_ops(struct ata_port_operations *ops)
5631{
5632 static DEFINE_SPINLOCK(lock);
5633 const struct ata_port_operations *cur;
5634 void **begin = (void **)ops;
5635 void **end = (void **)&ops->inherits;
5636 void **pp;
5637
5638 if (!ops || !ops->inherits)
5639 return;
5640
5641 spin_lock(&lock);
5642
5643 for (cur = ops->inherits; cur; cur = cur->inherits) {
5644 void **inherit = (void **)cur;
5645
5646 for (pp = begin; pp < end; pp++, inherit++)
5647 if (!*pp)
5648 *pp = *inherit;
5649 }
5650
5651 for (pp = begin; pp < end; pp++)
5652 if (IS_ERR(*pp))
5653 *pp = NULL;
5654
5655 ops->inherits = NULL;
5656
5657 spin_unlock(&lock);
5658}
5659
5660
5661
5662
5663
5664
5665
5666
5667
5668
5669
5670
5671
5672
5673
5674
5675
5676int ata_host_start(struct ata_host *host)
5677{
5678 int have_stop = 0;
5679 void *start_dr = NULL;
5680 int i, rc;
5681
5682 if (host->flags & ATA_HOST_STARTED)
5683 return 0;
5684
5685 ata_finalize_port_ops(host->ops);
5686
5687 for (i = 0; i < host->n_ports; i++) {
5688 struct ata_port *ap = host->ports[i];
5689
5690 ata_finalize_port_ops(ap->ops);
5691
5692 if (!host->ops && !ata_port_is_dummy(ap))
5693 host->ops = ap->ops;
5694
5695 if (ap->ops->port_stop)
5696 have_stop = 1;
5697 }
5698
5699 if (host->ops && host->ops->host_stop)
5700 have_stop = 1;
5701
5702 if (have_stop) {
5703 start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL);
5704 if (!start_dr)
5705 return -ENOMEM;
5706 }
5707
5708 for (i = 0; i < host->n_ports; i++) {
5709 struct ata_port *ap = host->ports[i];
5710
5711 if (ap->ops->port_start) {
5712 rc = ap->ops->port_start(ap);
5713 if (rc) {
5714 if (rc != -ENODEV)
5715 dev_err(host->dev,
5716 "failed to start port %d (errno=%d)\n",
5717 i, rc);
5718 goto err_out;
5719 }
5720 }
5721 ata_eh_freeze_port(ap);
5722 }
5723
5724 if (start_dr)
5725 devres_add(host->dev, start_dr);
5726 host->flags |= ATA_HOST_STARTED;
5727 return 0;
5728
5729 err_out:
5730 while (--i >= 0) {
5731 struct ata_port *ap = host->ports[i];
5732
5733 if (ap->ops->port_stop)
5734 ap->ops->port_stop(ap);
5735 }
5736 devres_free(start_dr);
5737 return rc;
5738}
5739EXPORT_SYMBOL_GPL(ata_host_start);
5740
5741
5742
5743
5744
5745
5746
5747
5748void ata_host_init(struct ata_host *host, struct device *dev,
5749 struct ata_port_operations *ops)
5750{
5751 spin_lock_init(&host->lock);
5752 mutex_init(&host->eh_mutex);
5753 host->n_tags = ATA_MAX_QUEUE;
5754 host->dev = dev;
5755 host->ops = ops;
5756 kref_init(&host->kref);
5757}
5758EXPORT_SYMBOL_GPL(ata_host_init);
5759
5760void __ata_port_probe(struct ata_port *ap)
5761{
5762 struct ata_eh_info *ehi = &ap->link.eh_info;
5763 unsigned long flags;
5764
5765
5766 spin_lock_irqsave(ap->lock, flags);
5767
5768 ehi->probe_mask |= ATA_ALL_DEVICES;
5769 ehi->action |= ATA_EH_RESET;
5770 ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
5771
5772 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
5773 ap->pflags |= ATA_PFLAG_LOADING;
5774 ata_port_schedule_eh(ap);
5775
5776 spin_unlock_irqrestore(ap->lock, flags);
5777}
5778
5779int ata_port_probe(struct ata_port *ap)
5780{
5781 int rc = 0;
5782
5783 if (ap->ops->error_handler) {
5784 __ata_port_probe(ap);
5785 ata_port_wait_eh(ap);
5786 } else {
5787 DPRINTK("ata%u: bus probe begin\n", ap->print_id);
5788 rc = ata_bus_probe(ap);
5789 DPRINTK("ata%u: bus probe end\n", ap->print_id);
5790 }
5791 return rc;
5792}
5793
5794
5795static void async_port_probe(void *data, async_cookie_t cookie)
5796{
5797 struct ata_port *ap = data;
5798
5799
5800
5801
5802
5803
5804
5805
5806 if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
5807 async_synchronize_cookie(cookie);
5808
5809 (void)ata_port_probe(ap);
5810
5811
5812 async_synchronize_cookie(cookie);
5813
5814 ata_scsi_scan_host(ap, 1);
5815}
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826
5827
5828
5829
5830
5831
5832
5833int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
5834{
5835 int i, rc;
5836
5837 host->n_tags = clamp(sht->can_queue, 1, ATA_MAX_QUEUE);
5838
5839
5840 if (!(host->flags & ATA_HOST_STARTED)) {
5841 dev_err(host->dev, "BUG: trying to register unstarted host\n");
5842 WARN_ON(1);
5843 return -EINVAL;
5844 }
5845
5846
5847
5848
5849
5850 for (i = host->n_ports; host->ports[i]; i++)
5851 kfree(host->ports[i]);
5852
5853
5854 for (i = 0; i < host->n_ports; i++) {
5855 host->ports[i]->print_id = atomic_inc_return(&ata_print_id);
5856 host->ports[i]->local_port_no = i + 1;
5857 }
5858
5859
5860 for (i = 0; i < host->n_ports; i++) {
5861 rc = ata_tport_add(host->dev,host->ports[i]);
5862 if (rc) {
5863 goto err_tadd;
5864 }
5865 }
5866
5867 rc = ata_scsi_add_hosts(host, sht);
5868 if (rc)
5869 goto err_tadd;
5870
5871
5872 for (i = 0; i < host->n_ports; i++) {
5873 struct ata_port *ap = host->ports[i];
5874 unsigned long xfer_mask;
5875
5876
5877 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
5878 ap->cbl = ATA_CBL_SATA;
5879
5880
5881 sata_link_init_spd(&ap->link);
5882 if (ap->slave_link)
5883 sata_link_init_spd(ap->slave_link);
5884
5885
5886 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
5887 ap->udma_mask);
5888
5889 if (!ata_port_is_dummy(ap)) {
5890 ata_port_info(ap, "%cATA max %s %s\n",
5891 (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
5892 ata_mode_string(xfer_mask),
5893 ap->link.eh_info.desc);
5894 ata_ehi_clear_desc(&ap->link.eh_info);
5895 } else
5896 ata_port_info(ap, "DUMMY\n");
5897 }
5898
5899
5900 for (i = 0; i < host->n_ports; i++) {
5901 struct ata_port *ap = host->ports[i];
5902 ap->cookie = async_schedule(async_port_probe, ap);
5903 }
5904
5905 return 0;
5906
5907 err_tadd:
5908 while (--i >= 0) {
5909 ata_tport_delete(host->ports[i]);
5910 }
5911 return rc;
5912
5913}
5914EXPORT_SYMBOL_GPL(ata_host_register);
5915
5916
5917
5918
5919
5920
5921
5922
5923
5924
5925
5926
5927
5928
5929
5930
5931
5932
5933
5934
5935
5936
5937
5938
5939int ata_host_activate(struct ata_host *host, int irq,
5940 irq_handler_t irq_handler, unsigned long irq_flags,
5941 struct scsi_host_template *sht)
5942{
5943 int i, rc;
5944 char *irq_desc;
5945
5946 rc = ata_host_start(host);
5947 if (rc)
5948 return rc;
5949
5950
5951 if (!irq) {
5952 WARN_ON(irq_handler);
5953 return ata_host_register(host, sht);
5954 }
5955
5956 irq_desc = devm_kasprintf(host->dev, GFP_KERNEL, "%s[%s]",
5957 dev_driver_string(host->dev),
5958 dev_name(host->dev));
5959 if (!irq_desc)
5960 return -ENOMEM;
5961
5962 rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags,
5963 irq_desc, host);
5964 if (rc)
5965 return rc;
5966
5967 for (i = 0; i < host->n_ports; i++)
5968 ata_port_desc(host->ports[i], "irq %d", irq);
5969
5970 rc = ata_host_register(host, sht);
5971
5972 if (rc)
5973 devm_free_irq(host->dev, irq, host);
5974
5975 return rc;
5976}
5977EXPORT_SYMBOL_GPL(ata_host_activate);
5978
5979
5980
5981
5982
5983
5984
5985
5986
5987
5988
5989
5990static void ata_port_detach(struct ata_port *ap)
5991{
5992 unsigned long flags;
5993 struct ata_link *link;
5994 struct ata_device *dev;
5995
5996 if (!ap->ops->error_handler)
5997 goto skip_eh;
5998
5999
6000 spin_lock_irqsave(ap->lock, flags);
6001 ap->pflags |= ATA_PFLAG_UNLOADING;
6002 ata_port_schedule_eh(ap);
6003 spin_unlock_irqrestore(ap->lock, flags);
6004
6005
6006 ata_port_wait_eh(ap);
6007
6008
6009 WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
6010
6011 cancel_delayed_work_sync(&ap->hotplug_task);
6012
6013 skip_eh:
6014
6015 ata_for_each_link(link, ap, HOST_FIRST) {
6016 ata_for_each_dev(dev, link, ALL) {
6017 if (zpodd_dev_enabled(dev))
6018 zpodd_exit(dev);
6019 }
6020 }
6021 if (ap->pmp_link) {
6022 int i;
6023 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
6024 ata_tlink_delete(&ap->pmp_link[i]);
6025 }
6026
6027 scsi_remove_host(ap->scsi_host);
6028 ata_tport_delete(ap);
6029}
6030
6031
6032
6033
6034
6035
6036
6037
6038
6039
6040void ata_host_detach(struct ata_host *host)
6041{
6042 int i;
6043
6044 for (i = 0; i < host->n_ports; i++) {
6045
6046 async_synchronize_cookie(host->ports[i]->cookie + 1);
6047 ata_port_detach(host->ports[i]);
6048 }
6049
6050
6051 ata_acpi_dissociate(host);
6052}
6053EXPORT_SYMBOL_GPL(ata_host_detach);
6054
6055#ifdef CONFIG_PCI
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068void ata_pci_remove_one(struct pci_dev *pdev)
6069{
6070 struct ata_host *host = pci_get_drvdata(pdev);
6071
6072 ata_host_detach(host);
6073}
6074EXPORT_SYMBOL_GPL(ata_pci_remove_one);
6075
6076void ata_pci_shutdown_one(struct pci_dev *pdev)
6077{
6078 struct ata_host *host = pci_get_drvdata(pdev);
6079 int i;
6080
6081 for (i = 0; i < host->n_ports; i++) {
6082 struct ata_port *ap = host->ports[i];
6083
6084 ap->pflags |= ATA_PFLAG_FROZEN;
6085
6086
6087 if (ap->ops->freeze)
6088 ap->ops->freeze(ap);
6089
6090
6091 if (ap->ops->port_stop)
6092 ap->ops->port_stop(ap);
6093 }
6094}
6095EXPORT_SYMBOL_GPL(ata_pci_shutdown_one);
6096
6097
6098int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
6099{
6100 unsigned long tmp = 0;
6101
6102 switch (bits->width) {
6103 case 1: {
6104 u8 tmp8 = 0;
6105 pci_read_config_byte(pdev, bits->reg, &tmp8);
6106 tmp = tmp8;
6107 break;
6108 }
6109 case 2: {
6110 u16 tmp16 = 0;
6111 pci_read_config_word(pdev, bits->reg, &tmp16);
6112 tmp = tmp16;
6113 break;
6114 }
6115 case 4: {
6116 u32 tmp32 = 0;
6117 pci_read_config_dword(pdev, bits->reg, &tmp32);
6118 tmp = tmp32;
6119 break;
6120 }
6121
6122 default:
6123 return -EINVAL;
6124 }
6125
6126 tmp &= bits->mask;
6127
6128 return (tmp == bits->val) ? 1 : 0;
6129}
6130EXPORT_SYMBOL_GPL(pci_test_config_bits);
6131
6132#ifdef CONFIG_PM
6133void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
6134{
6135 pci_save_state(pdev);
6136 pci_disable_device(pdev);
6137
6138 if (mesg.event & PM_EVENT_SLEEP)
6139 pci_set_power_state(pdev, PCI_D3hot);
6140}
6141EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
6142
6143int ata_pci_device_do_resume(struct pci_dev *pdev)
6144{
6145 int rc;
6146
6147 pci_set_power_state(pdev, PCI_D0);
6148 pci_restore_state(pdev);
6149
6150 rc = pcim_enable_device(pdev);
6151 if (rc) {
6152 dev_err(&pdev->dev,
6153 "failed to enable device after resume (%d)\n", rc);
6154 return rc;
6155 }
6156
6157 pci_set_master(pdev);
6158 return 0;
6159}
6160EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
6161
6162int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
6163{
6164 struct ata_host *host = pci_get_drvdata(pdev);
6165 int rc = 0;
6166
6167 rc = ata_host_suspend(host, mesg);
6168 if (rc)
6169 return rc;
6170
6171 ata_pci_device_do_suspend(pdev, mesg);
6172
6173 return 0;
6174}
6175EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
6176
6177int ata_pci_device_resume(struct pci_dev *pdev)
6178{
6179 struct ata_host *host = pci_get_drvdata(pdev);
6180 int rc;
6181
6182 rc = ata_pci_device_do_resume(pdev);
6183 if (rc == 0)
6184 ata_host_resume(host);
6185 return rc;
6186}
6187EXPORT_SYMBOL_GPL(ata_pci_device_resume);
6188#endif
6189#endif
6190
6191
6192
6193
6194
6195
6196
6197
6198
6199
6200
6201
6202int ata_platform_remove_one(struct platform_device *pdev)
6203{
6204 struct ata_host *host = platform_get_drvdata(pdev);
6205
6206 ata_host_detach(host);
6207
6208 return 0;
6209}
6210EXPORT_SYMBOL_GPL(ata_platform_remove_one);
6211
6212#ifdef CONFIG_ATA_FORCE
6213static int __init ata_parse_force_one(char **cur,
6214 struct ata_force_ent *force_ent,
6215 const char **reason)
6216{
6217 static const struct ata_force_param force_tbl[] __initconst = {
6218 { "40c", .cbl = ATA_CBL_PATA40 },
6219 { "80c", .cbl = ATA_CBL_PATA80 },
6220 { "short40c", .cbl = ATA_CBL_PATA40_SHORT },
6221 { "unk", .cbl = ATA_CBL_PATA_UNK },
6222 { "ign", .cbl = ATA_CBL_PATA_IGN },
6223 { "sata", .cbl = ATA_CBL_SATA },
6224 { "1.5Gbps", .spd_limit = 1 },
6225 { "3.0Gbps", .spd_limit = 2 },
6226 { "noncq", .horkage_on = ATA_HORKAGE_NONCQ },
6227 { "ncq", .horkage_off = ATA_HORKAGE_NONCQ },
6228 { "noncqtrim", .horkage_on = ATA_HORKAGE_NO_NCQ_TRIM },
6229 { "ncqtrim", .horkage_off = ATA_HORKAGE_NO_NCQ_TRIM },
6230 { "noncqati", .horkage_on = ATA_HORKAGE_NO_NCQ_ON_ATI },
6231 { "ncqati", .horkage_off = ATA_HORKAGE_NO_NCQ_ON_ATI },
6232 { "dump_id", .horkage_on = ATA_HORKAGE_DUMP_ID },
6233 { "pio0", .xfer_mask = 1 << (ATA_SHIFT_PIO + 0) },
6234 { "pio1", .xfer_mask = 1 << (ATA_SHIFT_PIO + 1) },
6235 { "pio2", .xfer_mask = 1 << (ATA_SHIFT_PIO + 2) },
6236 { "pio3", .xfer_mask = 1 << (ATA_SHIFT_PIO + 3) },
6237 { "pio4", .xfer_mask = 1 << (ATA_SHIFT_PIO + 4) },
6238 { "pio5", .xfer_mask = 1 << (ATA_SHIFT_PIO + 5) },
6239 { "pio6", .xfer_mask = 1 << (ATA_SHIFT_PIO + 6) },
6240 { "mwdma0", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 0) },
6241 { "mwdma1", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 1) },
6242 { "mwdma2", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 2) },
6243 { "mwdma3", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 3) },
6244 { "mwdma4", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 4) },
6245 { "udma0", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6246 { "udma16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6247 { "udma/16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6248 { "udma1", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6249 { "udma25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6250 { "udma/25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6251 { "udma2", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6252 { "udma33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6253 { "udma/33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6254 { "udma3", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6255 { "udma44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6256 { "udma/44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6257 { "udma4", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6258 { "udma66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6259 { "udma/66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6260 { "udma5", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6261 { "udma100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6262 { "udma/100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6263 { "udma6", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6264 { "udma133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6265 { "udma/133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6266 { "udma7", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 7) },
6267 { "nohrst", .lflags = ATA_LFLAG_NO_HRST },
6268 { "nosrst", .lflags = ATA_LFLAG_NO_SRST },
6269 { "norst", .lflags = ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST },
6270 { "rstonce", .lflags = ATA_LFLAG_RST_ONCE },
6271 { "atapi_dmadir", .horkage_on = ATA_HORKAGE_ATAPI_DMADIR },
6272 { "disable", .horkage_on = ATA_HORKAGE_DISABLE },
6273 };
6274 char *start = *cur, *p = *cur;
6275 char *id, *val, *endp;
6276 const struct ata_force_param *match_fp = NULL;
6277 int nr_matches = 0, i;
6278
6279
6280 while (*p != '\0' && *p != ',')
6281 p++;
6282
6283 if (*p == '\0')
6284 *cur = p;
6285 else
6286 *cur = p + 1;
6287
6288 *p = '\0';
6289
6290
6291 p = strchr(start, ':');
6292 if (!p) {
6293 val = strstrip(start);
6294 goto parse_val;
6295 }
6296 *p = '\0';
6297
6298 id = strstrip(start);
6299 val = strstrip(p + 1);
6300
6301
6302 p = strchr(id, '.');
6303 if (p) {
6304 *p++ = '\0';
6305 force_ent->device = simple_strtoul(p, &endp, 10);
6306 if (p == endp || *endp != '\0') {
6307 *reason = "invalid device";
6308 return -EINVAL;
6309 }
6310 }
6311
6312 force_ent->port = simple_strtoul(id, &endp, 10);
6313 if (id == endp || *endp != '\0') {
6314 *reason = "invalid port/link";
6315 return -EINVAL;
6316 }
6317
6318 parse_val:
6319
6320 for (i = 0; i < ARRAY_SIZE(force_tbl); i++) {
6321 const struct ata_force_param *fp = &force_tbl[i];
6322
6323 if (strncasecmp(val, fp->name, strlen(val)))
6324 continue;
6325
6326 nr_matches++;
6327 match_fp = fp;
6328
6329 if (strcasecmp(val, fp->name) == 0) {
6330 nr_matches = 1;
6331 break;
6332 }
6333 }
6334
6335 if (!nr_matches) {
6336 *reason = "unknown value";
6337 return -EINVAL;
6338 }
6339 if (nr_matches > 1) {
6340 *reason = "ambiguous value";
6341 return -EINVAL;
6342 }
6343
6344 force_ent->param = *match_fp;
6345
6346 return 0;
6347}
6348
6349static void __init ata_parse_force_param(void)
6350{
6351 int idx = 0, size = 1;
6352 int last_port = -1, last_device = -1;
6353 char *p, *cur, *next;
6354
6355
6356 for (p = ata_force_param_buf; *p; p++)
6357 if (*p == ',')
6358 size++;
6359
6360 ata_force_tbl = kcalloc(size, sizeof(ata_force_tbl[0]), GFP_KERNEL);
6361 if (!ata_force_tbl) {
6362 printk(KERN_WARNING "ata: failed to extend force table, "
6363 "libata.force ignored\n");
6364 return;
6365 }
6366
6367
6368 for (cur = ata_force_param_buf; *cur != '\0'; cur = next) {
6369 const char *reason = "";
6370 struct ata_force_ent te = { .port = -1, .device = -1 };
6371
6372 next = cur;
6373 if (ata_parse_force_one(&next, &te, &reason)) {
6374 printk(KERN_WARNING "ata: failed to parse force "
6375 "parameter \"%s\" (%s)\n",
6376 cur, reason);
6377 continue;
6378 }
6379
6380 if (te.port == -1) {
6381 te.port = last_port;
6382 te.device = last_device;
6383 }
6384
6385 ata_force_tbl[idx++] = te;
6386
6387 last_port = te.port;
6388 last_device = te.device;
6389 }
6390
6391 ata_force_tbl_size = idx;
6392}
6393
6394static void ata_free_force_param(void)
6395{
6396 kfree(ata_force_tbl);
6397}
6398#else
6399static inline void ata_parse_force_param(void) { }
6400static inline void ata_free_force_param(void) { }
6401#endif
6402
6403static int __init ata_init(void)
6404{
6405 int rc;
6406
6407 ata_parse_force_param();
6408
6409 rc = ata_sff_init();
6410 if (rc) {
6411 ata_free_force_param();
6412 return rc;
6413 }
6414
6415 libata_transport_init();
6416 ata_scsi_transport_template = ata_attach_transport();
6417 if (!ata_scsi_transport_template) {
6418 ata_sff_exit();
6419 rc = -ENOMEM;
6420 goto err_out;
6421 }
6422
6423 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
6424 return 0;
6425
6426err_out:
6427 return rc;
6428}
6429
6430static void __exit ata_exit(void)
6431{
6432 ata_release_transport(ata_scsi_transport_template);
6433 libata_transport_exit();
6434 ata_sff_exit();
6435 ata_free_force_param();
6436}
6437
6438subsys_initcall(ata_init);
6439module_exit(ata_exit);
6440
6441static DEFINE_RATELIMIT_STATE(ratelimit, HZ / 5, 1);
6442
6443int ata_ratelimit(void)
6444{
6445 return __ratelimit(&ratelimit);
6446}
6447EXPORT_SYMBOL_GPL(ata_ratelimit);
6448
6449
6450
6451
6452
6453
6454
6455
6456
6457
6458
6459
6460
6461
6462
6463void ata_msleep(struct ata_port *ap, unsigned int msecs)
6464{
6465 bool owns_eh = ap && ap->host->eh_owner == current;
6466
6467 if (owns_eh)
6468 ata_eh_release(ap);
6469
6470 if (msecs < 20) {
6471 unsigned long usecs = msecs * USEC_PER_MSEC;
6472 usleep_range(usecs, usecs + 50);
6473 } else {
6474 msleep(msecs);
6475 }
6476
6477 if (owns_eh)
6478 ata_eh_acquire(ap);
6479}
6480EXPORT_SYMBOL_GPL(ata_msleep);
6481
6482
6483
6484
6485
6486
6487
6488
6489
6490
6491
6492
6493
6494
6495
6496
6497
6498
6499
6500
6501
6502
6503
6504
6505
6506u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
6507 unsigned long interval, unsigned long timeout)
6508{
6509 unsigned long deadline;
6510 u32 tmp;
6511
6512 tmp = ioread32(reg);
6513
6514
6515
6516
6517
6518 deadline = ata_deadline(jiffies, timeout);
6519
6520 while ((tmp & mask) == val && time_before(jiffies, deadline)) {
6521 ata_msleep(ap, interval);
6522 tmp = ioread32(reg);
6523 }
6524
6525 return tmp;
6526}
6527EXPORT_SYMBOL_GPL(ata_wait_register);
6528
6529
6530
6531
6532static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
6533{
6534 return AC_ERR_SYSTEM;
6535}
6536
6537static void ata_dummy_error_handler(struct ata_port *ap)
6538{
6539
6540}
6541
6542struct ata_port_operations ata_dummy_port_ops = {
6543 .qc_prep = ata_noop_qc_prep,
6544 .qc_issue = ata_dummy_qc_issue,
6545 .error_handler = ata_dummy_error_handler,
6546 .sched_eh = ata_std_sched_eh,
6547 .end_eh = ata_std_end_eh,
6548};
6549EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
6550
6551const struct ata_port_info ata_dummy_port_info = {
6552 .port_ops = &ata_dummy_port_ops,
6553};
6554EXPORT_SYMBOL_GPL(ata_dummy_port_info);
6555
6556
6557
6558
6559void ata_port_printk(const struct ata_port *ap, const char *level,
6560 const char *fmt, ...)
6561{
6562 struct va_format vaf;
6563 va_list args;
6564
6565 va_start(args, fmt);
6566
6567 vaf.fmt = fmt;
6568 vaf.va = &args;
6569
6570 printk("%sata%u: %pV", level, ap->print_id, &vaf);
6571
6572 va_end(args);
6573}
6574EXPORT_SYMBOL(ata_port_printk);
6575
6576void ata_link_printk(const struct ata_link *link, const char *level,
6577 const char *fmt, ...)
6578{
6579 struct va_format vaf;
6580 va_list args;
6581
6582 va_start(args, fmt);
6583
6584 vaf.fmt = fmt;
6585 vaf.va = &args;
6586
6587 if (sata_pmp_attached(link->ap) || link->ap->slave_link)
6588 printk("%sata%u.%02u: %pV",
6589 level, link->ap->print_id, link->pmp, &vaf);
6590 else
6591 printk("%sata%u: %pV",
6592 level, link->ap->print_id, &vaf);
6593
6594 va_end(args);
6595}
6596EXPORT_SYMBOL(ata_link_printk);
6597
6598void ata_dev_printk(const struct ata_device *dev, const char *level,
6599 const char *fmt, ...)
6600{
6601 struct va_format vaf;
6602 va_list args;
6603
6604 va_start(args, fmt);
6605
6606 vaf.fmt = fmt;
6607 vaf.va = &args;
6608
6609 printk("%sata%u.%02u: %pV",
6610 level, dev->link->ap->print_id, dev->link->pmp + dev->devno,
6611 &vaf);
6612
6613 va_end(args);
6614}
6615EXPORT_SYMBOL(ata_dev_printk);
6616
6617void ata_print_version(const struct device *dev, const char *version)
6618{
6619 dev_printk(KERN_DEBUG, dev, "version %s\n", version);
6620}
6621EXPORT_SYMBOL(ata_print_version);
6622