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