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 (dev->dma_mode && 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, "Read log page 0x%02x failed, Emask 0x%x\n",
2035 (unsigned int)page, err_mask);
2036 }
2037
2038 return err_mask;
2039}
2040
2041static bool ata_log_supported(struct ata_device *dev, u8 log)
2042{
2043 struct ata_port *ap = dev->link->ap;
2044
2045 if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, ap->sector_buf, 1))
2046 return false;
2047 return get_unaligned_le16(&ap->sector_buf[log * 2]) ? true : false;
2048}
2049
2050static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
2051{
2052 struct ata_port *ap = dev->link->ap;
2053 unsigned int err, i;
2054
2055 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE)) {
2056 ata_dev_warn(dev, "ATA Identify Device Log not supported\n");
2057 return false;
2058 }
2059
2060
2061
2062
2063
2064 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, 0, ap->sector_buf,
2065 1);
2066 if (err)
2067 return false;
2068
2069 for (i = 0; i < ap->sector_buf[8]; i++) {
2070 if (ap->sector_buf[9 + i] == page)
2071 return true;
2072 }
2073
2074 return false;
2075}
2076
2077static int ata_do_link_spd_horkage(struct ata_device *dev)
2078{
2079 struct ata_link *plink = ata_dev_phys_link(dev);
2080 u32 target, target_limit;
2081
2082 if (!sata_scr_valid(plink))
2083 return 0;
2084
2085 if (dev->horkage & ATA_HORKAGE_1_5_GBPS)
2086 target = 1;
2087 else
2088 return 0;
2089
2090 target_limit = (1 << target) - 1;
2091
2092
2093 if (plink->sata_spd_limit <= target_limit)
2094 return 0;
2095
2096 plink->sata_spd_limit = target_limit;
2097
2098
2099
2100
2101
2102 if (plink->sata_spd > target) {
2103 ata_dev_info(dev, "applying link speed limit horkage to %s\n",
2104 sata_spd_string(target));
2105 return -EAGAIN;
2106 }
2107 return 0;
2108}
2109
2110static inline u8 ata_dev_knobble(struct ata_device *dev)
2111{
2112 struct ata_port *ap = dev->link->ap;
2113
2114 if (ata_dev_blacklisted(dev) & ATA_HORKAGE_BRIDGE_OK)
2115 return 0;
2116
2117 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
2118}
2119
2120static void ata_dev_config_ncq_send_recv(struct ata_device *dev)
2121{
2122 struct ata_port *ap = dev->link->ap;
2123 unsigned int err_mask;
2124
2125 if (!ata_log_supported(dev, ATA_LOG_NCQ_SEND_RECV)) {
2126 ata_dev_warn(dev, "NCQ Send/Recv Log not supported\n");
2127 return;
2128 }
2129 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_SEND_RECV,
2130 0, ap->sector_buf, 1);
2131 if (!err_mask) {
2132 u8 *cmds = dev->ncq_send_recv_cmds;
2133
2134 dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
2135 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);
2136
2137 if (dev->horkage & ATA_HORKAGE_NO_NCQ_TRIM) {
2138 ata_dev_dbg(dev, "disabling queued TRIM support\n");
2139 cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
2140 ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
2141 }
2142 }
2143}
2144
2145static void ata_dev_config_ncq_non_data(struct ata_device *dev)
2146{
2147 struct ata_port *ap = dev->link->ap;
2148 unsigned int err_mask;
2149
2150 if (!ata_log_supported(dev, ATA_LOG_NCQ_NON_DATA)) {
2151 ata_dev_warn(dev,
2152 "NCQ Send/Recv Log not supported\n");
2153 return;
2154 }
2155 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_NON_DATA,
2156 0, ap->sector_buf, 1);
2157 if (!err_mask) {
2158 u8 *cmds = dev->ncq_non_data_cmds;
2159
2160 memcpy(cmds, ap->sector_buf, ATA_LOG_NCQ_NON_DATA_SIZE);
2161 }
2162}
2163
2164static void ata_dev_config_ncq_prio(struct ata_device *dev)
2165{
2166 struct ata_port *ap = dev->link->ap;
2167 unsigned int err_mask;
2168
2169 err_mask = ata_read_log_page(dev,
2170 ATA_LOG_IDENTIFY_DEVICE,
2171 ATA_LOG_SATA_SETTINGS,
2172 ap->sector_buf,
2173 1);
2174 if (err_mask)
2175 goto not_supported;
2176
2177 if (!(ap->sector_buf[ATA_LOG_NCQ_PRIO_OFFSET] & BIT(3)))
2178 goto not_supported;
2179
2180 dev->flags |= ATA_DFLAG_NCQ_PRIO;
2181
2182 return;
2183
2184not_supported:
2185 dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLE;
2186 dev->flags &= ~ATA_DFLAG_NCQ_PRIO;
2187}
2188
2189static bool ata_dev_check_adapter(struct ata_device *dev,
2190 unsigned short vendor_id)
2191{
2192 struct pci_dev *pcidev = NULL;
2193 struct device *parent_dev = NULL;
2194
2195 for (parent_dev = dev->tdev.parent; parent_dev != NULL;
2196 parent_dev = parent_dev->parent) {
2197 if (dev_is_pci(parent_dev)) {
2198 pcidev = to_pci_dev(parent_dev);
2199 if (pcidev->vendor == vendor_id)
2200 return true;
2201 break;
2202 }
2203 }
2204
2205 return false;
2206}
2207
2208static int ata_dev_config_ncq(struct ata_device *dev,
2209 char *desc, size_t desc_sz)
2210{
2211 struct ata_port *ap = dev->link->ap;
2212 int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
2213 unsigned int err_mask;
2214 char *aa_desc = "";
2215
2216 if (!ata_id_has_ncq(dev->id)) {
2217 desc[0] = '\0';
2218 return 0;
2219 }
2220 if (!IS_ENABLED(CONFIG_SATA_HOST))
2221 return 0;
2222 if (dev->horkage & ATA_HORKAGE_NONCQ) {
2223 snprintf(desc, desc_sz, "NCQ (not used)");
2224 return 0;
2225 }
2226
2227 if (dev->horkage & ATA_HORKAGE_NO_NCQ_ON_ATI &&
2228 ata_dev_check_adapter(dev, PCI_VENDOR_ID_ATI)) {
2229 snprintf(desc, desc_sz, "NCQ (not used)");
2230 return 0;
2231 }
2232
2233 if (ap->flags & ATA_FLAG_NCQ) {
2234 hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE);
2235 dev->flags |= ATA_DFLAG_NCQ;
2236 }
2237
2238 if (!(dev->horkage & ATA_HORKAGE_BROKEN_FPDMA_AA) &&
2239 (ap->flags & ATA_FLAG_FPDMA_AA) &&
2240 ata_id_has_fpdma_aa(dev->id)) {
2241 err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
2242 SATA_FPDMA_AA);
2243 if (err_mask) {
2244 ata_dev_err(dev,
2245 "failed to enable AA (error_mask=0x%x)\n",
2246 err_mask);
2247 if (err_mask != AC_ERR_DEV) {
2248 dev->horkage |= ATA_HORKAGE_BROKEN_FPDMA_AA;
2249 return -EIO;
2250 }
2251 } else
2252 aa_desc = ", AA";
2253 }
2254
2255 if (hdepth >= ddepth)
2256 snprintf(desc, desc_sz, "NCQ (depth %d)%s", ddepth, aa_desc);
2257 else
2258 snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
2259 ddepth, aa_desc);
2260
2261 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
2262 if (ata_id_has_ncq_send_and_recv(dev->id))
2263 ata_dev_config_ncq_send_recv(dev);
2264 if (ata_id_has_ncq_non_data(dev->id))
2265 ata_dev_config_ncq_non_data(dev);
2266 if (ata_id_has_ncq_prio(dev->id))
2267 ata_dev_config_ncq_prio(dev);
2268 }
2269
2270 return 0;
2271}
2272
2273static void ata_dev_config_sense_reporting(struct ata_device *dev)
2274{
2275 unsigned int err_mask;
2276
2277 if (!ata_id_has_sense_reporting(dev->id))
2278 return;
2279
2280 if (ata_id_sense_reporting_enabled(dev->id))
2281 return;
2282
2283 err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA, 0x1);
2284 if (err_mask) {
2285 ata_dev_dbg(dev,
2286 "failed to enable Sense Data Reporting, Emask 0x%x\n",
2287 err_mask);
2288 }
2289}
2290
2291static void ata_dev_config_zac(struct ata_device *dev)
2292{
2293 struct ata_port *ap = dev->link->ap;
2294 unsigned int err_mask;
2295 u8 *identify_buf = ap->sector_buf;
2296
2297 dev->zac_zones_optimal_open = U32_MAX;
2298 dev->zac_zones_optimal_nonseq = U32_MAX;
2299 dev->zac_zones_max_open = U32_MAX;
2300
2301
2302
2303
2304 if (dev->class == ATA_DEV_ZAC)
2305 dev->flags |= ATA_DFLAG_ZAC;
2306 else if (ata_id_zoned_cap(dev->id) == 0x01)
2307
2308
2309
2310 dev->flags |= ATA_DFLAG_ZAC;
2311
2312 if (!(dev->flags & ATA_DFLAG_ZAC))
2313 return;
2314
2315 if (!ata_identify_page_supported(dev, ATA_LOG_ZONED_INFORMATION)) {
2316 ata_dev_warn(dev,
2317 "ATA Zoned Information Log not supported\n");
2318 return;
2319 }
2320
2321
2322
2323
2324 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
2325 ATA_LOG_ZONED_INFORMATION,
2326 identify_buf, 1);
2327 if (!err_mask) {
2328 u64 zoned_cap, opt_open, opt_nonseq, max_open;
2329
2330 zoned_cap = get_unaligned_le64(&identify_buf[8]);
2331 if ((zoned_cap >> 63))
2332 dev->zac_zoned_cap = (zoned_cap & 1);
2333 opt_open = get_unaligned_le64(&identify_buf[24]);
2334 if ((opt_open >> 63))
2335 dev->zac_zones_optimal_open = (u32)opt_open;
2336 opt_nonseq = get_unaligned_le64(&identify_buf[32]);
2337 if ((opt_nonseq >> 63))
2338 dev->zac_zones_optimal_nonseq = (u32)opt_nonseq;
2339 max_open = get_unaligned_le64(&identify_buf[40]);
2340 if ((max_open >> 63))
2341 dev->zac_zones_max_open = (u32)max_open;
2342 }
2343}
2344
2345static void ata_dev_config_trusted(struct ata_device *dev)
2346{
2347 struct ata_port *ap = dev->link->ap;
2348 u64 trusted_cap;
2349 unsigned int err;
2350
2351 if (!ata_id_has_trusted(dev->id))
2352 return;
2353
2354 if (!ata_identify_page_supported(dev, ATA_LOG_SECURITY)) {
2355 ata_dev_warn(dev,
2356 "Security Log not supported\n");
2357 return;
2358 }
2359
2360 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, ATA_LOG_SECURITY,
2361 ap->sector_buf, 1);
2362 if (err)
2363 return;
2364
2365 trusted_cap = get_unaligned_le64(&ap->sector_buf[40]);
2366 if (!(trusted_cap & (1ULL << 63))) {
2367 ata_dev_dbg(dev,
2368 "Trusted Computing capability qword not valid!\n");
2369 return;
2370 }
2371
2372 if (trusted_cap & (1 << 0))
2373 dev->flags |= ATA_DFLAG_TRUSTED;
2374}
2375
2376static int ata_dev_config_lba(struct ata_device *dev)
2377{
2378 struct ata_port *ap = dev->link->ap;
2379 const u16 *id = dev->id;
2380 const char *lba_desc;
2381 char ncq_desc[24];
2382 int ret;
2383
2384 dev->flags |= ATA_DFLAG_LBA;
2385
2386 if (ata_id_has_lba48(id)) {
2387 lba_desc = "LBA48";
2388 dev->flags |= ATA_DFLAG_LBA48;
2389 if (dev->n_sectors >= (1UL << 28) &&
2390 ata_id_has_flush_ext(id))
2391 dev->flags |= ATA_DFLAG_FLUSH_EXT;
2392 } else {
2393 lba_desc = "LBA";
2394 }
2395
2396
2397 ret = ata_dev_config_ncq(dev, ncq_desc, sizeof(ncq_desc));
2398
2399
2400 if (ata_msg_drv(ap) && ata_dev_print_info(dev))
2401 ata_dev_info(dev,
2402 "%llu sectors, multi %u: %s %s\n",
2403 (unsigned long long)dev->n_sectors,
2404 dev->multi_count, lba_desc, ncq_desc);
2405
2406 return ret;
2407}
2408
2409static void ata_dev_config_chs(struct ata_device *dev)
2410{
2411 struct ata_port *ap = dev->link->ap;
2412 const u16 *id = dev->id;
2413
2414 if (ata_id_current_chs_valid(id)) {
2415
2416 dev->cylinders = id[54];
2417 dev->heads = id[55];
2418 dev->sectors = id[56];
2419 } else {
2420
2421 dev->cylinders = id[1];
2422 dev->heads = id[3];
2423 dev->sectors = id[6];
2424 }
2425
2426
2427 if (ata_msg_drv(ap) && ata_dev_print_info(dev))
2428 ata_dev_info(dev,
2429 "%llu sectors, multi %u, CHS %u/%u/%u\n",
2430 (unsigned long long)dev->n_sectors,
2431 dev->multi_count, dev->cylinders,
2432 dev->heads, dev->sectors);
2433}
2434
2435static void ata_dev_config_devslp(struct ata_device *dev)
2436{
2437 u8 *sata_setting = dev->link->ap->sector_buf;
2438 unsigned int err_mask;
2439 int i, j;
2440
2441
2442
2443
2444
2445 if (!ata_id_has_devslp(dev->id))
2446 return;
2447
2448 err_mask = ata_read_log_page(dev,
2449 ATA_LOG_IDENTIFY_DEVICE,
2450 ATA_LOG_SATA_SETTINGS,
2451 sata_setting, 1);
2452 if (err_mask)
2453 return;
2454
2455 dev->flags |= ATA_DFLAG_DEVSLP;
2456 for (i = 0; i < ATA_LOG_DEVSLP_SIZE; i++) {
2457 j = ATA_LOG_DEVSLP_OFFSET + i;
2458 dev->devslp_timing[i] = sata_setting[j];
2459 }
2460}
2461
2462static void ata_dev_print_features(struct ata_device *dev)
2463{
2464 if (!(dev->flags & ATA_DFLAG_FEATURES_MASK))
2465 return;
2466
2467 ata_dev_info(dev,
2468 "Features:%s%s%s%s%s\n",
2469 dev->flags & ATA_DFLAG_TRUSTED ? " Trust" : "",
2470 dev->flags & ATA_DFLAG_DA ? " Dev-Attention" : "",
2471 dev->flags & ATA_DFLAG_DEVSLP ? " Dev-Sleep" : "",
2472 dev->flags & ATA_DFLAG_NCQ_SEND_RECV ? " NCQ-sndrcv" : "",
2473 dev->flags & ATA_DFLAG_NCQ_PRIO ? " NCQ-prio" : "");
2474}
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489int ata_dev_configure(struct ata_device *dev)
2490{
2491 struct ata_port *ap = dev->link->ap;
2492 bool print_info = ata_dev_print_info(dev);
2493 const u16 *id = dev->id;
2494 unsigned long xfer_mask;
2495 unsigned int err_mask;
2496 char revbuf[7];
2497 char fwrevbuf[ATA_ID_FW_REV_LEN+1];
2498 char modelbuf[ATA_ID_PROD_LEN+1];
2499 int rc;
2500
2501 if (!ata_dev_enabled(dev) && ata_msg_info(ap)) {
2502 ata_dev_info(dev, "%s: ENTER/EXIT -- nodev\n", __func__);
2503 return 0;
2504 }
2505
2506 if (ata_msg_probe(ap))
2507 ata_dev_dbg(dev, "%s: ENTER\n", __func__);
2508
2509
2510 dev->horkage |= ata_dev_blacklisted(dev);
2511 ata_force_horkage(dev);
2512
2513 if (dev->horkage & ATA_HORKAGE_DISABLE) {
2514 ata_dev_info(dev, "unsupported device, disabling\n");
2515 ata_dev_disable(dev);
2516 return 0;
2517 }
2518
2519 if ((!atapi_enabled || (ap->flags & ATA_FLAG_NO_ATAPI)) &&
2520 dev->class == ATA_DEV_ATAPI) {
2521 ata_dev_warn(dev, "WARNING: ATAPI is %s, device ignored\n",
2522 atapi_enabled ? "not supported with this driver"
2523 : "disabled");
2524 ata_dev_disable(dev);
2525 return 0;
2526 }
2527
2528 rc = ata_do_link_spd_horkage(dev);
2529 if (rc)
2530 return rc;
2531
2532
2533 if ((dev->horkage & ATA_HORKAGE_WD_BROKEN_LPM) &&
2534 (id[ATA_ID_SATA_CAPABILITY] & 0xe) == 0x2)
2535 dev->horkage |= ATA_HORKAGE_NOLPM;
2536
2537 if (ap->flags & ATA_FLAG_NO_LPM)
2538 dev->horkage |= ATA_HORKAGE_NOLPM;
2539
2540 if (dev->horkage & ATA_HORKAGE_NOLPM) {
2541 ata_dev_warn(dev, "LPM support broken, forcing max_power\n");
2542 dev->link->ap->target_lpm_policy = ATA_LPM_MAX_POWER;
2543 }
2544
2545
2546 rc = ata_acpi_on_devcfg(dev);
2547 if (rc)
2548 return rc;
2549
2550
2551 rc = ata_hpa_resize(dev);
2552 if (rc)
2553 return rc;
2554
2555
2556 if (ata_msg_probe(ap))
2557 ata_dev_dbg(dev,
2558 "%s: cfg 49:%04x 82:%04x 83:%04x 84:%04x "
2559 "85:%04x 86:%04x 87:%04x 88:%04x\n",
2560 __func__,
2561 id[49], id[82], id[83], id[84],
2562 id[85], id[86], id[87], id[88]);
2563
2564
2565 dev->flags &= ~ATA_DFLAG_CFG_MASK;
2566 dev->max_sectors = 0;
2567 dev->cdb_len = 0;
2568 dev->n_sectors = 0;
2569 dev->cylinders = 0;
2570 dev->heads = 0;
2571 dev->sectors = 0;
2572 dev->multi_count = 0;
2573
2574
2575
2576
2577
2578
2579 xfer_mask = ata_id_xfermask(id);
2580
2581 if (ata_msg_probe(ap))
2582 ata_dump_id(id);
2583
2584
2585 ata_id_c_string(dev->id, fwrevbuf, ATA_ID_FW_REV,
2586 sizeof(fwrevbuf));
2587
2588 ata_id_c_string(dev->id, modelbuf, ATA_ID_PROD,
2589 sizeof(modelbuf));
2590
2591
2592 if (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ZAC) {
2593 if (ata_id_is_cfa(id)) {
2594
2595 if (id[ATA_ID_CFA_KEY_MGMT] & 1)
2596 ata_dev_warn(dev,
2597 "supports DRM functions and may not be fully accessible\n");
2598 snprintf(revbuf, 7, "CFA");
2599 } else {
2600 snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
2601
2602 if (ata_id_has_tpm(id))
2603 ata_dev_warn(dev,
2604 "supports DRM functions and may not be fully accessible\n");
2605 }
2606
2607 dev->n_sectors = ata_id_n_sectors(id);
2608
2609
2610 if ((dev->id[47] >> 8) == 0x80 && (dev->id[59] & 0x100)) {
2611 unsigned int max = dev->id[47] & 0xff;
2612 unsigned int cnt = dev->id[59] & 0xff;
2613
2614 if (is_power_of_2(max) && is_power_of_2(cnt))
2615 if (cnt <= max)
2616 dev->multi_count = cnt;
2617 }
2618
2619
2620 if (ata_msg_drv(ap) && print_info)
2621 ata_dev_info(dev, "%s: %s, %s, max %s\n",
2622 revbuf, modelbuf, fwrevbuf,
2623 ata_mode_string(xfer_mask));
2624
2625 if (ata_id_has_lba(id)) {
2626 rc = ata_dev_config_lba(dev);
2627 if (rc)
2628 return rc;
2629 } else {
2630 ata_dev_config_chs(dev);
2631 }
2632
2633 ata_dev_config_devslp(dev);
2634 ata_dev_config_sense_reporting(dev);
2635 ata_dev_config_zac(dev);
2636 ata_dev_config_trusted(dev);
2637 dev->cdb_len = 32;
2638
2639 if (ata_msg_drv(ap) && print_info)
2640 ata_dev_print_features(dev);
2641 }
2642
2643
2644 else if (dev->class == ATA_DEV_ATAPI) {
2645 const char *cdb_intr_string = "";
2646 const char *atapi_an_string = "";
2647 const char *dma_dir_string = "";
2648 u32 sntf;
2649
2650 rc = atapi_cdb_len(id);
2651 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
2652 if (ata_msg_warn(ap))
2653 ata_dev_warn(dev, "unsupported CDB len\n");
2654 rc = -EINVAL;
2655 goto err_out_nosup;
2656 }
2657 dev->cdb_len = (unsigned int) rc;
2658
2659
2660
2661
2662
2663
2664 if (atapi_an &&
2665 (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
2666 (!sata_pmp_attached(ap) ||
2667 sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
2668
2669 err_mask = ata_dev_set_feature(dev,
2670 SETFEATURES_SATA_ENABLE, SATA_AN);
2671 if (err_mask)
2672 ata_dev_err(dev,
2673 "failed to enable ATAPI AN (err_mask=0x%x)\n",
2674 err_mask);
2675 else {
2676 dev->flags |= ATA_DFLAG_AN;
2677 atapi_an_string = ", ATAPI AN";
2678 }
2679 }
2680
2681 if (ata_id_cdb_intr(dev->id)) {
2682 dev->flags |= ATA_DFLAG_CDB_INTR;
2683 cdb_intr_string = ", CDB intr";
2684 }
2685
2686 if (atapi_dmadir || (dev->horkage & ATA_HORKAGE_ATAPI_DMADIR) || atapi_id_dmadir(dev->id)) {
2687 dev->flags |= ATA_DFLAG_DMADIR;
2688 dma_dir_string = ", DMADIR";
2689 }
2690
2691 if (ata_id_has_da(dev->id)) {
2692 dev->flags |= ATA_DFLAG_DA;
2693 zpodd_init(dev);
2694 }
2695
2696
2697 if (ata_msg_drv(ap) && print_info)
2698 ata_dev_info(dev,
2699 "ATAPI: %s, %s, max %s%s%s%s\n",
2700 modelbuf, fwrevbuf,
2701 ata_mode_string(xfer_mask),
2702 cdb_intr_string, atapi_an_string,
2703 dma_dir_string);
2704 }
2705
2706
2707 dev->max_sectors = ATA_MAX_SECTORS;
2708 if (dev->flags & ATA_DFLAG_LBA48)
2709 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2710
2711
2712
2713 if (ata_dev_knobble(dev)) {
2714 if (ata_msg_drv(ap) && print_info)
2715 ata_dev_info(dev, "applying bridge limits\n");
2716 dev->udma_mask &= ATA_UDMA5;
2717 dev->max_sectors = ATA_MAX_SECTORS;
2718 }
2719
2720 if ((dev->class == ATA_DEV_ATAPI) &&
2721 (atapi_command_packet_set(id) == TYPE_TAPE)) {
2722 dev->max_sectors = ATA_MAX_SECTORS_TAPE;
2723 dev->horkage |= ATA_HORKAGE_STUCK_ERR;
2724 }
2725
2726 if (dev->horkage & ATA_HORKAGE_MAX_SEC_128)
2727 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_128,
2728 dev->max_sectors);
2729
2730 if (dev->horkage & ATA_HORKAGE_MAX_SEC_1024)
2731 dev->max_sectors = min_t(unsigned int, ATA_MAX_SECTORS_1024,
2732 dev->max_sectors);
2733
2734 if (dev->horkage & ATA_HORKAGE_MAX_SEC_LBA48)
2735 dev->max_sectors = ATA_MAX_SECTORS_LBA48;
2736
2737 if (ap->ops->dev_config)
2738 ap->ops->dev_config(dev);
2739
2740 if (dev->horkage & ATA_HORKAGE_DIAGNOSTIC) {
2741
2742
2743
2744
2745
2746
2747 if (print_info) {
2748 ata_dev_warn(dev,
2749"Drive reports diagnostics failure. This may indicate a drive\n");
2750 ata_dev_warn(dev,
2751"fault or invalid emulation. Contact drive vendor for information.\n");
2752 }
2753 }
2754
2755 if ((dev->horkage & ATA_HORKAGE_FIRMWARE_WARN) && print_info) {
2756 ata_dev_warn(dev, "WARNING: device requires firmware update to be fully functional\n");
2757 ata_dev_warn(dev, " contact the vendor or visit http://ata.wiki.kernel.org\n");
2758 }
2759
2760 return 0;
2761
2762err_out_nosup:
2763 if (ata_msg_probe(ap))
2764 ata_dev_dbg(dev, "%s: EXIT, err\n", __func__);
2765 return rc;
2766}
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776int ata_cable_40wire(struct ata_port *ap)
2777{
2778 return ATA_CBL_PATA40;
2779}
2780EXPORT_SYMBOL_GPL(ata_cable_40wire);
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790int ata_cable_80wire(struct ata_port *ap)
2791{
2792 return ATA_CBL_PATA80;
2793}
2794EXPORT_SYMBOL_GPL(ata_cable_80wire);
2795
2796
2797
2798
2799
2800
2801
2802
2803int ata_cable_unknown(struct ata_port *ap)
2804{
2805 return ATA_CBL_PATA_UNK;
2806}
2807EXPORT_SYMBOL_GPL(ata_cable_unknown);
2808
2809
2810
2811
2812
2813
2814
2815
2816int ata_cable_ignore(struct ata_port *ap)
2817{
2818 return ATA_CBL_PATA_IGN;
2819}
2820EXPORT_SYMBOL_GPL(ata_cable_ignore);
2821
2822
2823
2824
2825
2826
2827
2828
2829int ata_cable_sata(struct ata_port *ap)
2830{
2831 return ATA_CBL_SATA;
2832}
2833EXPORT_SYMBOL_GPL(ata_cable_sata);
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850int ata_bus_probe(struct ata_port *ap)
2851{
2852 unsigned int classes[ATA_MAX_DEVICES];
2853 int tries[ATA_MAX_DEVICES];
2854 int rc;
2855 struct ata_device *dev;
2856
2857 ata_for_each_dev(dev, &ap->link, ALL)
2858 tries[dev->devno] = ATA_PROBE_MAX_TRIES;
2859
2860 retry:
2861 ata_for_each_dev(dev, &ap->link, ALL) {
2862
2863
2864
2865
2866
2867
2868
2869 dev->pio_mode = XFER_PIO_0;
2870 dev->dma_mode = 0xff;
2871
2872
2873
2874
2875
2876
2877 if (ap->ops->set_piomode)
2878 ap->ops->set_piomode(ap, dev);
2879 }
2880
2881
2882 ap->ops->phy_reset(ap);
2883
2884 ata_for_each_dev(dev, &ap->link, ALL) {
2885 if (dev->class != ATA_DEV_UNKNOWN)
2886 classes[dev->devno] = dev->class;
2887 else
2888 classes[dev->devno] = ATA_DEV_NONE;
2889
2890 dev->class = ATA_DEV_UNKNOWN;
2891 }
2892
2893
2894
2895
2896
2897 ata_for_each_dev(dev, &ap->link, ALL_REVERSE) {
2898 if (tries[dev->devno])
2899 dev->class = classes[dev->devno];
2900
2901 if (!ata_dev_enabled(dev))
2902 continue;
2903
2904 rc = ata_dev_read_id(dev, &dev->class, ATA_READID_POSTRESET,
2905 dev->id);
2906 if (rc)
2907 goto fail;
2908 }
2909
2910
2911 if (ap->ops->cable_detect)
2912 ap->cbl = ap->ops->cable_detect(ap);
2913
2914
2915
2916
2917
2918
2919 ata_for_each_dev(dev, &ap->link, ENABLED)
2920 if (ata_id_is_sata(dev->id))
2921 ap->cbl = ATA_CBL_SATA;
2922
2923
2924
2925
2926 ata_for_each_dev(dev, &ap->link, ENABLED) {
2927 ap->link.eh_context.i.flags |= ATA_EHI_PRINTINFO;
2928 rc = ata_dev_configure(dev);
2929 ap->link.eh_context.i.flags &= ~ATA_EHI_PRINTINFO;
2930 if (rc)
2931 goto fail;
2932 }
2933
2934
2935 rc = ata_set_mode(&ap->link, &dev);
2936 if (rc)
2937 goto fail;
2938
2939 ata_for_each_dev(dev, &ap->link, ENABLED)
2940 return 0;
2941
2942 return -ENODEV;
2943
2944 fail:
2945 tries[dev->devno]--;
2946
2947 switch (rc) {
2948 case -EINVAL:
2949
2950 tries[dev->devno] = 0;
2951 break;
2952
2953 case -ENODEV:
2954
2955 tries[dev->devno] = min(tries[dev->devno], 1);
2956 fallthrough;
2957 case -EIO:
2958 if (tries[dev->devno] == 1) {
2959
2960
2961
2962 sata_down_spd_limit(&ap->link, 0);
2963 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
2964 }
2965 }
2966
2967 if (!tries[dev->devno])
2968 ata_dev_disable(dev);
2969
2970 goto retry;
2971}
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982static void sata_print_link_status(struct ata_link *link)
2983{
2984 u32 sstatus, scontrol, tmp;
2985
2986 if (sata_scr_read(link, SCR_STATUS, &sstatus))
2987 return;
2988 sata_scr_read(link, SCR_CONTROL, &scontrol);
2989
2990 if (ata_phys_link_online(link)) {
2991 tmp = (sstatus >> 4) & 0xf;
2992 ata_link_info(link, "SATA link up %s (SStatus %X SControl %X)\n",
2993 sata_spd_string(tmp), sstatus, scontrol);
2994 } else {
2995 ata_link_info(link, "SATA link down (SStatus %X SControl %X)\n",
2996 sstatus, scontrol);
2997 }
2998}
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008struct ata_device *ata_dev_pair(struct ata_device *adev)
3009{
3010 struct ata_link *link = adev->link;
3011 struct ata_device *pair = &link->device[1 - adev->devno];
3012 if (!ata_dev_enabled(pair))
3013 return NULL;
3014 return pair;
3015}
3016EXPORT_SYMBOL_GPL(ata_dev_pair);
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038int sata_down_spd_limit(struct ata_link *link, u32 spd_limit)
3039{
3040 u32 sstatus, spd, mask;
3041 int rc, bit;
3042
3043 if (!sata_scr_valid(link))
3044 return -EOPNOTSUPP;
3045
3046
3047
3048
3049 rc = sata_scr_read(link, SCR_STATUS, &sstatus);
3050 if (rc == 0 && ata_sstatus_online(sstatus))
3051 spd = (sstatus >> 4) & 0xf;
3052 else
3053 spd = link->sata_spd;
3054
3055 mask = link->sata_spd_limit;
3056 if (mask <= 1)
3057 return -EINVAL;
3058
3059
3060 bit = fls(mask) - 1;
3061 mask &= ~(1 << bit);
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072 if (spd > 1)
3073 mask &= (1 << (spd - 1)) - 1;
3074 else
3075 return -EINVAL;
3076
3077
3078 if (!mask)
3079 return -EINVAL;
3080
3081 if (spd_limit) {
3082 if (mask & ((1 << spd_limit) - 1))
3083 mask &= (1 << spd_limit) - 1;
3084 else {
3085 bit = ffs(mask) - 1;
3086 mask = 1 << bit;
3087 }
3088 }
3089
3090 link->sata_spd_limit = mask;
3091
3092 ata_link_warn(link, "limiting SATA link speed to %s\n",
3093 sata_spd_string(fls(mask)));
3094
3095 return 0;
3096}
3097
3098#ifdef CONFIG_ATA_ACPI
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle)
3116{
3117 u8 base_mode = 0xff, last_mode = 0xff;
3118 const struct ata_xfer_ent *ent;
3119 const struct ata_timing *t;
3120
3121 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
3122 if (ent->shift == xfer_shift)
3123 base_mode = ent->base;
3124
3125 for (t = ata_timing_find_mode(base_mode);
3126 t && ata_xfer_mode2shift(t->mode) == xfer_shift; t++) {
3127 unsigned short this_cycle;
3128
3129 switch (xfer_shift) {
3130 case ATA_SHIFT_PIO:
3131 case ATA_SHIFT_MWDMA:
3132 this_cycle = t->cycle;
3133 break;
3134 case ATA_SHIFT_UDMA:
3135 this_cycle = t->udma;
3136 break;
3137 default:
3138 return 0xff;
3139 }
3140
3141 if (cycle > this_cycle)
3142 break;
3143
3144 last_mode = t->mode;
3145 }
3146
3147 return last_mode;
3148}
3149#endif
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel)
3167{
3168 char buf[32];
3169 unsigned long orig_mask, xfer_mask;
3170 unsigned long pio_mask, mwdma_mask, udma_mask;
3171 int quiet, highbit;
3172
3173 quiet = !!(sel & ATA_DNXFER_QUIET);
3174 sel &= ~ATA_DNXFER_QUIET;
3175
3176 xfer_mask = orig_mask = ata_pack_xfermask(dev->pio_mask,
3177 dev->mwdma_mask,
3178 dev->udma_mask);
3179 ata_unpack_xfermask(xfer_mask, &pio_mask, &mwdma_mask, &udma_mask);
3180
3181 switch (sel) {
3182 case ATA_DNXFER_PIO:
3183 highbit = fls(pio_mask) - 1;
3184 pio_mask &= ~(1 << highbit);
3185 break;
3186
3187 case ATA_DNXFER_DMA:
3188 if (udma_mask) {
3189 highbit = fls(udma_mask) - 1;
3190 udma_mask &= ~(1 << highbit);
3191 if (!udma_mask)
3192 return -ENOENT;
3193 } else if (mwdma_mask) {
3194 highbit = fls(mwdma_mask) - 1;
3195 mwdma_mask &= ~(1 << highbit);
3196 if (!mwdma_mask)
3197 return -ENOENT;
3198 }
3199 break;
3200
3201 case ATA_DNXFER_40C:
3202 udma_mask &= ATA_UDMA_MASK_40C;
3203 break;
3204
3205 case ATA_DNXFER_FORCE_PIO0:
3206 pio_mask &= 1;
3207 fallthrough;
3208 case ATA_DNXFER_FORCE_PIO:
3209 mwdma_mask = 0;
3210 udma_mask = 0;
3211 break;
3212
3213 default:
3214 BUG();
3215 }
3216
3217 xfer_mask &= ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
3218
3219 if (!(xfer_mask & ATA_MASK_PIO) || xfer_mask == orig_mask)
3220 return -ENOENT;
3221
3222 if (!quiet) {
3223 if (xfer_mask & (ATA_MASK_MWDMA | ATA_MASK_UDMA))
3224 snprintf(buf, sizeof(buf), "%s:%s",
3225 ata_mode_string(xfer_mask),
3226 ata_mode_string(xfer_mask & ATA_MASK_PIO));
3227 else
3228 snprintf(buf, sizeof(buf), "%s",
3229 ata_mode_string(xfer_mask));
3230
3231 ata_dev_warn(dev, "limiting speed to %s\n", buf);
3232 }
3233
3234 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
3235 &dev->udma_mask);
3236
3237 return 0;
3238}
3239
3240static int ata_dev_set_mode(struct ata_device *dev)
3241{
3242 struct ata_port *ap = dev->link->ap;
3243 struct ata_eh_context *ehc = &dev->link->eh_context;
3244 const bool nosetxfer = dev->horkage & ATA_HORKAGE_NOSETXFER;
3245 const char *dev_err_whine = "";
3246 int ign_dev_err = 0;
3247 unsigned int err_mask = 0;
3248 int rc;
3249
3250 dev->flags &= ~ATA_DFLAG_PIO;
3251 if (dev->xfer_shift == ATA_SHIFT_PIO)
3252 dev->flags |= ATA_DFLAG_PIO;
3253
3254 if (nosetxfer && ap->flags & ATA_FLAG_SATA && ata_id_is_sata(dev->id))
3255 dev_err_whine = " (SET_XFERMODE skipped)";
3256 else {
3257 if (nosetxfer)
3258 ata_dev_warn(dev,
3259 "NOSETXFER but PATA detected - can't "
3260 "skip SETXFER, might malfunction\n");
3261 err_mask = ata_dev_set_xfermode(dev);
3262 }
3263
3264 if (err_mask & ~AC_ERR_DEV)
3265 goto fail;
3266
3267
3268 ehc->i.flags |= ATA_EHI_POST_SETMODE;
3269 rc = ata_dev_revalidate(dev, ATA_DEV_UNKNOWN, 0);
3270 ehc->i.flags &= ~ATA_EHI_POST_SETMODE;
3271 if (rc)
3272 return rc;
3273
3274 if (dev->xfer_shift == ATA_SHIFT_PIO) {
3275
3276 if (ata_id_is_cfa(dev->id))
3277 ign_dev_err = 1;
3278
3279
3280 if (ata_id_major_version(dev->id) == 0 &&
3281 dev->pio_mode <= XFER_PIO_2)
3282 ign_dev_err = 1;
3283
3284
3285
3286 if (!ata_id_has_iordy(dev->id) && dev->pio_mode <= XFER_PIO_2)
3287 ign_dev_err = 1;
3288 }
3289
3290
3291 if (dev->xfer_shift == ATA_SHIFT_MWDMA &&
3292 dev->dma_mode == XFER_MW_DMA_0 &&
3293 (dev->id[63] >> 8) & 1)
3294 ign_dev_err = 1;
3295
3296
3297 if (dev->xfer_mode == ata_xfer_mask2mode(ata_id_xfermask(dev->id)))
3298 ign_dev_err = 1;
3299
3300 if (err_mask & AC_ERR_DEV) {
3301 if (!ign_dev_err)
3302 goto fail;
3303 else
3304 dev_err_whine = " (device error ignored)";
3305 }
3306
3307 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
3308 dev->xfer_shift, (int)dev->xfer_mode);
3309
3310 if (!(ehc->i.flags & ATA_EHI_QUIET) ||
3311 ehc->i.flags & ATA_EHI_DID_HARDRESET)
3312 ata_dev_info(dev, "configured for %s%s\n",
3313 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)),
3314 dev_err_whine);
3315
3316 return 0;
3317
3318 fail:
3319 ata_dev_err(dev, "failed to set xfermode (err_mask=0x%x)\n", err_mask);
3320 return -EIO;
3321}
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3341{
3342 struct ata_port *ap = link->ap;
3343 struct ata_device *dev;
3344 int rc = 0, used_dma = 0, found = 0;
3345
3346
3347 ata_for_each_dev(dev, link, ENABLED) {
3348 unsigned long pio_mask, dma_mask;
3349 unsigned int mode_mask;
3350
3351 mode_mask = ATA_DMA_MASK_ATA;
3352 if (dev->class == ATA_DEV_ATAPI)
3353 mode_mask = ATA_DMA_MASK_ATAPI;
3354 else if (ata_id_is_cfa(dev->id))
3355 mode_mask = ATA_DMA_MASK_CFA;
3356
3357 ata_dev_xfermask(dev);
3358 ata_force_xfermask(dev);
3359
3360 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
3361
3362 if (libata_dma_mask & mode_mask)
3363 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask,
3364 dev->udma_mask);
3365 else
3366 dma_mask = 0;
3367
3368 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
3369 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
3370
3371 found = 1;
3372 if (ata_dma_enabled(dev))
3373 used_dma = 1;
3374 }
3375 if (!found)
3376 goto out;
3377
3378
3379 ata_for_each_dev(dev, link, ENABLED) {
3380 if (dev->pio_mode == 0xff) {
3381 ata_dev_warn(dev, "no PIO support\n");
3382 rc = -EINVAL;
3383 goto out;
3384 }
3385
3386 dev->xfer_mode = dev->pio_mode;
3387 dev->xfer_shift = ATA_SHIFT_PIO;
3388 if (ap->ops->set_piomode)
3389 ap->ops->set_piomode(ap, dev);
3390 }
3391
3392
3393 ata_for_each_dev(dev, link, ENABLED) {
3394 if (!ata_dma_enabled(dev))
3395 continue;
3396
3397 dev->xfer_mode = dev->dma_mode;
3398 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
3399 if (ap->ops->set_dmamode)
3400 ap->ops->set_dmamode(ap, dev);
3401 }
3402
3403
3404 ata_for_each_dev(dev, link, ENABLED) {
3405 rc = ata_dev_set_mode(dev);
3406 if (rc)
3407 goto out;
3408 }
3409
3410
3411
3412
3413 if (used_dma && (ap->host->flags & ATA_HOST_SIMPLEX))
3414 ap->host->simplex_claimed = ap;
3415
3416 out:
3417 if (rc)
3418 *r_failed_dev = dev;
3419 return rc;
3420}
3421EXPORT_SYMBOL_GPL(ata_do_set_mode);
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443int ata_wait_ready(struct ata_link *link, unsigned long deadline,
3444 int (*check_ready)(struct ata_link *link))
3445{
3446 unsigned long start = jiffies;
3447 unsigned long nodev_deadline;
3448 int warned = 0;
3449
3450
3451 if (link->ap->host->flags & ATA_HOST_PARALLEL_SCAN)
3452 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT_LONG);
3453 else
3454 nodev_deadline = ata_deadline(start, ATA_TMOUT_FF_WAIT);
3455
3456
3457
3458
3459
3460 WARN_ON(link == link->ap->slave_link);
3461
3462 if (time_after(nodev_deadline, deadline))
3463 nodev_deadline = deadline;
3464
3465 while (1) {
3466 unsigned long now = jiffies;
3467 int ready, tmp;
3468
3469 ready = tmp = check_ready(link);
3470 if (ready > 0)
3471 return 0;
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484 if (ready == -ENODEV) {
3485 if (ata_link_online(link))
3486 ready = 0;
3487 else if ((link->ap->flags & ATA_FLAG_SATA) &&
3488 !ata_link_offline(link) &&
3489 time_before(now, nodev_deadline))
3490 ready = 0;
3491 }
3492
3493 if (ready)
3494 return ready;
3495 if (time_after(now, deadline))
3496 return -EBUSY;
3497
3498 if (!warned && time_after(now, start + 5 * HZ) &&
3499 (deadline - now > 3 * HZ)) {
3500 ata_link_warn(link,
3501 "link is slow to respond, please be patient "
3502 "(ready=%d)\n", tmp);
3503 warned = 1;
3504 }
3505
3506 ata_msleep(link->ap, 50);
3507 }
3508}
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
3525 int (*check_ready)(struct ata_link *link))
3526{
3527 ata_msleep(link->ap, ATA_WAIT_AFTER_RESET);
3528
3529 return ata_wait_ready(link, deadline, check_ready);
3530}
3531EXPORT_SYMBOL_GPL(ata_wait_after_reset);
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550int ata_std_prereset(struct ata_link *link, unsigned long deadline)
3551{
3552 struct ata_port *ap = link->ap;
3553 struct ata_eh_context *ehc = &link->eh_context;
3554 const unsigned long *timing = sata_ehc_deb_timing(ehc);
3555 int rc;
3556
3557
3558 if (ehc->i.action & ATA_EH_HARDRESET)
3559 return 0;
3560
3561
3562 if (ap->flags & ATA_FLAG_SATA) {
3563 rc = sata_link_resume(link, timing, deadline);
3564
3565 if (rc && rc != -EOPNOTSUPP)
3566 ata_link_warn(link,
3567 "failed to resume link for reset (errno=%d)\n",
3568 rc);
3569 }
3570
3571
3572 if (ata_phys_link_offline(link))
3573 ehc->i.action &= ~ATA_EH_SOFTRESET;
3574
3575 return 0;
3576}
3577EXPORT_SYMBOL_GPL(ata_std_prereset);
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593int sata_std_hardreset(struct ata_link *link, unsigned int *class,
3594 unsigned long deadline)
3595{
3596 const unsigned long *timing = sata_ehc_deb_timing(&link->eh_context);
3597 bool online;
3598 int rc;
3599
3600
3601 rc = sata_link_hardreset(link, timing, deadline, &online, NULL);
3602 return online ? -EAGAIN : rc;
3603}
3604EXPORT_SYMBOL_GPL(sata_std_hardreset);
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618void ata_std_postreset(struct ata_link *link, unsigned int *classes)
3619{
3620 u32 serror;
3621
3622 DPRINTK("ENTER\n");
3623
3624
3625 if (!sata_scr_read(link, SCR_ERROR, &serror))
3626 sata_scr_write(link, SCR_ERROR, serror);
3627
3628
3629 sata_print_link_status(link);
3630
3631 DPRINTK("EXIT\n");
3632}
3633EXPORT_SYMBOL_GPL(ata_std_postreset);
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651static int ata_dev_same_device(struct ata_device *dev, unsigned int new_class,
3652 const u16 *new_id)
3653{
3654 const u16 *old_id = dev->id;
3655 unsigned char model[2][ATA_ID_PROD_LEN + 1];
3656 unsigned char serial[2][ATA_ID_SERNO_LEN + 1];
3657
3658 if (dev->class != new_class) {
3659 ata_dev_info(dev, "class mismatch %d != %d\n",
3660 dev->class, new_class);
3661 return 0;
3662 }
3663
3664 ata_id_c_string(old_id, model[0], ATA_ID_PROD, sizeof(model[0]));
3665 ata_id_c_string(new_id, model[1], ATA_ID_PROD, sizeof(model[1]));
3666 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO, sizeof(serial[0]));
3667 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO, sizeof(serial[1]));
3668
3669 if (strcmp(model[0], model[1])) {
3670 ata_dev_info(dev, "model number mismatch '%s' != '%s'\n",
3671 model[0], model[1]);
3672 return 0;
3673 }
3674
3675 if (strcmp(serial[0], serial[1])) {
3676 ata_dev_info(dev, "serial number mismatch '%s' != '%s'\n",
3677 serial[0], serial[1]);
3678 return 0;
3679 }
3680
3681 return 1;
3682}
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags)
3699{
3700 unsigned int class = dev->class;
3701 u16 *id = (void *)dev->link->ap->sector_buf;
3702 int rc;
3703
3704
3705 rc = ata_dev_read_id(dev, &class, readid_flags, id);
3706 if (rc)
3707 return rc;
3708
3709
3710 if (!ata_dev_same_device(dev, class, id))
3711 return -ENODEV;
3712
3713 memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
3714 return 0;
3715}
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
3733 unsigned int readid_flags)
3734{
3735 u64 n_sectors = dev->n_sectors;
3736 u64 n_native_sectors = dev->n_native_sectors;
3737 int rc;
3738
3739 if (!ata_dev_enabled(dev))
3740 return -ENODEV;
3741
3742
3743 if (ata_class_enabled(new_class) &&
3744 new_class != ATA_DEV_ATA &&
3745 new_class != ATA_DEV_ATAPI &&
3746 new_class != ATA_DEV_ZAC &&
3747 new_class != ATA_DEV_SEMB) {
3748 ata_dev_info(dev, "class mismatch %u != %u\n",
3749 dev->class, new_class);
3750 rc = -ENODEV;
3751 goto fail;
3752 }
3753
3754
3755 rc = ata_dev_reread_id(dev, readid_flags);
3756 if (rc)
3757 goto fail;
3758
3759
3760 rc = ata_dev_configure(dev);
3761 if (rc)
3762 goto fail;
3763
3764
3765 if (dev->class != ATA_DEV_ATA || !n_sectors ||
3766 dev->n_sectors == n_sectors)
3767 return 0;
3768
3769
3770 ata_dev_warn(dev, "n_sectors mismatch %llu != %llu\n",
3771 (unsigned long long)n_sectors,
3772 (unsigned long long)dev->n_sectors);
3773
3774
3775
3776
3777
3778
3779 if (dev->n_native_sectors == n_native_sectors &&
3780 dev->n_sectors > n_sectors && dev->n_sectors == n_native_sectors) {
3781 ata_dev_warn(dev,
3782 "new n_sectors matches native, probably "
3783 "late HPA unlock, n_sectors updated\n");
3784
3785 return 0;
3786 }
3787
3788
3789
3790
3791
3792
3793
3794 if (dev->n_native_sectors == n_native_sectors &&
3795 dev->n_sectors < n_sectors && n_sectors == n_native_sectors &&
3796 !(dev->horkage & ATA_HORKAGE_BROKEN_HPA)) {
3797 ata_dev_warn(dev,
3798 "old n_sectors matches native, probably "
3799 "late HPA lock, will try to unlock HPA\n");
3800
3801 dev->flags |= ATA_DFLAG_UNLOCK_HPA;
3802 rc = -EIO;
3803 } else
3804 rc = -ENODEV;
3805
3806
3807 dev->n_native_sectors = n_native_sectors;
3808 dev->n_sectors = n_sectors;
3809 fail:
3810 ata_dev_err(dev, "revalidation failed (errno=%d)\n", rc);
3811 return rc;
3812}
3813
3814struct ata_blacklist_entry {
3815 const char *model_num;
3816 const char *model_rev;
3817 unsigned long horkage;
3818};
3819
3820static const struct ata_blacklist_entry ata_device_blacklist [] = {
3821
3822 { "WDC AC11000H", NULL, ATA_HORKAGE_NODMA },
3823 { "WDC AC22100H", NULL, ATA_HORKAGE_NODMA },
3824 { "WDC AC32500H", NULL, ATA_HORKAGE_NODMA },
3825 { "WDC AC33100H", NULL, ATA_HORKAGE_NODMA },
3826 { "WDC AC31600H", NULL, ATA_HORKAGE_NODMA },
3827 { "WDC AC32100H", "24.09P07", ATA_HORKAGE_NODMA },
3828 { "WDC AC23200L", "21.10N21", ATA_HORKAGE_NODMA },
3829 { "Compaq CRD-8241B", NULL, ATA_HORKAGE_NODMA },
3830 { "CRD-8400B", NULL, ATA_HORKAGE_NODMA },
3831 { "CRD-848[02]B", NULL, ATA_HORKAGE_NODMA },
3832 { "CRD-84", NULL, ATA_HORKAGE_NODMA },
3833 { "SanDisk SDP3B", NULL, ATA_HORKAGE_NODMA },
3834 { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA },
3835 { "SANYO CD-ROM CRD", NULL, ATA_HORKAGE_NODMA },
3836 { "HITACHI CDR-8", NULL, ATA_HORKAGE_NODMA },
3837 { "HITACHI CDR-8[34]35",NULL, ATA_HORKAGE_NODMA },
3838 { "Toshiba CD-ROM XM-6202B", NULL, ATA_HORKAGE_NODMA },
3839 { "TOSHIBA CD-ROM XM-1702BC", NULL, ATA_HORKAGE_NODMA },
3840 { "CD-532E-A", NULL, ATA_HORKAGE_NODMA },
3841 { "E-IDE CD-ROM CR-840",NULL, ATA_HORKAGE_NODMA },
3842 { "CD-ROM Drive/F5A", NULL, ATA_HORKAGE_NODMA },
3843 { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA },
3844 { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA },
3845 { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA },
3846 { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
3847 { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA },
3848 { "SAMSUNG CD-ROM SN-124", "N001", ATA_HORKAGE_NODMA },
3849 { "Seagate STT20000A", NULL, ATA_HORKAGE_NODMA },
3850 { " 2GB ATA Flash Disk", "ADMA428M", ATA_HORKAGE_NODMA },
3851 { "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },
3852
3853 { "Config Disk", NULL, ATA_HORKAGE_DISABLE },
3854
3855
3856 { "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },
3857 { "QUANTUM DAT DAT72-000", NULL, ATA_HORKAGE_ATAPI_MOD16_DMA },
3858 { "Slimtype DVD A DS8A8SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
3859 { "Slimtype DVD A DS8A9SH", NULL, ATA_HORKAGE_MAX_SEC_LBA48 },
3860
3861
3862
3863
3864
3865 { "ST380013AS", "3.20", ATA_HORKAGE_MAX_SEC_1024 },
3866
3867
3868
3869
3870
3871 { "LITEON CX1-JB*-HP", NULL, ATA_HORKAGE_MAX_SEC_1024 },
3872 { "LITEON EP1-*", NULL, ATA_HORKAGE_MAX_SEC_1024 },
3873
3874
3875
3876
3877
3878 { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ },
3879 { "WDC WD740ADFD-00NLR1", NULL, ATA_HORKAGE_NONCQ, },
3880
3881 { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ },
3882
3883 { "Maxtor *", "BANC*", ATA_HORKAGE_NONCQ },
3884 { "Maxtor 7V300F0", "VA111630", ATA_HORKAGE_NONCQ },
3885 { "ST380817AS", "3.42", ATA_HORKAGE_NONCQ },
3886 { "ST3160023AS", "3.42", ATA_HORKAGE_NONCQ },
3887 { "OCZ CORE_SSD", "02.10104", ATA_HORKAGE_NONCQ },
3888
3889
3890 { "ST31500341AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3891 ATA_HORKAGE_FIRMWARE_WARN },
3892
3893 { "ST31000333AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3894 ATA_HORKAGE_FIRMWARE_WARN },
3895
3896 { "ST3640[36]23AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3897 ATA_HORKAGE_FIRMWARE_WARN },
3898
3899 { "ST3320[68]13AS", "SD1[5-9]", ATA_HORKAGE_NONCQ |
3900 ATA_HORKAGE_FIRMWARE_WARN },
3901
3902
3903
3904 { "ST1000LM024 HN-M101MBB", NULL, ATA_HORKAGE_BROKEN_FPDMA_AA |
3905 ATA_HORKAGE_NOLPM, },
3906 { "VB0250EAVER", "HPG7", ATA_HORKAGE_BROKEN_FPDMA_AA },
3907
3908
3909
3910 { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, },
3911 { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, },
3912 { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, },
3913
3914
3915 { "C300-CTFDDAC128MAG", "0001", ATA_HORKAGE_NONCQ, },
3916
3917
3918 { "SanDisk SD[789]*", NULL, ATA_HORKAGE_MAX_TRIM_128M, },
3919
3920
3921 { "HDS724040KLSA80", "KFAOA20N", ATA_HORKAGE_BROKEN_HPA, },
3922 { "WDC WD3200JD-00KLB0", "WD-WCAMR1130137", ATA_HORKAGE_BROKEN_HPA },
3923 { "WDC WD2500JD-00HBB0", "WD-WMAL71490727", ATA_HORKAGE_BROKEN_HPA },
3924 { "MAXTOR 6L080L4", "A93.0500", ATA_HORKAGE_BROKEN_HPA },
3925
3926
3927 { "OCZ-VERTEX", "1.30", ATA_HORKAGE_BROKEN_HPA },
3928
3929
3930 { "ST340823A", NULL, ATA_HORKAGE_HPA_SIZE, },
3931 { "ST320413A", NULL, ATA_HORKAGE_HPA_SIZE, },
3932 { "ST310211A", NULL, ATA_HORKAGE_HPA_SIZE, },
3933
3934
3935 { "QUANTUM FIREBALLlct10 05", "A03.0900", ATA_HORKAGE_IVB, },
3936
3937 { "TSSTcorp CDDVDW SH-S202[HJN]", "SB0[01]", ATA_HORKAGE_IVB, },
3938
3939
3940 { "MTRON MSP-SATA*", NULL, ATA_HORKAGE_BRIDGE_OK, },
3941 { "BUFFALO HD-QSU2/R5", NULL, ATA_HORKAGE_BRIDGE_OK, },
3942
3943
3944 { "WD My Book", NULL, ATA_HORKAGE_1_5_GBPS, },
3945 { "Seagate FreeAgent GoFlex", NULL, ATA_HORKAGE_1_5_GBPS, },
3946
3947
3948
3949
3950
3951 { "PIONEER DVD-RW DVRTD08", NULL, ATA_HORKAGE_NOSETXFER },
3952 { "PIONEER DVD-RW DVRTD08A", NULL, ATA_HORKAGE_NOSETXFER },
3953 { "PIONEER DVD-RW DVR-215", NULL, ATA_HORKAGE_NOSETXFER },
3954 { "PIONEER DVD-RW DVR-212D", NULL, ATA_HORKAGE_NOSETXFER },
3955 { "PIONEER DVD-RW DVR-216D", NULL, ATA_HORKAGE_NOSETXFER },
3956
3957
3958 { "CT500BX100SSD1", NULL, ATA_HORKAGE_NOLPM },
3959
3960
3961 { "Crucial_CT512MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3962 ATA_HORKAGE_ZERO_AFTER_TRIM |
3963 ATA_HORKAGE_NOLPM, },
3964
3965 { "Crucial_CT512MX100*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM |
3966 ATA_HORKAGE_NOLPM, },
3967
3968
3969 { "Crucial_CT480M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
3970 ATA_HORKAGE_ZERO_AFTER_TRIM |
3971 ATA_HORKAGE_NOLPM, },
3972 { "Crucial_CT960M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
3973 ATA_HORKAGE_ZERO_AFTER_TRIM |
3974 ATA_HORKAGE_NOLPM, },
3975
3976
3977 { "SAMSUNG MZMPC128HBFU-000MV", "CXM14M1Q", ATA_HORKAGE_NOLPM, },
3978 { "SAMSUNG SSD PM830 mSATA *", "CXM13D1Q", ATA_HORKAGE_NOLPM, },
3979 { "SAMSUNG MZ7TD256HAFV-000L9", NULL, ATA_HORKAGE_NOLPM, },
3980 { "SAMSUNG MZ7TE512HMHP-000L1", "EXT06L0Q", ATA_HORKAGE_NOLPM, },
3981
3982
3983 { "Micron_M500IT_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3984 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3985 { "Micron_M500_*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
3986 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3987 { "Crucial_CT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
3988 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3989 { "Micron_M5[15]0_*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3990 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3991 { "Crucial_CT*M550*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3992 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3993 { "Crucial_CT*MX100*", "MU01", ATA_HORKAGE_NO_NCQ_TRIM |
3994 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3995 { "Samsung SSD 840*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
3996 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3997 { "Samsung SSD 850*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
3998 ATA_HORKAGE_ZERO_AFTER_TRIM, },
3999 { "Samsung SSD 860*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4000 ATA_HORKAGE_ZERO_AFTER_TRIM |
4001 ATA_HORKAGE_NO_NCQ_ON_ATI, },
4002 { "Samsung SSD 870*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4003 ATA_HORKAGE_ZERO_AFTER_TRIM |
4004 ATA_HORKAGE_NO_NCQ_ON_ATI, },
4005 { "FCCT*M500*", NULL, ATA_HORKAGE_NO_NCQ_TRIM |
4006 ATA_HORKAGE_ZERO_AFTER_TRIM, },
4007
4008
4009 { "SuperSSpeed S238*", NULL, ATA_HORKAGE_NOTRIM, },
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027 { "INTEL*SSDSC2MH*", NULL, 0, },
4028
4029 { "Micron*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4030 { "Crucial*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4031 { "INTEL*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4032 { "SSD*INTEL*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4033 { "Samsung*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4034 { "SAMSUNG*SSD*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4035 { "SAMSUNG*MZ7KM*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4036 { "ST[1248][0248]0[FH]*", NULL, ATA_HORKAGE_ZERO_AFTER_TRIM, },
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047 { "WDC WD800JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4048 { "WDC WD1200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4049 { "WDC WD1600JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4050 { "WDC WD2000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4051 { "WDC WD2500JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4052 { "WDC WD3000JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4053 { "WDC WD3200JD-*", NULL, ATA_HORKAGE_WD_BROKEN_LPM },
4054
4055
4056 { }
4057};
4058
4059static unsigned long ata_dev_blacklisted(const struct ata_device *dev)
4060{
4061 unsigned char model_num[ATA_ID_PROD_LEN + 1];
4062 unsigned char model_rev[ATA_ID_FW_REV_LEN + 1];
4063 const struct ata_blacklist_entry *ad = ata_device_blacklist;
4064
4065 ata_id_c_string(dev->id, model_num, ATA_ID_PROD, sizeof(model_num));
4066 ata_id_c_string(dev->id, model_rev, ATA_ID_FW_REV, sizeof(model_rev));
4067
4068 while (ad->model_num) {
4069 if (glob_match(ad->model_num, model_num)) {
4070 if (ad->model_rev == NULL)
4071 return ad->horkage;
4072 if (glob_match(ad->model_rev, model_rev))
4073 return ad->horkage;
4074 }
4075 ad++;
4076 }
4077 return 0;
4078}
4079
4080static int ata_dma_blacklisted(const struct ata_device *dev)
4081{
4082
4083
4084
4085
4086 if ((dev->link->ap->flags & ATA_FLAG_PIO_POLLING) &&
4087 (dev->flags & ATA_DFLAG_CDB_INTR))
4088 return 1;
4089 return (dev->horkage & ATA_HORKAGE_NODMA) ? 1 : 0;
4090}
4091
4092
4093
4094
4095
4096
4097
4098
4099
4100static int ata_is_40wire(struct ata_device *dev)
4101{
4102 if (dev->horkage & ATA_HORKAGE_IVB)
4103 return ata_drive_40wire_relaxed(dev->id);
4104 return ata_drive_40wire(dev->id);
4105}
4106
4107
4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119
4120static int cable_is_40wire(struct ata_port *ap)
4121{
4122 struct ata_link *link;
4123 struct ata_device *dev;
4124
4125
4126 if (ap->cbl == ATA_CBL_PATA40)
4127 return 1;
4128
4129
4130 if (ap->cbl == ATA_CBL_PATA80 || ap->cbl == ATA_CBL_SATA)
4131 return 0;
4132
4133
4134
4135
4136
4137 if (ap->cbl == ATA_CBL_PATA40_SHORT)
4138 return 0;
4139
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149 ata_for_each_link(link, ap, EDGE) {
4150 ata_for_each_dev(dev, link, ENABLED) {
4151 if (!ata_is_40wire(dev))
4152 return 0;
4153 }
4154 }
4155 return 1;
4156}
4157
4158
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169
4170static void ata_dev_xfermask(struct ata_device *dev)
4171{
4172 struct ata_link *link = dev->link;
4173 struct ata_port *ap = link->ap;
4174 struct ata_host *host = ap->host;
4175 unsigned long xfer_mask;
4176
4177
4178 xfer_mask = ata_pack_xfermask(ap->pio_mask,
4179 ap->mwdma_mask, ap->udma_mask);
4180
4181
4182 xfer_mask &= ata_pack_xfermask(dev->pio_mask,
4183 dev->mwdma_mask, dev->udma_mask);
4184 xfer_mask &= ata_id_xfermask(dev->id);
4185
4186
4187
4188
4189
4190 if (ata_dev_pair(dev)) {
4191
4192 xfer_mask &= ~(0x03 << (ATA_SHIFT_PIO + 5));
4193
4194 xfer_mask &= ~(0x03 << (ATA_SHIFT_MWDMA + 3));
4195 }
4196
4197 if (ata_dma_blacklisted(dev)) {
4198 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4199 ata_dev_warn(dev,
4200 "device is on DMA blacklist, disabling DMA\n");
4201 }
4202
4203 if ((host->flags & ATA_HOST_SIMPLEX) &&
4204 host->simplex_claimed && host->simplex_claimed != ap) {
4205 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
4206 ata_dev_warn(dev,
4207 "simplex DMA is claimed by other device, disabling DMA\n");
4208 }
4209
4210 if (ap->flags & ATA_FLAG_NO_IORDY)
4211 xfer_mask &= ata_pio_mask_no_iordy(dev);
4212
4213 if (ap->ops->mode_filter)
4214 xfer_mask = ap->ops->mode_filter(dev, xfer_mask);
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224 if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
4225
4226 if (cable_is_40wire(ap)) {
4227 ata_dev_warn(dev,
4228 "limited to UDMA/33 due to 40-wire cable\n");
4229 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
4230 }
4231
4232 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
4233 &dev->mwdma_mask, &dev->udma_mask);
4234}
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244
4245
4246
4247
4248
4249
4250static unsigned int ata_dev_set_xfermode(struct ata_device *dev)
4251{
4252 struct ata_taskfile tf;
4253 unsigned int err_mask;
4254
4255
4256 DPRINTK("set features - xfer mode\n");
4257
4258
4259
4260
4261 ata_tf_init(dev, &tf);
4262 tf.command = ATA_CMD_SET_FEATURES;
4263 tf.feature = SETFEATURES_XFER;
4264 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE | ATA_TFLAG_POLLING;
4265 tf.protocol = ATA_PROT_NODATA;
4266
4267 if (ata_pio_need_iordy(dev))
4268 tf.nsect = dev->xfer_mode;
4269
4270 else if (ata_id_has_iordy(dev->id))
4271 tf.nsect = 0x01;
4272 else
4273 return 0;
4274
4275
4276 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 15000);
4277
4278 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4279 return err_mask;
4280}
4281
4282
4283
4284
4285
4286
4287
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297unsigned int ata_dev_set_feature(struct ata_device *dev, u8 enable, u8 feature)
4298{
4299 struct ata_taskfile tf;
4300 unsigned int err_mask;
4301 unsigned long timeout = 0;
4302
4303
4304 DPRINTK("set features - SATA features\n");
4305
4306 ata_tf_init(dev, &tf);
4307 tf.command = ATA_CMD_SET_FEATURES;
4308 tf.feature = enable;
4309 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4310 tf.protocol = ATA_PROT_NODATA;
4311 tf.nsect = feature;
4312
4313 if (enable == SETFEATURES_SPINUP)
4314 timeout = ata_probe_timeout ?
4315 ata_probe_timeout * 1000 : SETFEATURES_SPINUP_TIMEOUT;
4316 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, timeout);
4317
4318 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4319 return err_mask;
4320}
4321EXPORT_SYMBOL_GPL(ata_dev_set_feature);
4322
4323
4324
4325
4326
4327
4328
4329
4330
4331
4332
4333
4334
4335static unsigned int ata_dev_init_params(struct ata_device *dev,
4336 u16 heads, u16 sectors)
4337{
4338 struct ata_taskfile tf;
4339 unsigned int err_mask;
4340
4341
4342 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
4343 return AC_ERR_INVALID;
4344
4345
4346 DPRINTK("init dev params \n");
4347
4348 ata_tf_init(dev, &tf);
4349 tf.command = ATA_CMD_INIT_DEV_PARAMS;
4350 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
4351 tf.protocol = ATA_PROT_NODATA;
4352 tf.nsect = sectors;
4353 tf.device |= (heads - 1) & 0x0f;
4354
4355 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
4356
4357
4358
4359 if (err_mask == AC_ERR_DEV && (tf.feature & ATA_ABORTED))
4360 err_mask = 0;
4361
4362 DPRINTK("EXIT, err_mask=%x\n", err_mask);
4363 return err_mask;
4364}
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380int atapi_check_dma(struct ata_queued_cmd *qc)
4381{
4382 struct ata_port *ap = qc->ap;
4383
4384
4385
4386
4387 if (!(qc->dev->horkage & ATA_HORKAGE_ATAPI_MOD16_DMA) &&
4388 unlikely(qc->nbytes & 15))
4389 return 1;
4390
4391 if (ap->ops->check_atapi_dma)
4392 return ap->ops->check_atapi_dma(qc);
4393
4394 return 0;
4395}
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
4411
4412int ata_std_qc_defer(struct ata_queued_cmd *qc)
4413{
4414 struct ata_link *link = qc->dev->link;
4415
4416 if (ata_is_ncq(qc->tf.protocol)) {
4417 if (!ata_tag_valid(link->active_tag))
4418 return 0;
4419 } else {
4420 if (!ata_tag_valid(link->active_tag) && !link->sactive)
4421 return 0;
4422 }
4423
4424 return ATA_DEFER_LINK;
4425}
4426EXPORT_SYMBOL_GPL(ata_std_qc_defer);
4427
4428enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc)
4429{
4430 return AC_ERR_OK;
4431}
4432EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
4433
4434
4435
4436
4437
4438
4439
4440
4441
4442
4443
4444
4445
4446
4447void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
4448 unsigned int n_elem)
4449{
4450 qc->sg = sg;
4451 qc->n_elem = n_elem;
4452 qc->cursg = qc->sg;
4453}
4454
4455#ifdef CONFIG_HAS_DMA
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466static void ata_sg_clean(struct ata_queued_cmd *qc)
4467{
4468 struct ata_port *ap = qc->ap;
4469 struct scatterlist *sg = qc->sg;
4470 int dir = qc->dma_dir;
4471
4472 WARN_ON_ONCE(sg == NULL);
4473
4474 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
4475
4476 if (qc->n_elem)
4477 dma_unmap_sg(ap->dev, sg, qc->orig_n_elem, dir);
4478
4479 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4480 qc->sg = NULL;
4481}
4482
4483
4484
4485
4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496static int ata_sg_setup(struct ata_queued_cmd *qc)
4497{
4498 struct ata_port *ap = qc->ap;
4499 unsigned int n_elem;
4500
4501 VPRINTK("ENTER, ata%u\n", ap->print_id);
4502
4503 n_elem = dma_map_sg(ap->dev, qc->sg, qc->n_elem, qc->dma_dir);
4504 if (n_elem < 1)
4505 return -1;
4506
4507 VPRINTK("%d sg elements mapped\n", n_elem);
4508 qc->orig_n_elem = qc->n_elem;
4509 qc->n_elem = n_elem;
4510 qc->flags |= ATA_QCFLAG_DMAMAP;
4511
4512 return 0;
4513}
4514
4515#else
4516
4517static inline void ata_sg_clean(struct ata_queued_cmd *qc) {}
4518static inline int ata_sg_setup(struct ata_queued_cmd *qc) { return -1; }
4519
4520#endif
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534void swap_buf_le16(u16 *buf, unsigned int buf_words)
4535{
4536#ifdef __BIG_ENDIAN
4537 unsigned int i;
4538
4539 for (i = 0; i < buf_words; i++)
4540 buf[i] = le16_to_cpu(buf[i]);
4541#endif
4542}
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev, int tag)
4554{
4555 struct ata_port *ap = dev->link->ap;
4556 struct ata_queued_cmd *qc;
4557
4558
4559 if (unlikely(ap->pflags & ATA_PFLAG_FROZEN))
4560 return NULL;
4561
4562
4563 if (ap->flags & ATA_FLAG_SAS_HOST) {
4564 tag = ata_sas_allocate_tag(ap);
4565 if (tag < 0)
4566 return NULL;
4567 }
4568
4569 qc = __ata_qc_from_tag(ap, tag);
4570 qc->tag = qc->hw_tag = tag;
4571 qc->scsicmd = NULL;
4572 qc->ap = ap;
4573 qc->dev = dev;
4574
4575 ata_qc_reinit(qc);
4576
4577 return qc;
4578}
4579
4580
4581
4582
4583
4584
4585
4586
4587
4588
4589
4590void ata_qc_free(struct ata_queued_cmd *qc)
4591{
4592 struct ata_port *ap;
4593 unsigned int tag;
4594
4595 WARN_ON_ONCE(qc == NULL);
4596 ap = qc->ap;
4597
4598 qc->flags = 0;
4599 tag = qc->tag;
4600 if (ata_tag_valid(tag)) {
4601 qc->tag = ATA_TAG_POISON;
4602 if (ap->flags & ATA_FLAG_SAS_HOST)
4603 ata_sas_free_tag(tag, ap);
4604 }
4605}
4606
4607void __ata_qc_complete(struct ata_queued_cmd *qc)
4608{
4609 struct ata_port *ap;
4610 struct ata_link *link;
4611
4612 WARN_ON_ONCE(qc == NULL);
4613 WARN_ON_ONCE(!(qc->flags & ATA_QCFLAG_ACTIVE));
4614 ap = qc->ap;
4615 link = qc->dev->link;
4616
4617 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4618 ata_sg_clean(qc);
4619
4620
4621 if (ata_is_ncq(qc->tf.protocol)) {
4622 link->sactive &= ~(1 << qc->hw_tag);
4623 if (!link->sactive)
4624 ap->nr_active_links--;
4625 } else {
4626 link->active_tag = ATA_TAG_POISON;
4627 ap->nr_active_links--;
4628 }
4629
4630
4631 if (unlikely(qc->flags & ATA_QCFLAG_CLEAR_EXCL &&
4632 ap->excl_link == link))
4633 ap->excl_link = NULL;
4634
4635
4636
4637
4638
4639 qc->flags &= ~ATA_QCFLAG_ACTIVE;
4640 ap->qc_active &= ~(1ULL << qc->tag);
4641
4642
4643 qc->complete_fn(qc);
4644}
4645
4646static void fill_result_tf(struct ata_queued_cmd *qc)
4647{
4648 struct ata_port *ap = qc->ap;
4649
4650 qc->result_tf.flags = qc->tf.flags;
4651 ap->ops->qc_fill_rtf(qc);
4652}
4653
4654static void ata_verify_xfer(struct ata_queued_cmd *qc)
4655{
4656 struct ata_device *dev = qc->dev;
4657
4658 if (!ata_is_data(qc->tf.protocol))
4659 return;
4660
4661 if ((dev->mwdma_mask || dev->udma_mask) && ata_is_pio(qc->tf.protocol))
4662 return;
4663
4664 dev->flags &= ~ATA_DFLAG_DUBIOUS_XFER;
4665}
4666
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682void ata_qc_complete(struct ata_queued_cmd *qc)
4683{
4684 struct ata_port *ap = qc->ap;
4685
4686
4687 ledtrig_disk_activity(!!(qc->tf.flags & ATA_TFLAG_WRITE));
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697
4698
4699
4700
4701
4702 if (ap->ops->error_handler) {
4703 struct ata_device *dev = qc->dev;
4704 struct ata_eh_info *ehi = &dev->link->eh_info;
4705
4706 if (unlikely(qc->err_mask))
4707 qc->flags |= ATA_QCFLAG_FAILED;
4708
4709
4710
4711
4712
4713 if (unlikely(ata_tag_internal(qc->tag))) {
4714 fill_result_tf(qc);
4715 trace_ata_qc_complete_internal(qc);
4716 __ata_qc_complete(qc);
4717 return;
4718 }
4719
4720
4721
4722
4723
4724 if (unlikely(qc->flags & ATA_QCFLAG_FAILED)) {
4725 fill_result_tf(qc);
4726 trace_ata_qc_complete_failed(qc);
4727 ata_qc_schedule_eh(qc);
4728 return;
4729 }
4730
4731 WARN_ON_ONCE(ap->pflags & ATA_PFLAG_FROZEN);
4732
4733
4734 if (qc->flags & ATA_QCFLAG_RESULT_TF)
4735 fill_result_tf(qc);
4736
4737 trace_ata_qc_complete_done(qc);
4738
4739
4740
4741 switch (qc->tf.command) {
4742 case ATA_CMD_SET_FEATURES:
4743 if (qc->tf.feature != SETFEATURES_WC_ON &&
4744 qc->tf.feature != SETFEATURES_WC_OFF &&
4745 qc->tf.feature != SETFEATURES_RA_ON &&
4746 qc->tf.feature != SETFEATURES_RA_OFF)
4747 break;
4748 fallthrough;
4749 case ATA_CMD_INIT_DEV_PARAMS:
4750 case ATA_CMD_SET_MULTI:
4751
4752 ehi->dev_action[dev->devno] |= ATA_EH_REVALIDATE;
4753 ata_port_schedule_eh(ap);
4754 break;
4755
4756 case ATA_CMD_SLEEP:
4757 dev->flags |= ATA_DFLAG_SLEEPING;
4758 break;
4759 }
4760
4761 if (unlikely(dev->flags & ATA_DFLAG_DUBIOUS_XFER))
4762 ata_verify_xfer(qc);
4763
4764 __ata_qc_complete(qc);
4765 } else {
4766 if (qc->flags & ATA_QCFLAG_EH_SCHEDULED)
4767 return;
4768
4769
4770 if (qc->err_mask || qc->flags & ATA_QCFLAG_RESULT_TF)
4771 fill_result_tf(qc);
4772
4773 __ata_qc_complete(qc);
4774 }
4775}
4776EXPORT_SYMBOL_GPL(ata_qc_complete);
4777
4778
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788u64 ata_qc_get_active(struct ata_port *ap)
4789{
4790 u64 qc_active = ap->qc_active;
4791
4792
4793 if (qc_active & (1ULL << ATA_TAG_INTERNAL)) {
4794 qc_active |= (1 << 0);
4795 qc_active &= ~(1ULL << ATA_TAG_INTERNAL);
4796 }
4797
4798 return qc_active;
4799}
4800EXPORT_SYMBOL_GPL(ata_qc_get_active);
4801
4802
4803
4804
4805
4806
4807
4808
4809
4810
4811
4812
4813
4814void ata_qc_issue(struct ata_queued_cmd *qc)
4815{
4816 struct ata_port *ap = qc->ap;
4817 struct ata_link *link = qc->dev->link;
4818 u8 prot = qc->tf.protocol;
4819
4820
4821
4822
4823
4824 WARN_ON_ONCE(ap->ops->error_handler && ata_tag_valid(link->active_tag));
4825
4826 if (ata_is_ncq(prot)) {
4827 WARN_ON_ONCE(link->sactive & (1 << qc->hw_tag));
4828
4829 if (!link->sactive)
4830 ap->nr_active_links++;
4831 link->sactive |= 1 << qc->hw_tag;
4832 } else {
4833 WARN_ON_ONCE(link->sactive);
4834
4835 ap->nr_active_links++;
4836 link->active_tag = qc->tag;
4837 }
4838
4839 qc->flags |= ATA_QCFLAG_ACTIVE;
4840 ap->qc_active |= 1ULL << qc->tag;
4841
4842
4843
4844
4845
4846 if (ata_is_data(prot) && (!qc->sg || !qc->n_elem || !qc->nbytes))
4847 goto sys_err;
4848
4849 if (ata_is_dma(prot) || (ata_is_pio(prot) &&
4850 (ap->flags & ATA_FLAG_PIO_DMA)))
4851 if (ata_sg_setup(qc))
4852 goto sys_err;
4853
4854
4855 if (unlikely(qc->dev->flags & ATA_DFLAG_SLEEPING)) {
4856 link->eh_info.action |= ATA_EH_RESET;
4857 ata_ehi_push_desc(&link->eh_info, "waking up from sleep");
4858 ata_link_abort(link);
4859 return;
4860 }
4861
4862 qc->err_mask |= ap->ops->qc_prep(qc);
4863 if (unlikely(qc->err_mask))
4864 goto err;
4865 trace_ata_qc_issue(qc);
4866 qc->err_mask |= ap->ops->qc_issue(qc);
4867 if (unlikely(qc->err_mask))
4868 goto err;
4869 return;
4870
4871sys_err:
4872 qc->err_mask |= AC_ERR_SYSTEM;
4873err:
4874 ata_qc_complete(qc);
4875}
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887
4888
4889
4890
4891bool ata_phys_link_online(struct ata_link *link)
4892{
4893 u32 sstatus;
4894
4895 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
4896 ata_sstatus_online(sstatus))
4897 return true;
4898 return false;
4899}
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915bool ata_phys_link_offline(struct ata_link *link)
4916{
4917 u32 sstatus;
4918
4919 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0 &&
4920 !ata_sstatus_online(sstatus))
4921 return true;
4922 return false;
4923}
4924
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
4937
4938
4939
4940
4941bool ata_link_online(struct ata_link *link)
4942{
4943 struct ata_link *slave = link->ap->slave_link;
4944
4945 WARN_ON(link == slave);
4946
4947 return ata_phys_link_online(link) ||
4948 (slave && ata_phys_link_online(slave));
4949}
4950EXPORT_SYMBOL_GPL(ata_link_online);
4951
4952
4953
4954
4955
4956
4957
4958
4959
4960
4961
4962
4963
4964
4965
4966
4967
4968bool ata_link_offline(struct ata_link *link)
4969{
4970 struct ata_link *slave = link->ap->slave_link;
4971
4972 WARN_ON(link == slave);
4973
4974 return ata_phys_link_offline(link) &&
4975 (!slave || ata_phys_link_offline(slave));
4976}
4977EXPORT_SYMBOL_GPL(ata_link_offline);
4978
4979#ifdef CONFIG_PM
4980static void ata_port_request_pm(struct ata_port *ap, pm_message_t mesg,
4981 unsigned int action, unsigned int ehi_flags,
4982 bool async)
4983{
4984 struct ata_link *link;
4985 unsigned long flags;
4986
4987
4988
4989
4990 if (ap->pflags & ATA_PFLAG_PM_PENDING) {
4991 ata_port_wait_eh(ap);
4992 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
4993 }
4994
4995
4996 spin_lock_irqsave(ap->lock, flags);
4997
4998 ap->pm_mesg = mesg;
4999 ap->pflags |= ATA_PFLAG_PM_PENDING;
5000 ata_for_each_link(link, ap, HOST_FIRST) {
5001 link->eh_info.action |= action;
5002 link->eh_info.flags |= ehi_flags;
5003 }
5004
5005 ata_port_schedule_eh(ap);
5006
5007 spin_unlock_irqrestore(ap->lock, flags);
5008
5009 if (!async) {
5010 ata_port_wait_eh(ap);
5011 WARN_ON(ap->pflags & ATA_PFLAG_PM_PENDING);
5012 }
5013}
5014
5015
5016
5017
5018
5019
5020
5021
5022static const unsigned int ata_port_suspend_ehi = ATA_EHI_QUIET
5023 | ATA_EHI_NO_AUTOPSY
5024 | ATA_EHI_NO_RECOVERY;
5025
5026static void ata_port_suspend(struct ata_port *ap, pm_message_t mesg)
5027{
5028 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, false);
5029}
5030
5031static void ata_port_suspend_async(struct ata_port *ap, pm_message_t mesg)
5032{
5033 ata_port_request_pm(ap, mesg, 0, ata_port_suspend_ehi, true);
5034}
5035
5036static int ata_port_pm_suspend(struct device *dev)
5037{
5038 struct ata_port *ap = to_ata_port(dev);
5039
5040 if (pm_runtime_suspended(dev))
5041 return 0;
5042
5043 ata_port_suspend(ap, PMSG_SUSPEND);
5044 return 0;
5045}
5046
5047static int ata_port_pm_freeze(struct device *dev)
5048{
5049 struct ata_port *ap = to_ata_port(dev);
5050
5051 if (pm_runtime_suspended(dev))
5052 return 0;
5053
5054 ata_port_suspend(ap, PMSG_FREEZE);
5055 return 0;
5056}
5057
5058static int ata_port_pm_poweroff(struct device *dev)
5059{
5060 ata_port_suspend(to_ata_port(dev), PMSG_HIBERNATE);
5061 return 0;
5062}
5063
5064static const unsigned int ata_port_resume_ehi = ATA_EHI_NO_AUTOPSY
5065 | ATA_EHI_QUIET;
5066
5067static void ata_port_resume(struct ata_port *ap, pm_message_t mesg)
5068{
5069 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, false);
5070}
5071
5072static void ata_port_resume_async(struct ata_port *ap, pm_message_t mesg)
5073{
5074 ata_port_request_pm(ap, mesg, ATA_EH_RESET, ata_port_resume_ehi, true);
5075}
5076
5077static int ata_port_pm_resume(struct device *dev)
5078{
5079 ata_port_resume_async(to_ata_port(dev), PMSG_RESUME);
5080 pm_runtime_disable(dev);
5081 pm_runtime_set_active(dev);
5082 pm_runtime_enable(dev);
5083 return 0;
5084}
5085
5086
5087
5088
5089
5090
5091
5092
5093
5094static int ata_port_runtime_idle(struct device *dev)
5095{
5096 struct ata_port *ap = to_ata_port(dev);
5097 struct ata_link *link;
5098 struct ata_device *adev;
5099
5100 ata_for_each_link(link, ap, HOST_FIRST) {
5101 ata_for_each_dev(adev, link, ENABLED)
5102 if (adev->class == ATA_DEV_ATAPI &&
5103 !zpodd_dev_enabled(adev))
5104 return -EBUSY;
5105 }
5106
5107 return 0;
5108}
5109
5110static int ata_port_runtime_suspend(struct device *dev)
5111{
5112 ata_port_suspend(to_ata_port(dev), PMSG_AUTO_SUSPEND);
5113 return 0;
5114}
5115
5116static int ata_port_runtime_resume(struct device *dev)
5117{
5118 ata_port_resume(to_ata_port(dev), PMSG_AUTO_RESUME);
5119 return 0;
5120}
5121
5122static const struct dev_pm_ops ata_port_pm_ops = {
5123 .suspend = ata_port_pm_suspend,
5124 .resume = ata_port_pm_resume,
5125 .freeze = ata_port_pm_freeze,
5126 .thaw = ata_port_pm_resume,
5127 .poweroff = ata_port_pm_poweroff,
5128 .restore = ata_port_pm_resume,
5129
5130 .runtime_suspend = ata_port_runtime_suspend,
5131 .runtime_resume = ata_port_runtime_resume,
5132 .runtime_idle = ata_port_runtime_idle,
5133};
5134
5135
5136
5137
5138
5139
5140void ata_sas_port_suspend(struct ata_port *ap)
5141{
5142 ata_port_suspend_async(ap, PMSG_SUSPEND);
5143}
5144EXPORT_SYMBOL_GPL(ata_sas_port_suspend);
5145
5146void ata_sas_port_resume(struct ata_port *ap)
5147{
5148 ata_port_resume_async(ap, PMSG_RESUME);
5149}
5150EXPORT_SYMBOL_GPL(ata_sas_port_resume);
5151
5152
5153
5154
5155
5156
5157
5158
5159int ata_host_suspend(struct ata_host *host, pm_message_t mesg)
5160{
5161 host->dev->power.power_state = mesg;
5162 return 0;
5163}
5164EXPORT_SYMBOL_GPL(ata_host_suspend);
5165
5166
5167
5168
5169
5170
5171
5172void ata_host_resume(struct ata_host *host)
5173{
5174 host->dev->power.power_state = PMSG_ON;
5175}
5176EXPORT_SYMBOL_GPL(ata_host_resume);
5177#endif
5178
5179const struct device_type ata_port_type = {
5180 .name = "ata_port",
5181#ifdef CONFIG_PM
5182 .pm = &ata_port_pm_ops,
5183#endif
5184};
5185
5186
5187
5188
5189
5190
5191
5192
5193
5194
5195void ata_dev_init(struct ata_device *dev)
5196{
5197 struct ata_link *link = ata_dev_phys_link(dev);
5198 struct ata_port *ap = link->ap;
5199 unsigned long flags;
5200
5201
5202 link->sata_spd_limit = link->hw_sata_spd_limit;
5203 link->sata_spd = 0;
5204
5205
5206
5207
5208
5209 spin_lock_irqsave(ap->lock, flags);
5210 dev->flags &= ~ATA_DFLAG_INIT_MASK;
5211 dev->horkage = 0;
5212 spin_unlock_irqrestore(ap->lock, flags);
5213
5214 memset((void *)dev + ATA_DEVICE_CLEAR_BEGIN, 0,
5215 ATA_DEVICE_CLEAR_END - ATA_DEVICE_CLEAR_BEGIN);
5216 dev->pio_mask = UINT_MAX;
5217 dev->mwdma_mask = UINT_MAX;
5218 dev->udma_mask = UINT_MAX;
5219}
5220
5221
5222
5223
5224
5225
5226
5227
5228
5229
5230
5231
5232void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp)
5233{
5234 int i;
5235
5236
5237 memset((void *)link + ATA_LINK_CLEAR_BEGIN, 0,
5238 ATA_LINK_CLEAR_END - ATA_LINK_CLEAR_BEGIN);
5239
5240 link->ap = ap;
5241 link->pmp = pmp;
5242 link->active_tag = ATA_TAG_POISON;
5243 link->hw_sata_spd_limit = UINT_MAX;
5244
5245
5246 for (i = 0; i < ATA_MAX_DEVICES; i++) {
5247 struct ata_device *dev = &link->device[i];
5248
5249 dev->link = link;
5250 dev->devno = dev - link->device;
5251#ifdef CONFIG_ATA_ACPI
5252 dev->gtf_filter = ata_acpi_gtf_filter;
5253#endif
5254 ata_dev_init(dev);
5255 }
5256}
5257
5258
5259
5260
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271int sata_link_init_spd(struct ata_link *link)
5272{
5273 u8 spd;
5274 int rc;
5275
5276 rc = sata_scr_read(link, SCR_CONTROL, &link->saved_scontrol);
5277 if (rc)
5278 return rc;
5279
5280 spd = (link->saved_scontrol >> 4) & 0xf;
5281 if (spd)
5282 link->hw_sata_spd_limit &= (1 << spd) - 1;
5283
5284 ata_force_link_limits(link);
5285
5286 link->sata_spd_limit = link->hw_sata_spd_limit;
5287
5288 return 0;
5289}
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303struct ata_port *ata_port_alloc(struct ata_host *host)
5304{
5305 struct ata_port *ap;
5306
5307 DPRINTK("ENTER\n");
5308
5309 ap = kzalloc(sizeof(*ap), GFP_KERNEL);
5310 if (!ap)
5311 return NULL;
5312
5313 ap->pflags |= ATA_PFLAG_INITIALIZING | ATA_PFLAG_FROZEN;
5314 ap->lock = &host->lock;
5315 ap->print_id = -1;
5316 ap->local_port_no = -1;
5317 ap->host = host;
5318 ap->dev = host->dev;
5319
5320#if defined(ATA_VERBOSE_DEBUG)
5321
5322 ap->msg_enable = 0x00FF;
5323#elif defined(ATA_DEBUG)
5324 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_INFO | ATA_MSG_CTL | ATA_MSG_WARN | ATA_MSG_ERR;
5325#else
5326 ap->msg_enable = ATA_MSG_DRV | ATA_MSG_ERR | ATA_MSG_WARN;
5327#endif
5328
5329 mutex_init(&ap->scsi_scan_mutex);
5330 INIT_DELAYED_WORK(&ap->hotplug_task, ata_scsi_hotplug);
5331 INIT_WORK(&ap->scsi_rescan_task, ata_scsi_dev_rescan);
5332 INIT_LIST_HEAD(&ap->eh_done_q);
5333 init_waitqueue_head(&ap->eh_wait_q);
5334 init_completion(&ap->park_req_pending);
5335 timer_setup(&ap->fastdrain_timer, ata_eh_fastdrain_timerfn,
5336 TIMER_DEFERRABLE);
5337
5338 ap->cbl = ATA_CBL_NONE;
5339
5340 ata_link_init(ap, &ap->link, 0);
5341
5342#ifdef ATA_IRQ_TRAP
5343 ap->stats.unhandled_irq = 1;
5344 ap->stats.idle_irq = 1;
5345#endif
5346 ata_sff_port_init(ap);
5347
5348 return ap;
5349}
5350
5351static void ata_devres_release(struct device *gendev, void *res)
5352{
5353 struct ata_host *host = dev_get_drvdata(gendev);
5354 int i;
5355
5356 for (i = 0; i < host->n_ports; i++) {
5357 struct ata_port *ap = host->ports[i];
5358
5359 if (!ap)
5360 continue;
5361
5362 if (ap->scsi_host)
5363 scsi_host_put(ap->scsi_host);
5364
5365 }
5366
5367 dev_set_drvdata(gendev, NULL);
5368 ata_host_put(host);
5369}
5370
5371static void ata_host_release(struct kref *kref)
5372{
5373 struct ata_host *host = container_of(kref, struct ata_host, kref);
5374 int i;
5375
5376 for (i = 0; i < host->n_ports; i++) {
5377 struct ata_port *ap = host->ports[i];
5378
5379 kfree(ap->pmp_link);
5380 kfree(ap->slave_link);
5381 kfree(ap);
5382 host->ports[i] = NULL;
5383 }
5384 kfree(host);
5385}
5386
5387void ata_host_get(struct ata_host *host)
5388{
5389 kref_get(&host->kref);
5390}
5391
5392void ata_host_put(struct ata_host *host)
5393{
5394 kref_put(&host->kref, ata_host_release);
5395}
5396EXPORT_SYMBOL_GPL(ata_host_put);
5397
5398
5399
5400
5401
5402
5403
5404
5405
5406
5407
5408
5409
5410
5411
5412
5413
5414
5415
5416
5417
5418struct ata_host *ata_host_alloc(struct device *dev, int max_ports)
5419{
5420 struct ata_host *host;
5421 size_t sz;
5422 int i;
5423 void *dr;
5424
5425 DPRINTK("ENTER\n");
5426
5427
5428 sz = sizeof(struct ata_host) + (max_ports + 1) * sizeof(void *);
5429 host = kzalloc(sz, GFP_KERNEL);
5430 if (!host)
5431 return NULL;
5432
5433 if (!devres_open_group(dev, NULL, GFP_KERNEL))
5434 goto err_free;
5435
5436 dr = devres_alloc(ata_devres_release, 0, GFP_KERNEL);
5437 if (!dr)
5438 goto err_out;
5439
5440 devres_add(dev, dr);
5441 dev_set_drvdata(dev, host);
5442
5443 spin_lock_init(&host->lock);
5444 mutex_init(&host->eh_mutex);
5445 host->dev = dev;
5446 host->n_ports = max_ports;
5447 kref_init(&host->kref);
5448
5449
5450 for (i = 0; i < max_ports; i++) {
5451 struct ata_port *ap;
5452
5453 ap = ata_port_alloc(host);
5454 if (!ap)
5455 goto err_out;
5456
5457 ap->port_no = i;
5458 host->ports[i] = ap;
5459 }
5460
5461 devres_remove_group(dev, NULL);
5462 return host;
5463
5464 err_out:
5465 devres_release_group(dev, NULL);
5466 err_free:
5467 kfree(host);
5468 return NULL;
5469}
5470EXPORT_SYMBOL_GPL(ata_host_alloc);
5471
5472
5473
5474
5475
5476
5477
5478
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488struct ata_host *ata_host_alloc_pinfo(struct device *dev,
5489 const struct ata_port_info * const * ppi,
5490 int n_ports)
5491{
5492 const struct ata_port_info *pi;
5493 struct ata_host *host;
5494 int i, j;
5495
5496 host = ata_host_alloc(dev, n_ports);
5497 if (!host)
5498 return NULL;
5499
5500 for (i = 0, j = 0, pi = NULL; i < host->n_ports; i++) {
5501 struct ata_port *ap = host->ports[i];
5502
5503 if (ppi[j])
5504 pi = ppi[j++];
5505
5506 ap->pio_mask = pi->pio_mask;
5507 ap->mwdma_mask = pi->mwdma_mask;
5508 ap->udma_mask = pi->udma_mask;
5509 ap->flags |= pi->flags;
5510 ap->link.flags |= pi->link_flags;
5511 ap->ops = pi->port_ops;
5512
5513 if (!host->ops && (pi->port_ops != &ata_dummy_port_ops))
5514 host->ops = pi->port_ops;
5515 }
5516
5517 return host;
5518}
5519EXPORT_SYMBOL_GPL(ata_host_alloc_pinfo);
5520
5521static void ata_host_stop(struct device *gendev, void *res)
5522{
5523 struct ata_host *host = dev_get_drvdata(gendev);
5524 int i;
5525
5526 WARN_ON(!(host->flags & ATA_HOST_STARTED));
5527
5528 for (i = 0; i < host->n_ports; i++) {
5529 struct ata_port *ap = host->ports[i];
5530
5531 if (ap->ops->port_stop)
5532 ap->ops->port_stop(ap);
5533 }
5534
5535 if (host->ops->host_stop)
5536 host->ops->host_stop(host);
5537}
5538
5539
5540
5541
5542
5543
5544
5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
5555
5556
5557
5558
5559static void ata_finalize_port_ops(struct ata_port_operations *ops)
5560{
5561 static DEFINE_SPINLOCK(lock);
5562 const struct ata_port_operations *cur;
5563 void **begin = (void **)ops;
5564 void **end = (void **)&ops->inherits;
5565 void **pp;
5566
5567 if (!ops || !ops->inherits)
5568 return;
5569
5570 spin_lock(&lock);
5571
5572 for (cur = ops->inherits; cur; cur = cur->inherits) {
5573 void **inherit = (void **)cur;
5574
5575 for (pp = begin; pp < end; pp++, inherit++)
5576 if (!*pp)
5577 *pp = *inherit;
5578 }
5579
5580 for (pp = begin; pp < end; pp++)
5581 if (IS_ERR(*pp))
5582 *pp = NULL;
5583
5584 ops->inherits = NULL;
5585
5586 spin_unlock(&lock);
5587}
5588
5589
5590
5591
5592
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
5604
5605int ata_host_start(struct ata_host *host)
5606{
5607 int have_stop = 0;
5608 void *start_dr = NULL;
5609 int i, rc;
5610
5611 if (host->flags & ATA_HOST_STARTED)
5612 return 0;
5613
5614 ata_finalize_port_ops(host->ops);
5615
5616 for (i = 0; i < host->n_ports; i++) {
5617 struct ata_port *ap = host->ports[i];
5618
5619 ata_finalize_port_ops(ap->ops);
5620
5621 if (!host->ops && !ata_port_is_dummy(ap))
5622 host->ops = ap->ops;
5623
5624 if (ap->ops->port_stop)
5625 have_stop = 1;
5626 }
5627
5628 if (host->ops && host->ops->host_stop)
5629 have_stop = 1;
5630
5631 if (have_stop) {
5632 start_dr = devres_alloc(ata_host_stop, 0, GFP_KERNEL);
5633 if (!start_dr)
5634 return -ENOMEM;
5635 }
5636
5637 for (i = 0; i < host->n_ports; i++) {
5638 struct ata_port *ap = host->ports[i];
5639
5640 if (ap->ops->port_start) {
5641 rc = ap->ops->port_start(ap);
5642 if (rc) {
5643 if (rc != -ENODEV)
5644 dev_err(host->dev,
5645 "failed to start port %d (errno=%d)\n",
5646 i, rc);
5647 goto err_out;
5648 }
5649 }
5650 ata_eh_freeze_port(ap);
5651 }
5652
5653 if (start_dr)
5654 devres_add(host->dev, start_dr);
5655 host->flags |= ATA_HOST_STARTED;
5656 return 0;
5657
5658 err_out:
5659 while (--i >= 0) {
5660 struct ata_port *ap = host->ports[i];
5661
5662 if (ap->ops->port_stop)
5663 ap->ops->port_stop(ap);
5664 }
5665 devres_free(start_dr);
5666 return rc;
5667}
5668EXPORT_SYMBOL_GPL(ata_host_start);
5669
5670
5671
5672
5673
5674
5675
5676
5677void ata_host_init(struct ata_host *host, struct device *dev,
5678 struct ata_port_operations *ops)
5679{
5680 spin_lock_init(&host->lock);
5681 mutex_init(&host->eh_mutex);
5682 host->n_tags = ATA_MAX_QUEUE;
5683 host->dev = dev;
5684 host->ops = ops;
5685 kref_init(&host->kref);
5686}
5687EXPORT_SYMBOL_GPL(ata_host_init);
5688
5689void __ata_port_probe(struct ata_port *ap)
5690{
5691 struct ata_eh_info *ehi = &ap->link.eh_info;
5692 unsigned long flags;
5693
5694
5695 spin_lock_irqsave(ap->lock, flags);
5696
5697 ehi->probe_mask |= ATA_ALL_DEVICES;
5698 ehi->action |= ATA_EH_RESET;
5699 ehi->flags |= ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET;
5700
5701 ap->pflags &= ~ATA_PFLAG_INITIALIZING;
5702 ap->pflags |= ATA_PFLAG_LOADING;
5703 ata_port_schedule_eh(ap);
5704
5705 spin_unlock_irqrestore(ap->lock, flags);
5706}
5707
5708int ata_port_probe(struct ata_port *ap)
5709{
5710 int rc = 0;
5711
5712 if (ap->ops->error_handler) {
5713 __ata_port_probe(ap);
5714 ata_port_wait_eh(ap);
5715 } else {
5716 DPRINTK("ata%u: bus probe begin\n", ap->print_id);
5717 rc = ata_bus_probe(ap);
5718 DPRINTK("ata%u: bus probe end\n", ap->print_id);
5719 }
5720 return rc;
5721}
5722
5723
5724static void async_port_probe(void *data, async_cookie_t cookie)
5725{
5726 struct ata_port *ap = data;
5727
5728
5729
5730
5731
5732
5733
5734
5735 if (!(ap->host->flags & ATA_HOST_PARALLEL_SCAN) && ap->port_no != 0)
5736 async_synchronize_cookie(cookie);
5737
5738 (void)ata_port_probe(ap);
5739
5740
5741 async_synchronize_cookie(cookie);
5742
5743 ata_scsi_scan_host(ap, 1);
5744}
5745
5746
5747
5748
5749
5750
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762int ata_host_register(struct ata_host *host, struct scsi_host_template *sht)
5763{
5764 int i, rc;
5765
5766 host->n_tags = clamp(sht->can_queue, 1, ATA_MAX_QUEUE);
5767
5768
5769 if (!(host->flags & ATA_HOST_STARTED)) {
5770 dev_err(host->dev, "BUG: trying to register unstarted host\n");
5771 WARN_ON(1);
5772 return -EINVAL;
5773 }
5774
5775
5776
5777
5778
5779 for (i = host->n_ports; host->ports[i]; i++)
5780 kfree(host->ports[i]);
5781
5782
5783 for (i = 0; i < host->n_ports; i++) {
5784 host->ports[i]->print_id = atomic_inc_return(&ata_print_id);
5785 host->ports[i]->local_port_no = i + 1;
5786 }
5787
5788
5789 for (i = 0; i < host->n_ports; i++) {
5790 rc = ata_tport_add(host->dev,host->ports[i]);
5791 if (rc) {
5792 goto err_tadd;
5793 }
5794 }
5795
5796 rc = ata_scsi_add_hosts(host, sht);
5797 if (rc)
5798 goto err_tadd;
5799
5800
5801 for (i = 0; i < host->n_ports; i++) {
5802 struct ata_port *ap = host->ports[i];
5803 unsigned long xfer_mask;
5804
5805
5806 if (ap->cbl == ATA_CBL_NONE && (ap->flags & ATA_FLAG_SATA))
5807 ap->cbl = ATA_CBL_SATA;
5808
5809
5810 sata_link_init_spd(&ap->link);
5811 if (ap->slave_link)
5812 sata_link_init_spd(ap->slave_link);
5813
5814
5815 xfer_mask = ata_pack_xfermask(ap->pio_mask, ap->mwdma_mask,
5816 ap->udma_mask);
5817
5818 if (!ata_port_is_dummy(ap)) {
5819 ata_port_info(ap, "%cATA max %s %s\n",
5820 (ap->flags & ATA_FLAG_SATA) ? 'S' : 'P',
5821 ata_mode_string(xfer_mask),
5822 ap->link.eh_info.desc);
5823 ata_ehi_clear_desc(&ap->link.eh_info);
5824 } else
5825 ata_port_info(ap, "DUMMY\n");
5826 }
5827
5828
5829 for (i = 0; i < host->n_ports; i++) {
5830 struct ata_port *ap = host->ports[i];
5831 ap->cookie = async_schedule(async_port_probe, ap);
5832 }
5833
5834 return 0;
5835
5836 err_tadd:
5837 while (--i >= 0) {
5838 ata_tport_delete(host->ports[i]);
5839 }
5840 return rc;
5841
5842}
5843EXPORT_SYMBOL_GPL(ata_host_register);
5844
5845
5846
5847
5848
5849
5850
5851
5852
5853
5854
5855
5856
5857
5858
5859
5860
5861
5862
5863
5864
5865
5866
5867
5868int ata_host_activate(struct ata_host *host, int irq,
5869 irq_handler_t irq_handler, unsigned long irq_flags,
5870 struct scsi_host_template *sht)
5871{
5872 int i, rc;
5873 char *irq_desc;
5874
5875 rc = ata_host_start(host);
5876 if (rc)
5877 return rc;
5878
5879
5880 if (!irq) {
5881 WARN_ON(irq_handler);
5882 return ata_host_register(host, sht);
5883 }
5884
5885 irq_desc = devm_kasprintf(host->dev, GFP_KERNEL, "%s[%s]",
5886 dev_driver_string(host->dev),
5887 dev_name(host->dev));
5888 if (!irq_desc)
5889 return -ENOMEM;
5890
5891 rc = devm_request_irq(host->dev, irq, irq_handler, irq_flags,
5892 irq_desc, host);
5893 if (rc)
5894 return rc;
5895
5896 for (i = 0; i < host->n_ports; i++)
5897 ata_port_desc(host->ports[i], "irq %d", irq);
5898
5899 rc = ata_host_register(host, sht);
5900
5901 if (rc)
5902 devm_free_irq(host->dev, irq, host);
5903
5904 return rc;
5905}
5906EXPORT_SYMBOL_GPL(ata_host_activate);
5907
5908
5909
5910
5911
5912
5913
5914
5915
5916
5917
5918
5919static void ata_port_detach(struct ata_port *ap)
5920{
5921 unsigned long flags;
5922 struct ata_link *link;
5923 struct ata_device *dev;
5924
5925 if (!ap->ops->error_handler)
5926 goto skip_eh;
5927
5928
5929 spin_lock_irqsave(ap->lock, flags);
5930 ap->pflags |= ATA_PFLAG_UNLOADING;
5931 ata_port_schedule_eh(ap);
5932 spin_unlock_irqrestore(ap->lock, flags);
5933
5934
5935 ata_port_wait_eh(ap);
5936
5937
5938 WARN_ON(!(ap->pflags & ATA_PFLAG_UNLOADED));
5939
5940 cancel_delayed_work_sync(&ap->hotplug_task);
5941
5942 skip_eh:
5943
5944 ata_for_each_link(link, ap, HOST_FIRST) {
5945 ata_for_each_dev(dev, link, ALL) {
5946 if (zpodd_dev_enabled(dev))
5947 zpodd_exit(dev);
5948 }
5949 }
5950 if (ap->pmp_link) {
5951 int i;
5952 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
5953 ata_tlink_delete(&ap->pmp_link[i]);
5954 }
5955
5956 scsi_remove_host(ap->scsi_host);
5957 ata_tport_delete(ap);
5958}
5959
5960
5961
5962
5963
5964
5965
5966
5967
5968
5969void ata_host_detach(struct ata_host *host)
5970{
5971 int i;
5972
5973 for (i = 0; i < host->n_ports; i++) {
5974
5975 async_synchronize_cookie(host->ports[i]->cookie + 1);
5976 ata_port_detach(host->ports[i]);
5977 }
5978
5979
5980 ata_acpi_dissociate(host);
5981}
5982EXPORT_SYMBOL_GPL(ata_host_detach);
5983
5984#ifdef CONFIG_PCI
5985
5986
5987
5988
5989
5990
5991
5992
5993
5994
5995
5996
5997void ata_pci_remove_one(struct pci_dev *pdev)
5998{
5999 struct ata_host *host = pci_get_drvdata(pdev);
6000
6001 ata_host_detach(host);
6002}
6003EXPORT_SYMBOL_GPL(ata_pci_remove_one);
6004
6005void ata_pci_shutdown_one(struct pci_dev *pdev)
6006{
6007 struct ata_host *host = pci_get_drvdata(pdev);
6008 int i;
6009
6010 for (i = 0; i < host->n_ports; i++) {
6011 struct ata_port *ap = host->ports[i];
6012
6013 ap->pflags |= ATA_PFLAG_FROZEN;
6014
6015
6016 if (ap->ops->freeze)
6017 ap->ops->freeze(ap);
6018
6019
6020 if (ap->ops->port_stop)
6021 ap->ops->port_stop(ap);
6022 }
6023}
6024EXPORT_SYMBOL_GPL(ata_pci_shutdown_one);
6025
6026
6027int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
6028{
6029 unsigned long tmp = 0;
6030
6031 switch (bits->width) {
6032 case 1: {
6033 u8 tmp8 = 0;
6034 pci_read_config_byte(pdev, bits->reg, &tmp8);
6035 tmp = tmp8;
6036 break;
6037 }
6038 case 2: {
6039 u16 tmp16 = 0;
6040 pci_read_config_word(pdev, bits->reg, &tmp16);
6041 tmp = tmp16;
6042 break;
6043 }
6044 case 4: {
6045 u32 tmp32 = 0;
6046 pci_read_config_dword(pdev, bits->reg, &tmp32);
6047 tmp = tmp32;
6048 break;
6049 }
6050
6051 default:
6052 return -EINVAL;
6053 }
6054
6055 tmp &= bits->mask;
6056
6057 return (tmp == bits->val) ? 1 : 0;
6058}
6059EXPORT_SYMBOL_GPL(pci_test_config_bits);
6060
6061#ifdef CONFIG_PM
6062void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg)
6063{
6064 pci_save_state(pdev);
6065 pci_disable_device(pdev);
6066
6067 if (mesg.event & PM_EVENT_SLEEP)
6068 pci_set_power_state(pdev, PCI_D3hot);
6069}
6070EXPORT_SYMBOL_GPL(ata_pci_device_do_suspend);
6071
6072int ata_pci_device_do_resume(struct pci_dev *pdev)
6073{
6074 int rc;
6075
6076 pci_set_power_state(pdev, PCI_D0);
6077 pci_restore_state(pdev);
6078
6079 rc = pcim_enable_device(pdev);
6080 if (rc) {
6081 dev_err(&pdev->dev,
6082 "failed to enable device after resume (%d)\n", rc);
6083 return rc;
6084 }
6085
6086 pci_set_master(pdev);
6087 return 0;
6088}
6089EXPORT_SYMBOL_GPL(ata_pci_device_do_resume);
6090
6091int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg)
6092{
6093 struct ata_host *host = pci_get_drvdata(pdev);
6094 int rc = 0;
6095
6096 rc = ata_host_suspend(host, mesg);
6097 if (rc)
6098 return rc;
6099
6100 ata_pci_device_do_suspend(pdev, mesg);
6101
6102 return 0;
6103}
6104EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
6105
6106int ata_pci_device_resume(struct pci_dev *pdev)
6107{
6108 struct ata_host *host = pci_get_drvdata(pdev);
6109 int rc;
6110
6111 rc = ata_pci_device_do_resume(pdev);
6112 if (rc == 0)
6113 ata_host_resume(host);
6114 return rc;
6115}
6116EXPORT_SYMBOL_GPL(ata_pci_device_resume);
6117#endif
6118#endif
6119
6120
6121
6122
6123
6124
6125
6126
6127
6128
6129
6130
6131int ata_platform_remove_one(struct platform_device *pdev)
6132{
6133 struct ata_host *host = platform_get_drvdata(pdev);
6134
6135 ata_host_detach(host);
6136
6137 return 0;
6138}
6139EXPORT_SYMBOL_GPL(ata_platform_remove_one);
6140
6141#ifdef CONFIG_ATA_FORCE
6142static int __init ata_parse_force_one(char **cur,
6143 struct ata_force_ent *force_ent,
6144 const char **reason)
6145{
6146 static const struct ata_force_param force_tbl[] __initconst = {
6147 { "40c", .cbl = ATA_CBL_PATA40 },
6148 { "80c", .cbl = ATA_CBL_PATA80 },
6149 { "short40c", .cbl = ATA_CBL_PATA40_SHORT },
6150 { "unk", .cbl = ATA_CBL_PATA_UNK },
6151 { "ign", .cbl = ATA_CBL_PATA_IGN },
6152 { "sata", .cbl = ATA_CBL_SATA },
6153 { "1.5Gbps", .spd_limit = 1 },
6154 { "3.0Gbps", .spd_limit = 2 },
6155 { "noncq", .horkage_on = ATA_HORKAGE_NONCQ },
6156 { "ncq", .horkage_off = ATA_HORKAGE_NONCQ },
6157 { "noncqtrim", .horkage_on = ATA_HORKAGE_NO_NCQ_TRIM },
6158 { "ncqtrim", .horkage_off = ATA_HORKAGE_NO_NCQ_TRIM },
6159 { "noncqati", .horkage_on = ATA_HORKAGE_NO_NCQ_ON_ATI },
6160 { "ncqati", .horkage_off = ATA_HORKAGE_NO_NCQ_ON_ATI },
6161 { "dump_id", .horkage_on = ATA_HORKAGE_DUMP_ID },
6162 { "pio0", .xfer_mask = 1 << (ATA_SHIFT_PIO + 0) },
6163 { "pio1", .xfer_mask = 1 << (ATA_SHIFT_PIO + 1) },
6164 { "pio2", .xfer_mask = 1 << (ATA_SHIFT_PIO + 2) },
6165 { "pio3", .xfer_mask = 1 << (ATA_SHIFT_PIO + 3) },
6166 { "pio4", .xfer_mask = 1 << (ATA_SHIFT_PIO + 4) },
6167 { "pio5", .xfer_mask = 1 << (ATA_SHIFT_PIO + 5) },
6168 { "pio6", .xfer_mask = 1 << (ATA_SHIFT_PIO + 6) },
6169 { "mwdma0", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 0) },
6170 { "mwdma1", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 1) },
6171 { "mwdma2", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 2) },
6172 { "mwdma3", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 3) },
6173 { "mwdma4", .xfer_mask = 1 << (ATA_SHIFT_MWDMA + 4) },
6174 { "udma0", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6175 { "udma16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6176 { "udma/16", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 0) },
6177 { "udma1", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6178 { "udma25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6179 { "udma/25", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 1) },
6180 { "udma2", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6181 { "udma33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6182 { "udma/33", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 2) },
6183 { "udma3", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6184 { "udma44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6185 { "udma/44", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 3) },
6186 { "udma4", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6187 { "udma66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6188 { "udma/66", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 4) },
6189 { "udma5", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6190 { "udma100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6191 { "udma/100", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 5) },
6192 { "udma6", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6193 { "udma133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6194 { "udma/133", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 6) },
6195 { "udma7", .xfer_mask = 1 << (ATA_SHIFT_UDMA + 7) },
6196 { "nohrst", .lflags = ATA_LFLAG_NO_HRST },
6197 { "nosrst", .lflags = ATA_LFLAG_NO_SRST },
6198 { "norst", .lflags = ATA_LFLAG_NO_HRST | ATA_LFLAG_NO_SRST },
6199 { "rstonce", .lflags = ATA_LFLAG_RST_ONCE },
6200 { "atapi_dmadir", .horkage_on = ATA_HORKAGE_ATAPI_DMADIR },
6201 { "disable", .horkage_on = ATA_HORKAGE_DISABLE },
6202 };
6203 char *start = *cur, *p = *cur;
6204 char *id, *val, *endp;
6205 const struct ata_force_param *match_fp = NULL;
6206 int nr_matches = 0, i;
6207
6208
6209 while (*p != '\0' && *p != ',')
6210 p++;
6211
6212 if (*p == '\0')
6213 *cur = p;
6214 else
6215 *cur = p + 1;
6216
6217 *p = '\0';
6218
6219
6220 p = strchr(start, ':');
6221 if (!p) {
6222 val = strstrip(start);
6223 goto parse_val;
6224 }
6225 *p = '\0';
6226
6227 id = strstrip(start);
6228 val = strstrip(p + 1);
6229
6230
6231 p = strchr(id, '.');
6232 if (p) {
6233 *p++ = '\0';
6234 force_ent->device = simple_strtoul(p, &endp, 10);
6235 if (p == endp || *endp != '\0') {
6236 *reason = "invalid device";
6237 return -EINVAL;
6238 }
6239 }
6240
6241 force_ent->port = simple_strtoul(id, &endp, 10);
6242 if (id == endp || *endp != '\0') {
6243 *reason = "invalid port/link";
6244 return -EINVAL;
6245 }
6246
6247 parse_val:
6248
6249 for (i = 0; i < ARRAY_SIZE(force_tbl); i++) {
6250 const struct ata_force_param *fp = &force_tbl[i];
6251
6252 if (strncasecmp(val, fp->name, strlen(val)))
6253 continue;
6254
6255 nr_matches++;
6256 match_fp = fp;
6257
6258 if (strcasecmp(val, fp->name) == 0) {
6259 nr_matches = 1;
6260 break;
6261 }
6262 }
6263
6264 if (!nr_matches) {
6265 *reason = "unknown value";
6266 return -EINVAL;
6267 }
6268 if (nr_matches > 1) {
6269 *reason = "ambiguous value";
6270 return -EINVAL;
6271 }
6272
6273 force_ent->param = *match_fp;
6274
6275 return 0;
6276}
6277
6278static void __init ata_parse_force_param(void)
6279{
6280 int idx = 0, size = 1;
6281 int last_port = -1, last_device = -1;
6282 char *p, *cur, *next;
6283
6284
6285 for (p = ata_force_param_buf; *p; p++)
6286 if (*p == ',')
6287 size++;
6288
6289 ata_force_tbl = kcalloc(size, sizeof(ata_force_tbl[0]), GFP_KERNEL);
6290 if (!ata_force_tbl) {
6291 printk(KERN_WARNING "ata: failed to extend force table, "
6292 "libata.force ignored\n");
6293 return;
6294 }
6295
6296
6297 for (cur = ata_force_param_buf; *cur != '\0'; cur = next) {
6298 const char *reason = "";
6299 struct ata_force_ent te = { .port = -1, .device = -1 };
6300
6301 next = cur;
6302 if (ata_parse_force_one(&next, &te, &reason)) {
6303 printk(KERN_WARNING "ata: failed to parse force "
6304 "parameter \"%s\" (%s)\n",
6305 cur, reason);
6306 continue;
6307 }
6308
6309 if (te.port == -1) {
6310 te.port = last_port;
6311 te.device = last_device;
6312 }
6313
6314 ata_force_tbl[idx++] = te;
6315
6316 last_port = te.port;
6317 last_device = te.device;
6318 }
6319
6320 ata_force_tbl_size = idx;
6321}
6322
6323static void ata_free_force_param(void)
6324{
6325 kfree(ata_force_tbl);
6326}
6327#else
6328static inline void ata_parse_force_param(void) { }
6329static inline void ata_free_force_param(void) { }
6330#endif
6331
6332static int __init ata_init(void)
6333{
6334 int rc;
6335
6336 ata_parse_force_param();
6337
6338 rc = ata_sff_init();
6339 if (rc) {
6340 ata_free_force_param();
6341 return rc;
6342 }
6343
6344 libata_transport_init();
6345 ata_scsi_transport_template = ata_attach_transport();
6346 if (!ata_scsi_transport_template) {
6347 ata_sff_exit();
6348 rc = -ENOMEM;
6349 goto err_out;
6350 }
6351
6352 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
6353 return 0;
6354
6355err_out:
6356 return rc;
6357}
6358
6359static void __exit ata_exit(void)
6360{
6361 ata_release_transport(ata_scsi_transport_template);
6362 libata_transport_exit();
6363 ata_sff_exit();
6364 ata_free_force_param();
6365}
6366
6367subsys_initcall(ata_init);
6368module_exit(ata_exit);
6369
6370static DEFINE_RATELIMIT_STATE(ratelimit, HZ / 5, 1);
6371
6372int ata_ratelimit(void)
6373{
6374 return __ratelimit(&ratelimit);
6375}
6376EXPORT_SYMBOL_GPL(ata_ratelimit);
6377
6378
6379
6380
6381
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391
6392void ata_msleep(struct ata_port *ap, unsigned int msecs)
6393{
6394 bool owns_eh = ap && ap->host->eh_owner == current;
6395
6396 if (owns_eh)
6397 ata_eh_release(ap);
6398
6399 if (msecs < 20) {
6400 unsigned long usecs = msecs * USEC_PER_MSEC;
6401 usleep_range(usecs, usecs + 50);
6402 } else {
6403 msleep(msecs);
6404 }
6405
6406 if (owns_eh)
6407 ata_eh_acquire(ap);
6408}
6409EXPORT_SYMBOL_GPL(ata_msleep);
6410
6411
6412
6413
6414
6415
6416
6417
6418
6419
6420
6421
6422
6423
6424
6425
6426
6427
6428
6429
6430
6431
6432
6433
6434
6435u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask, u32 val,
6436 unsigned long interval, unsigned long timeout)
6437{
6438 unsigned long deadline;
6439 u32 tmp;
6440
6441 tmp = ioread32(reg);
6442
6443
6444
6445
6446
6447 deadline = ata_deadline(jiffies, timeout);
6448
6449 while ((tmp & mask) == val && time_before(jiffies, deadline)) {
6450 ata_msleep(ap, interval);
6451 tmp = ioread32(reg);
6452 }
6453
6454 return tmp;
6455}
6456EXPORT_SYMBOL_GPL(ata_wait_register);
6457
6458
6459
6460
6461static unsigned int ata_dummy_qc_issue(struct ata_queued_cmd *qc)
6462{
6463 return AC_ERR_SYSTEM;
6464}
6465
6466static void ata_dummy_error_handler(struct ata_port *ap)
6467{
6468
6469}
6470
6471struct ata_port_operations ata_dummy_port_ops = {
6472 .qc_prep = ata_noop_qc_prep,
6473 .qc_issue = ata_dummy_qc_issue,
6474 .error_handler = ata_dummy_error_handler,
6475 .sched_eh = ata_std_sched_eh,
6476 .end_eh = ata_std_end_eh,
6477};
6478EXPORT_SYMBOL_GPL(ata_dummy_port_ops);
6479
6480const struct ata_port_info ata_dummy_port_info = {
6481 .port_ops = &ata_dummy_port_ops,
6482};
6483EXPORT_SYMBOL_GPL(ata_dummy_port_info);
6484
6485
6486
6487
6488void ata_port_printk(const struct ata_port *ap, const char *level,
6489 const char *fmt, ...)
6490{
6491 struct va_format vaf;
6492 va_list args;
6493
6494 va_start(args, fmt);
6495
6496 vaf.fmt = fmt;
6497 vaf.va = &args;
6498
6499 printk("%sata%u: %pV", level, ap->print_id, &vaf);
6500
6501 va_end(args);
6502}
6503EXPORT_SYMBOL(ata_port_printk);
6504
6505void ata_link_printk(const struct ata_link *link, const char *level,
6506 const char *fmt, ...)
6507{
6508 struct va_format vaf;
6509 va_list args;
6510
6511 va_start(args, fmt);
6512
6513 vaf.fmt = fmt;
6514 vaf.va = &args;
6515
6516 if (sata_pmp_attached(link->ap) || link->ap->slave_link)
6517 printk("%sata%u.%02u: %pV",
6518 level, link->ap->print_id, link->pmp, &vaf);
6519 else
6520 printk("%sata%u: %pV",
6521 level, link->ap->print_id, &vaf);
6522
6523 va_end(args);
6524}
6525EXPORT_SYMBOL(ata_link_printk);
6526
6527void ata_dev_printk(const struct ata_device *dev, const char *level,
6528 const char *fmt, ...)
6529{
6530 struct va_format vaf;
6531 va_list args;
6532
6533 va_start(args, fmt);
6534
6535 vaf.fmt = fmt;
6536 vaf.va = &args;
6537
6538 printk("%sata%u.%02u: %pV",
6539 level, dev->link->ap->print_id, dev->link->pmp + dev->devno,
6540 &vaf);
6541
6542 va_end(args);
6543}
6544EXPORT_SYMBOL(ata_dev_printk);
6545
6546void ata_print_version(const struct device *dev, const char *version)
6547{
6548 dev_printk(KERN_DEBUG, dev, "version %s\n", version);
6549}
6550EXPORT_SYMBOL(ata_print_version);
6551