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
29
30
31
32
33
34
35#include <linux/kernel.h>
36#include <linux/blkdev.h>
37#include <linux/export.h>
38#include <linux/pci.h>
39#include <scsi/scsi.h>
40#include <scsi/scsi_host.h>
41#include <scsi/scsi_eh.h>
42#include <scsi/scsi_device.h>
43#include <scsi/scsi_cmnd.h>
44#include <scsi/scsi_dbg.h>
45#include "../scsi/scsi_transport_api.h"
46
47#include <linux/libata.h>
48
49#include <trace/events/libata.h>
50#include "libata.h"
51
52enum {
53
54 ATA_EH_SPDN_NCQ_OFF = (1 << 0),
55 ATA_EH_SPDN_SPEED_DOWN = (1 << 1),
56 ATA_EH_SPDN_FALLBACK_TO_PIO = (1 << 2),
57 ATA_EH_SPDN_KEEP_ERRORS = (1 << 3),
58
59
60 ATA_EFLAG_IS_IO = (1 << 0),
61 ATA_EFLAG_DUBIOUS_XFER = (1 << 1),
62 ATA_EFLAG_OLD_ER = (1 << 31),
63
64
65 ATA_ECAT_NONE = 0,
66 ATA_ECAT_ATA_BUS = 1,
67 ATA_ECAT_TOUT_HSM = 2,
68 ATA_ECAT_UNK_DEV = 3,
69 ATA_ECAT_DUBIOUS_NONE = 4,
70 ATA_ECAT_DUBIOUS_ATA_BUS = 5,
71 ATA_ECAT_DUBIOUS_TOUT_HSM = 6,
72 ATA_ECAT_DUBIOUS_UNK_DEV = 7,
73 ATA_ECAT_NR = 8,
74
75 ATA_EH_CMD_DFL_TIMEOUT = 5000,
76
77
78 ATA_EH_RESET_COOL_DOWN = 5000,
79
80
81
82
83
84
85 ATA_EH_PRERESET_TIMEOUT = 10000,
86 ATA_EH_FASTDRAIN_INTERVAL = 3000,
87
88 ATA_EH_UA_TRIES = 5,
89
90
91 ATA_EH_PROBE_TRIAL_INTERVAL = 60000,
92 ATA_EH_PROBE_TRIALS = 2,
93};
94
95
96
97
98
99
100
101
102static const unsigned long ata_eh_reset_timeouts[] = {
103 10000,
104 10000,
105 35000,
106 5000,
107 ULONG_MAX,
108};
109
110static const unsigned long ata_eh_identify_timeouts[] = {
111 5000,
112 10000,
113 30000,
114 ULONG_MAX,
115};
116
117static const unsigned long ata_eh_flush_timeouts[] = {
118 15000,
119 15000,
120 30000,
121 ULONG_MAX,
122};
123
124static const unsigned long ata_eh_other_timeouts[] = {
125 5000,
126 10000,
127
128 ULONG_MAX,
129};
130
131struct ata_eh_cmd_timeout_ent {
132 const u8 *commands;
133 const unsigned long *timeouts;
134};
135
136
137
138
139
140
141
142
143
144
145
146
147
148#define CMDS(cmds...) (const u8 []){ cmds, 0 }
149static const struct ata_eh_cmd_timeout_ent
150ata_eh_cmd_timeout_table[ATA_EH_CMD_TIMEOUT_TABLE_SIZE] = {
151 { .commands = CMDS(ATA_CMD_ID_ATA, ATA_CMD_ID_ATAPI),
152 .timeouts = ata_eh_identify_timeouts, },
153 { .commands = CMDS(ATA_CMD_READ_NATIVE_MAX, ATA_CMD_READ_NATIVE_MAX_EXT),
154 .timeouts = ata_eh_other_timeouts, },
155 { .commands = CMDS(ATA_CMD_SET_MAX, ATA_CMD_SET_MAX_EXT),
156 .timeouts = ata_eh_other_timeouts, },
157 { .commands = CMDS(ATA_CMD_SET_FEATURES),
158 .timeouts = ata_eh_other_timeouts, },
159 { .commands = CMDS(ATA_CMD_INIT_DEV_PARAMS),
160 .timeouts = ata_eh_other_timeouts, },
161 { .commands = CMDS(ATA_CMD_FLUSH, ATA_CMD_FLUSH_EXT),
162 .timeouts = ata_eh_flush_timeouts },
163};
164#undef CMDS
165
166static void __ata_port_freeze(struct ata_port *ap);
167#ifdef CONFIG_PM
168static void ata_eh_handle_port_suspend(struct ata_port *ap);
169static void ata_eh_handle_port_resume(struct ata_port *ap);
170#else
171static void ata_eh_handle_port_suspend(struct ata_port *ap)
172{ }
173
174static void ata_eh_handle_port_resume(struct ata_port *ap)
175{ }
176#endif
177
178static void __ata_ehi_pushv_desc(struct ata_eh_info *ehi, const char *fmt,
179 va_list args)
180{
181 ehi->desc_len += vscnprintf(ehi->desc + ehi->desc_len,
182 ATA_EH_DESC_LEN - ehi->desc_len,
183 fmt, args);
184}
185
186
187
188
189
190
191
192
193
194
195
196void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
197{
198 va_list args;
199
200 va_start(args, fmt);
201 __ata_ehi_pushv_desc(ehi, fmt, args);
202 va_end(args);
203}
204
205
206
207
208
209
210
211
212
213
214
215
216void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...)
217{
218 va_list args;
219
220 if (ehi->desc_len)
221 __ata_ehi_push_desc(ehi, ", ");
222
223 va_start(args, fmt);
224 __ata_ehi_pushv_desc(ehi, fmt, args);
225 va_end(args);
226}
227
228
229
230
231
232
233
234
235
236
237void ata_ehi_clear_desc(struct ata_eh_info *ehi)
238{
239 ehi->desc[0] = '\0';
240 ehi->desc_len = 0;
241}
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256void ata_port_desc(struct ata_port *ap, const char *fmt, ...)
257{
258 va_list args;
259
260 WARN_ON(!(ap->pflags & ATA_PFLAG_INITIALIZING));
261
262 if (ap->link.eh_info.desc_len)
263 __ata_ehi_push_desc(&ap->link.eh_info, " ");
264
265 va_start(args, fmt);
266 __ata_ehi_pushv_desc(&ap->link.eh_info, fmt, args);
267 va_end(args);
268}
269
270#ifdef CONFIG_PCI
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
288 const char *name)
289{
290 struct pci_dev *pdev = to_pci_dev(ap->host->dev);
291 char *type = "";
292 unsigned long long start, len;
293
294 if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM)
295 type = "m";
296 else if (pci_resource_flags(pdev, bar) & IORESOURCE_IO)
297 type = "i";
298
299 start = (unsigned long long)pci_resource_start(pdev, bar);
300 len = (unsigned long long)pci_resource_len(pdev, bar);
301
302 if (offset < 0)
303 ata_port_desc(ap, "%s %s%llu@0x%llx", name, type, len, start);
304 else
305 ata_port_desc(ap, "%s 0x%llx", name,
306 start + (unsigned long long)offset);
307}
308
309#endif
310
311static int ata_lookup_timeout_table(u8 cmd)
312{
313 int i;
314
315 for (i = 0; i < ATA_EH_CMD_TIMEOUT_TABLE_SIZE; i++) {
316 const u8 *cur;
317
318 for (cur = ata_eh_cmd_timeout_table[i].commands; *cur; cur++)
319 if (*cur == cmd)
320 return i;
321 }
322
323 return -1;
324}
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd)
340{
341 struct ata_eh_context *ehc = &dev->link->eh_context;
342 int ent = ata_lookup_timeout_table(cmd);
343 int idx;
344
345 if (ent < 0)
346 return ATA_EH_CMD_DFL_TIMEOUT;
347
348 idx = ehc->cmd_timeout_idx[dev->devno][ent];
349 return ata_eh_cmd_timeout_table[ent].timeouts[idx];
350}
351
352
353
354
355
356
357
358
359
360
361
362
363
364void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd)
365{
366 struct ata_eh_context *ehc = &dev->link->eh_context;
367 int ent = ata_lookup_timeout_table(cmd);
368 int idx;
369
370 if (ent < 0)
371 return;
372
373 idx = ehc->cmd_timeout_idx[dev->devno][ent];
374 if (ata_eh_cmd_timeout_table[ent].timeouts[idx + 1] != ULONG_MAX)
375 ehc->cmd_timeout_idx[dev->devno][ent]++;
376}
377
378static void ata_ering_record(struct ata_ering *ering, unsigned int eflags,
379 unsigned int err_mask)
380{
381 struct ata_ering_entry *ent;
382
383 WARN_ON(!err_mask);
384
385 ering->cursor++;
386 ering->cursor %= ATA_ERING_SIZE;
387
388 ent = &ering->ring[ering->cursor];
389 ent->eflags = eflags;
390 ent->err_mask = err_mask;
391 ent->timestamp = get_jiffies_64();
392}
393
394static struct ata_ering_entry *ata_ering_top(struct ata_ering *ering)
395{
396 struct ata_ering_entry *ent = &ering->ring[ering->cursor];
397
398 if (ent->err_mask)
399 return ent;
400 return NULL;
401}
402
403int ata_ering_map(struct ata_ering *ering,
404 int (*map_fn)(struct ata_ering_entry *, void *),
405 void *arg)
406{
407 int idx, rc = 0;
408 struct ata_ering_entry *ent;
409
410 idx = ering->cursor;
411 do {
412 ent = &ering->ring[idx];
413 if (!ent->err_mask)
414 break;
415 rc = map_fn(ent, arg);
416 if (rc)
417 break;
418 idx = (idx - 1 + ATA_ERING_SIZE) % ATA_ERING_SIZE;
419 } while (idx != ering->cursor);
420
421 return rc;
422}
423
424static int ata_ering_clear_cb(struct ata_ering_entry *ent, void *void_arg)
425{
426 ent->eflags |= ATA_EFLAG_OLD_ER;
427 return 0;
428}
429
430static void ata_ering_clear(struct ata_ering *ering)
431{
432 ata_ering_map(ering, ata_ering_clear_cb, NULL);
433}
434
435static unsigned int ata_eh_dev_action(struct ata_device *dev)
436{
437 struct ata_eh_context *ehc = &dev->link->eh_context;
438
439 return ehc->i.action | ehc->i.dev_action[dev->devno];
440}
441
442static void ata_eh_clear_action(struct ata_link *link, struct ata_device *dev,
443 struct ata_eh_info *ehi, unsigned int action)
444{
445 struct ata_device *tdev;
446
447 if (!dev) {
448 ehi->action &= ~action;
449 ata_for_each_dev(tdev, link, ALL)
450 ehi->dev_action[tdev->devno] &= ~action;
451 } else {
452
453 WARN_ON(!(action & ATA_EH_PERDEV_MASK));
454
455
456 if (ehi->action & action) {
457 ata_for_each_dev(tdev, link, ALL)
458 ehi->dev_action[tdev->devno] |=
459 ehi->action & action;
460 ehi->action &= ~action;
461 }
462
463
464 ehi->dev_action[dev->devno] &= ~action;
465 }
466}
467
468
469
470
471
472
473
474
475
476
477
478
479void ata_eh_acquire(struct ata_port *ap)
480{
481 mutex_lock(&ap->host->eh_mutex);
482 WARN_ON_ONCE(ap->host->eh_owner);
483 ap->host->eh_owner = current;
484}
485
486
487
488
489
490
491
492
493
494
495
496void ata_eh_release(struct ata_port *ap)
497{
498 WARN_ON_ONCE(ap->host->eh_owner != current);
499 ap->host->eh_owner = NULL;
500 mutex_unlock(&ap->host->eh_mutex);
501}
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
523{
524 struct Scsi_Host *host = cmd->device->host;
525 struct ata_port *ap = ata_shost_to_port(host);
526 unsigned long flags;
527 struct ata_queued_cmd *qc;
528 enum blk_eh_timer_return ret;
529
530 DPRINTK("ENTER\n");
531
532 if (ap->ops->error_handler) {
533 ret = BLK_EH_NOT_HANDLED;
534 goto out;
535 }
536
537 ret = BLK_EH_HANDLED;
538 spin_lock_irqsave(ap->lock, flags);
539 qc = ata_qc_from_tag(ap, ap->link.active_tag);
540 if (qc) {
541 WARN_ON(qc->scsicmd != cmd);
542 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
543 qc->err_mask |= AC_ERR_TIMEOUT;
544 ret = BLK_EH_NOT_HANDLED;
545 }
546 spin_unlock_irqrestore(ap->lock, flags);
547
548 out:
549 DPRINTK("EXIT, ret=%d\n", ret);
550 return ret;
551}
552
553static void ata_eh_unload(struct ata_port *ap)
554{
555 struct ata_link *link;
556 struct ata_device *dev;
557 unsigned long flags;
558
559
560
561
562 ata_for_each_link(link, ap, PMP_FIRST) {
563 sata_scr_write(link, SCR_CONTROL, link->saved_scontrol & 0xff0);
564 ata_for_each_dev(dev, link, ALL)
565 ata_dev_disable(dev);
566 }
567
568
569 spin_lock_irqsave(ap->lock, flags);
570
571 ata_port_freeze(ap);
572 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
573 ap->pflags |= ATA_PFLAG_UNLOADED;
574
575 spin_unlock_irqrestore(ap->lock, flags);
576}
577
578
579
580
581
582
583
584
585
586
587
588
589
590void ata_scsi_error(struct Scsi_Host *host)
591{
592 struct ata_port *ap = ata_shost_to_port(host);
593 unsigned long flags;
594 LIST_HEAD(eh_work_q);
595
596 DPRINTK("ENTER\n");
597
598 spin_lock_irqsave(host->host_lock, flags);
599 list_splice_init(&host->eh_cmd_q, &eh_work_q);
600 spin_unlock_irqrestore(host->host_lock, flags);
601
602 ata_scsi_cmd_error_handler(host, ap, &eh_work_q);
603
604
605
606 ata_scsi_port_error_handler(host, ap);
607
608
609 WARN_ON(!list_empty(&eh_work_q));
610
611 DPRINTK("EXIT\n");
612}
613
614
615
616
617
618
619
620
621
622
623
624void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap,
625 struct list_head *eh_work_q)
626{
627 int i;
628 unsigned long flags;
629
630
631 ata_sff_flush_pio_task(ap);
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647 if (ap->ops->error_handler) {
648 struct scsi_cmnd *scmd, *tmp;
649 int nr_timedout = 0;
650
651 spin_lock_irqsave(ap->lock, flags);
652
653
654
655
656
657
658
659
660
661
662 if (ap->ops->lost_interrupt)
663 ap->ops->lost_interrupt(ap);
664
665 list_for_each_entry_safe(scmd, tmp, eh_work_q, eh_entry) {
666 struct ata_queued_cmd *qc;
667
668 for (i = 0; i < ATA_MAX_QUEUE; i++) {
669 qc = __ata_qc_from_tag(ap, i);
670 if (qc->flags & ATA_QCFLAG_ACTIVE &&
671 qc->scsicmd == scmd)
672 break;
673 }
674
675 if (i < ATA_MAX_QUEUE) {
676
677 if (!(qc->flags & ATA_QCFLAG_FAILED)) {
678
679 qc->err_mask |= AC_ERR_TIMEOUT;
680 qc->flags |= ATA_QCFLAG_FAILED;
681 nr_timedout++;
682 }
683 } else {
684
685
686
687
688 scmd->retries = scmd->allowed;
689 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
690 }
691 }
692
693
694
695
696
697
698
699 if (nr_timedout)
700 __ata_port_freeze(ap);
701
702 spin_unlock_irqrestore(ap->lock, flags);
703
704
705 ap->eh_tries = ATA_EH_MAX_TRIES;
706 } else
707 spin_unlock_wait(ap->lock);
708
709}
710EXPORT_SYMBOL(ata_scsi_cmd_error_handler);
711
712
713
714
715
716
717
718
719
720void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap)
721{
722 unsigned long flags;
723
724
725 if (ap->ops->error_handler) {
726 struct ata_link *link;
727
728
729 ata_eh_acquire(ap);
730 repeat:
731
732 del_timer_sync(&ap->fastdrain_timer);
733
734
735 ata_eh_handle_port_resume(ap);
736
737
738 spin_lock_irqsave(ap->lock, flags);
739
740 ata_for_each_link(link, ap, HOST_FIRST) {
741 struct ata_eh_context *ehc = &link->eh_context;
742 struct ata_device *dev;
743
744 memset(&link->eh_context, 0, sizeof(link->eh_context));
745 link->eh_context.i = link->eh_info;
746 memset(&link->eh_info, 0, sizeof(link->eh_info));
747
748 ata_for_each_dev(dev, link, ENABLED) {
749 int devno = dev->devno;
750
751 ehc->saved_xfer_mode[devno] = dev->xfer_mode;
752 if (ata_ncq_enabled(dev))
753 ehc->saved_ncq_enabled |= 1 << devno;
754 }
755 }
756
757 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
758 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
759 ap->excl_link = NULL;
760
761 spin_unlock_irqrestore(ap->lock, flags);
762
763
764 if (!(ap->pflags & (ATA_PFLAG_UNLOADING | ATA_PFLAG_SUSPENDED)))
765 ap->ops->error_handler(ap);
766 else {
767
768 if ((ap->pflags & ATA_PFLAG_UNLOADING) &&
769 !(ap->pflags & ATA_PFLAG_UNLOADED))
770 ata_eh_unload(ap);
771 ata_eh_finish(ap);
772 }
773
774
775 ata_eh_handle_port_suspend(ap);
776
777
778
779
780
781 spin_lock_irqsave(ap->lock, flags);
782
783 if (ap->pflags & ATA_PFLAG_EH_PENDING) {
784 if (--ap->eh_tries) {
785 spin_unlock_irqrestore(ap->lock, flags);
786 goto repeat;
787 }
788 ata_port_err(ap,
789 "EH pending after %d tries, giving up\n",
790 ATA_EH_MAX_TRIES);
791 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
792 }
793
794
795 ata_for_each_link(link, ap, HOST_FIRST)
796 memset(&link->eh_info, 0, sizeof(link->eh_info));
797
798
799
800
801
802
803 ap->ops->end_eh(ap);
804
805 spin_unlock_irqrestore(ap->lock, flags);
806 ata_eh_release(ap);
807 } else {
808 WARN_ON(ata_qc_from_tag(ap, ap->link.active_tag) == NULL);
809 ap->ops->eng_timeout(ap);
810 }
811
812 scsi_eh_flush_done_q(&ap->eh_done_q);
813
814
815 spin_lock_irqsave(ap->lock, flags);
816
817 if (ap->pflags & ATA_PFLAG_LOADING)
818 ap->pflags &= ~ATA_PFLAG_LOADING;
819 else if (ap->pflags & ATA_PFLAG_SCSI_HOTPLUG)
820 schedule_delayed_work(&ap->hotplug_task, 0);
821
822 if (ap->pflags & ATA_PFLAG_RECOVERED)
823 ata_port_info(ap, "EH complete\n");
824
825 ap->pflags &= ~(ATA_PFLAG_SCSI_HOTPLUG | ATA_PFLAG_RECOVERED);
826
827
828 ap->pflags &= ~ATA_PFLAG_EH_IN_PROGRESS;
829 wake_up_all(&ap->eh_wait_q);
830
831 spin_unlock_irqrestore(ap->lock, flags);
832}
833EXPORT_SYMBOL_GPL(ata_scsi_port_error_handler);
834
835
836
837
838
839
840
841
842
843
844void ata_port_wait_eh(struct ata_port *ap)
845{
846 unsigned long flags;
847 DEFINE_WAIT(wait);
848
849 retry:
850 spin_lock_irqsave(ap->lock, flags);
851
852 while (ap->pflags & (ATA_PFLAG_EH_PENDING | ATA_PFLAG_EH_IN_PROGRESS)) {
853 prepare_to_wait(&ap->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE);
854 spin_unlock_irqrestore(ap->lock, flags);
855 schedule();
856 spin_lock_irqsave(ap->lock, flags);
857 }
858 finish_wait(&ap->eh_wait_q, &wait);
859
860 spin_unlock_irqrestore(ap->lock, flags);
861
862
863 if (scsi_host_in_recovery(ap->scsi_host)) {
864 ata_msleep(ap, 10);
865 goto retry;
866 }
867}
868EXPORT_SYMBOL_GPL(ata_port_wait_eh);
869
870static int ata_eh_nr_in_flight(struct ata_port *ap)
871{
872 unsigned int tag;
873 int nr = 0;
874
875
876 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++)
877 if (ata_qc_from_tag(ap, tag))
878 nr++;
879
880 return nr;
881}
882
883void ata_eh_fastdrain_timerfn(unsigned long arg)
884{
885 struct ata_port *ap = (void *)arg;
886 unsigned long flags;
887 int cnt;
888
889 spin_lock_irqsave(ap->lock, flags);
890
891 cnt = ata_eh_nr_in_flight(ap);
892
893
894 if (!cnt)
895 goto out_unlock;
896
897 if (cnt == ap->fastdrain_cnt) {
898 unsigned int tag;
899
900
901
902
903 for (tag = 0; tag < ATA_MAX_QUEUE - 1; tag++) {
904 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
905 if (qc)
906 qc->err_mask |= AC_ERR_TIMEOUT;
907 }
908
909 ata_port_freeze(ap);
910 } else {
911
912 ap->fastdrain_cnt = cnt;
913 ap->fastdrain_timer.expires =
914 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
915 add_timer(&ap->fastdrain_timer);
916 }
917
918 out_unlock:
919 spin_unlock_irqrestore(ap->lock, flags);
920}
921
922
923
924
925
926
927
928
929
930
931
932
933
934static void ata_eh_set_pending(struct ata_port *ap, int fastdrain)
935{
936 int cnt;
937
938
939 if (ap->pflags & ATA_PFLAG_EH_PENDING)
940 return;
941
942 ap->pflags |= ATA_PFLAG_EH_PENDING;
943
944 if (!fastdrain)
945 return;
946
947
948 cnt = ata_eh_nr_in_flight(ap);
949 if (!cnt)
950 return;
951
952
953 ap->fastdrain_cnt = cnt;
954 ap->fastdrain_timer.expires =
955 ata_deadline(jiffies, ATA_EH_FASTDRAIN_INTERVAL);
956 add_timer(&ap->fastdrain_timer);
957}
958
959
960
961
962
963
964
965
966
967
968
969void ata_qc_schedule_eh(struct ata_queued_cmd *qc)
970{
971 struct ata_port *ap = qc->ap;
972 struct request_queue *q = qc->scsicmd->device->request_queue;
973 unsigned long flags;
974
975 WARN_ON(!ap->ops->error_handler);
976
977 qc->flags |= ATA_QCFLAG_FAILED;
978 ata_eh_set_pending(ap, 1);
979
980
981
982
983
984
985 spin_lock_irqsave(q->queue_lock, flags);
986 blk_abort_request(qc->scsicmd->request);
987 spin_unlock_irqrestore(q->queue_lock, flags);
988}
989
990
991
992
993
994
995
996
997void ata_std_sched_eh(struct ata_port *ap)
998{
999 WARN_ON(!ap->ops->error_handler);
1000
1001 if (ap->pflags & ATA_PFLAG_INITIALIZING)
1002 return;
1003
1004 ata_eh_set_pending(ap, 1);
1005 scsi_schedule_eh(ap->scsi_host);
1006
1007 DPRINTK("port EH scheduled\n");
1008}
1009EXPORT_SYMBOL_GPL(ata_std_sched_eh);
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023void ata_std_end_eh(struct ata_port *ap)
1024{
1025 struct Scsi_Host *host = ap->scsi_host;
1026
1027 host->host_eh_scheduled = 0;
1028}
1029EXPORT_SYMBOL(ata_std_end_eh);
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042void ata_port_schedule_eh(struct ata_port *ap)
1043{
1044
1045 ap->ops->sched_eh(ap);
1046}
1047
1048static int ata_do_link_abort(struct ata_port *ap, struct ata_link *link)
1049{
1050 int tag, nr_aborted = 0;
1051
1052 WARN_ON(!ap->ops->error_handler);
1053
1054
1055 ata_eh_set_pending(ap, 0);
1056
1057 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1058 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, tag);
1059
1060 if (qc && (!link || qc->dev->link == link)) {
1061 qc->flags |= ATA_QCFLAG_FAILED;
1062 ata_qc_complete(qc);
1063 nr_aborted++;
1064 }
1065 }
1066
1067 if (!nr_aborted)
1068 ata_port_schedule_eh(ap);
1069
1070 return nr_aborted;
1071}
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085int ata_link_abort(struct ata_link *link)
1086{
1087 return ata_do_link_abort(link->ap, link);
1088}
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102int ata_port_abort(struct ata_port *ap)
1103{
1104 return ata_do_link_abort(ap, NULL);
1105}
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125static void __ata_port_freeze(struct ata_port *ap)
1126{
1127 WARN_ON(!ap->ops->error_handler);
1128
1129 if (ap->ops->freeze)
1130 ap->ops->freeze(ap);
1131
1132 ap->pflags |= ATA_PFLAG_FROZEN;
1133
1134 DPRINTK("ata%u port frozen\n", ap->print_id);
1135}
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151int ata_port_freeze(struct ata_port *ap)
1152{
1153 int nr_aborted;
1154
1155 WARN_ON(!ap->ops->error_handler);
1156
1157 __ata_port_freeze(ap);
1158 nr_aborted = ata_port_abort(ap);
1159
1160 return nr_aborted;
1161}
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176int sata_async_notification(struct ata_port *ap)
1177{
1178 u32 sntf;
1179 int rc;
1180
1181 if (!(ap->flags & ATA_FLAG_AN))
1182 return 0;
1183
1184 rc = sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf);
1185 if (rc == 0)
1186 sata_scr_write(&ap->link, SCR_NOTIFICATION, sntf);
1187
1188 if (!sata_pmp_attached(ap) || rc) {
1189
1190 if (!sata_pmp_attached(ap)) {
1191
1192
1193
1194
1195 struct ata_device *dev = ap->link.device;
1196
1197 if ((dev->class == ATA_DEV_ATAPI) &&
1198 (dev->flags & ATA_DFLAG_AN))
1199 ata_scsi_media_change_notify(dev);
1200 return 0;
1201 } else {
1202
1203
1204
1205
1206
1207 ata_port_schedule_eh(ap);
1208 return 1;
1209 }
1210 } else {
1211
1212 struct ata_link *link;
1213
1214
1215 ata_for_each_link(link, ap, EDGE) {
1216 if (!(sntf & (1 << link->pmp)))
1217 continue;
1218
1219 if ((link->device->class == ATA_DEV_ATAPI) &&
1220 (link->device->flags & ATA_DFLAG_AN))
1221 ata_scsi_media_change_notify(link->device);
1222 }
1223
1224
1225
1226
1227 if (sntf & (1 << SATA_PMP_CTRL_PORT)) {
1228 ata_port_schedule_eh(ap);
1229 return 1;
1230 }
1231
1232 return 0;
1233 }
1234}
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245void ata_eh_freeze_port(struct ata_port *ap)
1246{
1247 unsigned long flags;
1248
1249 if (!ap->ops->error_handler)
1250 return;
1251
1252 spin_lock_irqsave(ap->lock, flags);
1253 __ata_port_freeze(ap);
1254 spin_unlock_irqrestore(ap->lock, flags);
1255}
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266void ata_eh_thaw_port(struct ata_port *ap)
1267{
1268 unsigned long flags;
1269
1270 if (!ap->ops->error_handler)
1271 return;
1272
1273 spin_lock_irqsave(ap->lock, flags);
1274
1275 ap->pflags &= ~ATA_PFLAG_FROZEN;
1276
1277 if (ap->ops->thaw)
1278 ap->ops->thaw(ap);
1279
1280 spin_unlock_irqrestore(ap->lock, flags);
1281
1282 DPRINTK("ata%u port thawed\n", ap->print_id);
1283}
1284
1285static void ata_eh_scsidone(struct scsi_cmnd *scmd)
1286{
1287
1288}
1289
1290static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
1291{
1292 struct ata_port *ap = qc->ap;
1293 struct scsi_cmnd *scmd = qc->scsicmd;
1294 unsigned long flags;
1295
1296 spin_lock_irqsave(ap->lock, flags);
1297 qc->scsidone = ata_eh_scsidone;
1298 __ata_qc_complete(qc);
1299 WARN_ON(ata_tag_valid(qc->tag));
1300 spin_unlock_irqrestore(ap->lock, flags);
1301
1302 scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
1303}
1304
1305
1306
1307
1308
1309
1310
1311
1312void ata_eh_qc_complete(struct ata_queued_cmd *qc)
1313{
1314 struct scsi_cmnd *scmd = qc->scsicmd;
1315 scmd->retries = scmd->allowed;
1316 __ata_eh_qc_complete(qc);
1317}
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330void ata_eh_qc_retry(struct ata_queued_cmd *qc)
1331{
1332 struct scsi_cmnd *scmd = qc->scsicmd;
1333 if (!qc->err_mask)
1334 scmd->allowed++;
1335 __ata_eh_qc_complete(qc);
1336}
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347void ata_dev_disable(struct ata_device *dev)
1348{
1349 if (!ata_dev_enabled(dev))
1350 return;
1351
1352 if (ata_msg_drv(dev->link->ap))
1353 ata_dev_warn(dev, "disabled\n");
1354 ata_acpi_on_disable(dev);
1355 ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO0 | ATA_DNXFER_QUIET);
1356 dev->class++;
1357
1358
1359
1360
1361 ata_ering_clear(&dev->ering);
1362}
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373void ata_eh_detach_dev(struct ata_device *dev)
1374{
1375 struct ata_link *link = dev->link;
1376 struct ata_port *ap = link->ap;
1377 struct ata_eh_context *ehc = &link->eh_context;
1378 unsigned long flags;
1379
1380 ata_dev_disable(dev);
1381
1382 spin_lock_irqsave(ap->lock, flags);
1383
1384 dev->flags &= ~ATA_DFLAG_DETACH;
1385
1386 if (ata_scsi_offline_dev(dev)) {
1387 dev->flags |= ATA_DFLAG_DETACHED;
1388 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
1389 }
1390
1391
1392 ata_eh_clear_action(link, dev, &link->eh_info, ATA_EH_PERDEV_MASK);
1393 ata_eh_clear_action(link, dev, &link->eh_context.i, ATA_EH_PERDEV_MASK);
1394 ehc->saved_xfer_mode[dev->devno] = 0;
1395 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
1396
1397 spin_unlock_irqrestore(ap->lock, flags);
1398}
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
1414 unsigned int action)
1415{
1416 struct ata_port *ap = link->ap;
1417 struct ata_eh_info *ehi = &link->eh_info;
1418 struct ata_eh_context *ehc = &link->eh_context;
1419 unsigned long flags;
1420
1421 spin_lock_irqsave(ap->lock, flags);
1422
1423 ata_eh_clear_action(link, dev, ehi, action);
1424
1425
1426
1427
1428 if (!(ehc->i.flags & ATA_EHI_QUIET) && link != ap->slave_link)
1429 ap->pflags |= ATA_PFLAG_RECOVERED;
1430
1431 spin_unlock_irqrestore(ap->lock, flags);
1432}
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446void ata_eh_done(struct ata_link *link, struct ata_device *dev,
1447 unsigned int action)
1448{
1449 struct ata_eh_context *ehc = &link->eh_context;
1450
1451 ata_eh_clear_action(link, dev, &ehc->i, action);
1452}
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468static const char *ata_err_string(unsigned int err_mask)
1469{
1470 if (err_mask & AC_ERR_HOST_BUS)
1471 return "host bus error";
1472 if (err_mask & AC_ERR_ATA_BUS)
1473 return "ATA bus error";
1474 if (err_mask & AC_ERR_TIMEOUT)
1475 return "timeout";
1476 if (err_mask & AC_ERR_HSM)
1477 return "HSM violation";
1478 if (err_mask & AC_ERR_SYSTEM)
1479 return "internal error";
1480 if (err_mask & AC_ERR_MEDIA)
1481 return "media error";
1482 if (err_mask & AC_ERR_INVALID)
1483 return "invalid argument";
1484 if (err_mask & AC_ERR_DEV)
1485 return "device error";
1486 return "unknown error";
1487}
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505unsigned int ata_read_log_page(struct ata_device *dev, u8 log,
1506 u8 page, void *buf, unsigned int sectors)
1507{
1508 unsigned long ap_flags = dev->link->ap->flags;
1509 struct ata_taskfile tf;
1510 unsigned int err_mask;
1511 bool dma = false;
1512
1513 DPRINTK("read log page - log 0x%x, page 0x%x\n", log, page);
1514
1515
1516
1517
1518
1519 if (ap_flags & ATA_FLAG_NO_LOG_PAGE)
1520 return AC_ERR_DEV;
1521
1522retry:
1523 ata_tf_init(dev, &tf);
1524 if (dev->dma_mode && ata_id_has_read_log_dma_ext(dev->id) &&
1525 !(dev->horkage & ATA_HORKAGE_NO_NCQ_LOG)) {
1526 tf.command = ATA_CMD_READ_LOG_DMA_EXT;
1527 tf.protocol = ATA_PROT_DMA;
1528 dma = true;
1529 } else {
1530 tf.command = ATA_CMD_READ_LOG_EXT;
1531 tf.protocol = ATA_PROT_PIO;
1532 dma = false;
1533 }
1534 tf.lbal = log;
1535 tf.lbam = page;
1536 tf.nsect = sectors;
1537 tf.hob_nsect = sectors >> 8;
1538 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_LBA48 | ATA_TFLAG_DEVICE;
1539
1540 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_FROM_DEVICE,
1541 buf, sectors * ATA_SECT_SIZE, 0);
1542
1543 if (err_mask && dma) {
1544 dev->horkage |= ATA_HORKAGE_NO_NCQ_LOG;
1545 ata_dev_warn(dev, "READ LOG DMA EXT failed, trying unqueued\n");
1546 goto retry;
1547 }
1548
1549 DPRINTK("EXIT, err_mask=%x\n", err_mask);
1550 return err_mask;
1551}
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568static int ata_eh_read_log_10h(struct ata_device *dev,
1569 int *tag, struct ata_taskfile *tf)
1570{
1571 u8 *buf = dev->link->ap->sector_buf;
1572 unsigned int err_mask;
1573 u8 csum;
1574 int i;
1575
1576 err_mask = ata_read_log_page(dev, ATA_LOG_SATA_NCQ, 0, buf, 1);
1577 if (err_mask)
1578 return -EIO;
1579
1580 csum = 0;
1581 for (i = 0; i < ATA_SECT_SIZE; i++)
1582 csum += buf[i];
1583 if (csum)
1584 ata_dev_warn(dev, "invalid checksum 0x%x on log page 10h\n",
1585 csum);
1586
1587 if (buf[0] & 0x80)
1588 return -ENOENT;
1589
1590 *tag = buf[0] & 0x1f;
1591
1592 tf->command = buf[2];
1593 tf->feature = buf[3];
1594 tf->lbal = buf[4];
1595 tf->lbam = buf[5];
1596 tf->lbah = buf[6];
1597 tf->device = buf[7];
1598 tf->hob_lbal = buf[8];
1599 tf->hob_lbam = buf[9];
1600 tf->hob_lbah = buf[10];
1601 tf->nsect = buf[12];
1602 tf->hob_nsect = buf[13];
1603 if (ata_id_has_ncq_autosense(dev->id))
1604 tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16];
1605
1606 return 0;
1607}
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
1623{
1624 u8 cdb[ATAPI_CDB_LEN] = { TEST_UNIT_READY, 0, 0, 0, 0, 0 };
1625 struct ata_taskfile tf;
1626 unsigned int err_mask;
1627
1628 ata_tf_init(dev, &tf);
1629
1630 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1631 tf.command = ATA_CMD_PACKET;
1632 tf.protocol = ATAPI_PROT_NODATA;
1633
1634 err_mask = ata_exec_internal(dev, &tf, cdb, DMA_NONE, NULL, 0, 0);
1635 if (err_mask == AC_ERR_DEV)
1636 *r_sense_key = tf.feature >> 4;
1637 return err_mask;
1638}
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651static void ata_eh_request_sense(struct ata_queued_cmd *qc,
1652 struct scsi_cmnd *cmd)
1653{
1654 struct ata_device *dev = qc->dev;
1655 struct ata_taskfile tf;
1656 unsigned int err_mask;
1657
1658 if (qc->ap->pflags & ATA_PFLAG_FROZEN) {
1659 ata_dev_warn(dev, "sense data available but port frozen\n");
1660 return;
1661 }
1662
1663 if (!cmd || qc->flags & ATA_QCFLAG_SENSE_VALID)
1664 return;
1665
1666 if (!ata_id_sense_reporting_enabled(dev->id)) {
1667 ata_dev_warn(qc->dev, "sense data reporting disabled\n");
1668 return;
1669 }
1670
1671 DPRINTK("ATA request sense\n");
1672
1673 ata_tf_init(dev, &tf);
1674 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1675 tf.flags |= ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1676 tf.command = ATA_CMD_REQ_SENSE_DATA;
1677 tf.protocol = ATA_PROT_NODATA;
1678
1679 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
1680
1681 if (tf.command & ATA_SENSE) {
1682 ata_scsi_set_sense(dev, cmd, tf.lbah, tf.lbam, tf.lbal);
1683 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1684 } else {
1685 ata_dev_warn(dev, "request sense failed stat %02x emask %x\n",
1686 tf.command, err_mask);
1687 }
1688}
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705unsigned int atapi_eh_request_sense(struct ata_device *dev,
1706 u8 *sense_buf, u8 dfl_sense_key)
1707{
1708 u8 cdb[ATAPI_CDB_LEN] =
1709 { REQUEST_SENSE, 0, 0, 0, SCSI_SENSE_BUFFERSIZE, 0 };
1710 struct ata_port *ap = dev->link->ap;
1711 struct ata_taskfile tf;
1712
1713 DPRINTK("ATAPI request sense\n");
1714
1715 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
1716
1717
1718
1719
1720 sense_buf[0] = 0x70;
1721 sense_buf[2] = dfl_sense_key;
1722
1723
1724 ata_tf_init(dev, &tf);
1725
1726 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1727 tf.command = ATA_CMD_PACKET;
1728
1729
1730 if (ap->flags & ATA_FLAG_PIO_DMA) {
1731 tf.protocol = ATAPI_PROT_DMA;
1732 tf.feature |= ATAPI_PKT_DMA;
1733 } else {
1734 tf.protocol = ATAPI_PROT_PIO;
1735 tf.lbam = SCSI_SENSE_BUFFERSIZE;
1736 tf.lbah = 0;
1737 }
1738
1739 return ata_exec_internal(dev, &tf, cdb, DMA_FROM_DEVICE,
1740 sense_buf, SCSI_SENSE_BUFFERSIZE, 0);
1741}
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753static void ata_eh_analyze_serror(struct ata_link *link)
1754{
1755 struct ata_eh_context *ehc = &link->eh_context;
1756 u32 serror = ehc->i.serror;
1757 unsigned int err_mask = 0, action = 0;
1758 u32 hotplug_mask;
1759
1760 if (serror & (SERR_PERSISTENT | SERR_DATA)) {
1761 err_mask |= AC_ERR_ATA_BUS;
1762 action |= ATA_EH_RESET;
1763 }
1764 if (serror & SERR_PROTOCOL) {
1765 err_mask |= AC_ERR_HSM;
1766 action |= ATA_EH_RESET;
1767 }
1768 if (serror & SERR_INTERNAL) {
1769 err_mask |= AC_ERR_SYSTEM;
1770 action |= ATA_EH_RESET;
1771 }
1772
1773
1774
1775
1776
1777
1778 if (link->lpm_policy > ATA_LPM_MAX_POWER)
1779 hotplug_mask = 0;
1780 else if (!(link->flags & ATA_LFLAG_DISABLED) || ata_is_host_link(link))
1781 hotplug_mask = SERR_PHYRDY_CHG | SERR_DEV_XCHG;
1782 else
1783 hotplug_mask = SERR_PHYRDY_CHG;
1784
1785 if (serror & hotplug_mask)
1786 ata_ehi_hotplugged(&ehc->i);
1787
1788 ehc->i.err_mask |= err_mask;
1789 ehc->i.action |= action;
1790}
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804void ata_eh_analyze_ncq_error(struct ata_link *link)
1805{
1806 struct ata_port *ap = link->ap;
1807 struct ata_eh_context *ehc = &link->eh_context;
1808 struct ata_device *dev = link->device;
1809 struct ata_queued_cmd *qc;
1810 struct ata_taskfile tf;
1811 int tag, rc;
1812
1813
1814 if (ap->pflags & ATA_PFLAG_FROZEN)
1815 return;
1816
1817
1818 if (!link->sactive || !(ehc->i.err_mask & AC_ERR_DEV))
1819 return;
1820
1821
1822 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
1823 qc = __ata_qc_from_tag(ap, tag);
1824
1825 if (!(qc->flags & ATA_QCFLAG_FAILED))
1826 continue;
1827
1828 if (qc->err_mask)
1829 return;
1830 }
1831
1832
1833 memset(&tf, 0, sizeof(tf));
1834 rc = ata_eh_read_log_10h(dev, &tag, &tf);
1835 if (rc) {
1836 ata_link_err(link, "failed to read log page 10h (errno=%d)\n",
1837 rc);
1838 return;
1839 }
1840
1841 if (!(link->sactive & (1 << tag))) {
1842 ata_link_err(link, "log page 10h reported inactive tag %d\n",
1843 tag);
1844 return;
1845 }
1846
1847
1848 qc = __ata_qc_from_tag(ap, tag);
1849 memcpy(&qc->result_tf, &tf, sizeof(tf));
1850 qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
1851 qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
1852 if ((qc->result_tf.command & ATA_SENSE) || qc->result_tf.auxiliary) {
1853 char sense_key, asc, ascq;
1854
1855 sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
1856 asc = (qc->result_tf.auxiliary >> 8) & 0xff;
1857 ascq = qc->result_tf.auxiliary & 0xff;
1858 ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc, ascq);
1859 ata_scsi_set_sense_information(dev, qc->scsicmd,
1860 &qc->result_tf);
1861 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1862 }
1863
1864 ehc->i.err_mask &= ~AC_ERR_DEV;
1865}
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
1883 const struct ata_taskfile *tf)
1884{
1885 unsigned int tmp, action = 0;
1886 u8 stat = tf->command, err = tf->feature;
1887
1888 if ((stat & (ATA_BUSY | ATA_DRQ | ATA_DRDY)) != ATA_DRDY) {
1889 qc->err_mask |= AC_ERR_HSM;
1890 return ATA_EH_RESET;
1891 }
1892
1893 if (stat & (ATA_ERR | ATA_DF)) {
1894 qc->err_mask |= AC_ERR_DEV;
1895
1896
1897
1898
1899 if (stat & ATA_DF)
1900 stat &= ~ATA_SENSE;
1901 } else {
1902 return 0;
1903 }
1904
1905 switch (qc->dev->class) {
1906 case ATA_DEV_ATA:
1907 case ATA_DEV_ZAC:
1908 if (stat & ATA_SENSE)
1909 ata_eh_request_sense(qc, qc->scsicmd);
1910 if (err & ATA_ICRC)
1911 qc->err_mask |= AC_ERR_ATA_BUS;
1912 if (err & (ATA_UNC | ATA_AMNF))
1913 qc->err_mask |= AC_ERR_MEDIA;
1914 if (err & ATA_IDNF)
1915 qc->err_mask |= AC_ERR_INVALID;
1916 break;
1917
1918 case ATA_DEV_ATAPI:
1919 if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
1920 tmp = atapi_eh_request_sense(qc->dev,
1921 qc->scsicmd->sense_buffer,
1922 qc->result_tf.feature >> 4);
1923 if (!tmp)
1924 qc->flags |= ATA_QCFLAG_SENSE_VALID;
1925 else
1926 qc->err_mask |= tmp;
1927 }
1928 }
1929
1930 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
1931 int ret = scsi_check_sense(qc->scsicmd);
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941 if (ret == NEEDS_RETRY || ret == ADD_TO_MLQUEUE) {
1942 qc->flags |= ATA_QCFLAG_RETRY;
1943 qc->err_mask |= AC_ERR_OTHER;
1944 } else if (ret != SUCCESS) {
1945 qc->err_mask |= AC_ERR_HSM;
1946 }
1947 }
1948 if (qc->err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT | AC_ERR_ATA_BUS))
1949 action |= ATA_EH_RESET;
1950
1951 return action;
1952}
1953
1954static int ata_eh_categorize_error(unsigned int eflags, unsigned int err_mask,
1955 int *xfer_ok)
1956{
1957 int base = 0;
1958
1959 if (!(eflags & ATA_EFLAG_DUBIOUS_XFER))
1960 *xfer_ok = 1;
1961
1962 if (!*xfer_ok)
1963 base = ATA_ECAT_DUBIOUS_NONE;
1964
1965 if (err_mask & AC_ERR_ATA_BUS)
1966 return base + ATA_ECAT_ATA_BUS;
1967
1968 if (err_mask & AC_ERR_TIMEOUT)
1969 return base + ATA_ECAT_TOUT_HSM;
1970
1971 if (eflags & ATA_EFLAG_IS_IO) {
1972 if (err_mask & AC_ERR_HSM)
1973 return base + ATA_ECAT_TOUT_HSM;
1974 if ((err_mask &
1975 (AC_ERR_DEV|AC_ERR_MEDIA|AC_ERR_INVALID)) == AC_ERR_DEV)
1976 return base + ATA_ECAT_UNK_DEV;
1977 }
1978
1979 return 0;
1980}
1981
1982struct speed_down_verdict_arg {
1983 u64 since;
1984 int xfer_ok;
1985 int nr_errors[ATA_ECAT_NR];
1986};
1987
1988static int speed_down_verdict_cb(struct ata_ering_entry *ent, void *void_arg)
1989{
1990 struct speed_down_verdict_arg *arg = void_arg;
1991 int cat;
1992
1993 if ((ent->eflags & ATA_EFLAG_OLD_ER) || (ent->timestamp < arg->since))
1994 return -1;
1995
1996 cat = ata_eh_categorize_error(ent->eflags, ent->err_mask,
1997 &arg->xfer_ok);
1998 arg->nr_errors[cat]++;
1999
2000 return 0;
2001}
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060static unsigned int ata_eh_speed_down_verdict(struct ata_device *dev)
2061{
2062 const u64 j5mins = 5LLU * 60 * HZ, j10mins = 10LLU * 60 * HZ;
2063 u64 j64 = get_jiffies_64();
2064 struct speed_down_verdict_arg arg;
2065 unsigned int verdict = 0;
2066
2067
2068 memset(&arg, 0, sizeof(arg));
2069 arg.since = j64 - min(j64, j5mins);
2070 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
2071
2072 if (arg.nr_errors[ATA_ECAT_DUBIOUS_ATA_BUS] +
2073 arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] > 1)
2074 verdict |= ATA_EH_SPDN_SPEED_DOWN |
2075 ATA_EH_SPDN_FALLBACK_TO_PIO | ATA_EH_SPDN_KEEP_ERRORS;
2076
2077 if (arg.nr_errors[ATA_ECAT_DUBIOUS_TOUT_HSM] +
2078 arg.nr_errors[ATA_ECAT_DUBIOUS_UNK_DEV] > 1)
2079 verdict |= ATA_EH_SPDN_NCQ_OFF | ATA_EH_SPDN_KEEP_ERRORS;
2080
2081 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
2082 arg.nr_errors[ATA_ECAT_TOUT_HSM] +
2083 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
2084 verdict |= ATA_EH_SPDN_FALLBACK_TO_PIO;
2085
2086
2087 memset(&arg, 0, sizeof(arg));
2088 arg.since = j64 - min(j64, j10mins);
2089 ata_ering_map(&dev->ering, speed_down_verdict_cb, &arg);
2090
2091 if (arg.nr_errors[ATA_ECAT_TOUT_HSM] +
2092 arg.nr_errors[ATA_ECAT_UNK_DEV] > 3)
2093 verdict |= ATA_EH_SPDN_NCQ_OFF;
2094
2095 if (arg.nr_errors[ATA_ECAT_ATA_BUS] +
2096 arg.nr_errors[ATA_ECAT_TOUT_HSM] > 3 ||
2097 arg.nr_errors[ATA_ECAT_UNK_DEV] > 6)
2098 verdict |= ATA_EH_SPDN_SPEED_DOWN;
2099
2100 return verdict;
2101}
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120static unsigned int ata_eh_speed_down(struct ata_device *dev,
2121 unsigned int eflags, unsigned int err_mask)
2122{
2123 struct ata_link *link = ata_dev_phys_link(dev);
2124 int xfer_ok = 0;
2125 unsigned int verdict;
2126 unsigned int action = 0;
2127
2128
2129 if (ata_eh_categorize_error(eflags, err_mask, &xfer_ok) == 0)
2130 return 0;
2131
2132
2133 ata_ering_record(&dev->ering, eflags, err_mask);
2134 verdict = ata_eh_speed_down_verdict(dev);
2135
2136
2137 if ((verdict & ATA_EH_SPDN_NCQ_OFF) &&
2138 (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ |
2139 ATA_DFLAG_NCQ_OFF)) == ATA_DFLAG_NCQ) {
2140 dev->flags |= ATA_DFLAG_NCQ_OFF;
2141 ata_dev_warn(dev, "NCQ disabled due to excessive errors\n");
2142 goto done;
2143 }
2144
2145
2146 if (verdict & ATA_EH_SPDN_SPEED_DOWN) {
2147
2148 if (sata_down_spd_limit(link, 0) == 0) {
2149 action |= ATA_EH_RESET;
2150 goto done;
2151 }
2152
2153
2154 if (dev->spdn_cnt < 2) {
2155 static const int dma_dnxfer_sel[] =
2156 { ATA_DNXFER_DMA, ATA_DNXFER_40C };
2157 static const int pio_dnxfer_sel[] =
2158 { ATA_DNXFER_PIO, ATA_DNXFER_FORCE_PIO0 };
2159 int sel;
2160
2161 if (dev->xfer_shift != ATA_SHIFT_PIO)
2162 sel = dma_dnxfer_sel[dev->spdn_cnt];
2163 else
2164 sel = pio_dnxfer_sel[dev->spdn_cnt];
2165
2166 dev->spdn_cnt++;
2167
2168 if (ata_down_xfermask_limit(dev, sel) == 0) {
2169 action |= ATA_EH_RESET;
2170 goto done;
2171 }
2172 }
2173 }
2174
2175
2176
2177
2178 if ((verdict & ATA_EH_SPDN_FALLBACK_TO_PIO) && (dev->spdn_cnt >= 2) &&
2179 (link->ap->cbl != ATA_CBL_SATA || dev->class == ATA_DEV_ATAPI) &&
2180 (dev->xfer_shift != ATA_SHIFT_PIO)) {
2181 if (ata_down_xfermask_limit(dev, ATA_DNXFER_FORCE_PIO) == 0) {
2182 dev->spdn_cnt = 0;
2183 action |= ATA_EH_RESET;
2184 goto done;
2185 }
2186 }
2187
2188 return 0;
2189 done:
2190
2191 if (!(verdict & ATA_EH_SPDN_KEEP_ERRORS))
2192 ata_ering_clear(&dev->ering);
2193 return action;
2194}
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205static inline int ata_eh_worth_retry(struct ata_queued_cmd *qc)
2206{
2207 if (qc->err_mask & AC_ERR_MEDIA)
2208 return 0;
2209 if (qc->flags & ATA_QCFLAG_IO)
2210 return 1;
2211 if (qc->err_mask & AC_ERR_INVALID)
2212 return 0;
2213 return qc->err_mask != AC_ERR_DEV;
2214}
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227static void ata_eh_link_autopsy(struct ata_link *link)
2228{
2229 struct ata_port *ap = link->ap;
2230 struct ata_eh_context *ehc = &link->eh_context;
2231 struct ata_device *dev;
2232 unsigned int all_err_mask = 0, eflags = 0;
2233 int tag;
2234 u32 serror;
2235 int rc;
2236
2237 DPRINTK("ENTER\n");
2238
2239 if (ehc->i.flags & ATA_EHI_NO_AUTOPSY)
2240 return;
2241
2242
2243 rc = sata_scr_read(link, SCR_ERROR, &serror);
2244 if (rc == 0) {
2245 ehc->i.serror |= serror;
2246 ata_eh_analyze_serror(link);
2247 } else if (rc != -EOPNOTSUPP) {
2248
2249 ehc->i.probe_mask |= ATA_ALL_DEVICES;
2250 ehc->i.action |= ATA_EH_RESET;
2251 ehc->i.err_mask |= AC_ERR_OTHER;
2252 }
2253
2254
2255 ata_eh_analyze_ncq_error(link);
2256
2257
2258 if (ehc->i.err_mask & ~AC_ERR_OTHER)
2259 ehc->i.err_mask &= ~AC_ERR_OTHER;
2260
2261 all_err_mask |= ehc->i.err_mask;
2262
2263 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2264 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2265
2266 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2267 ata_dev_phys_link(qc->dev) != link)
2268 continue;
2269
2270
2271 qc->err_mask |= ehc->i.err_mask;
2272
2273
2274 ehc->i.action |= ata_eh_analyze_tf(qc, &qc->result_tf);
2275
2276
2277 if (qc->err_mask & AC_ERR_ATA_BUS)
2278 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_MEDIA |
2279 AC_ERR_INVALID);
2280
2281
2282 if (qc->err_mask & ~AC_ERR_OTHER)
2283 qc->err_mask &= ~AC_ERR_OTHER;
2284
2285
2286 if (qc->flags & ATA_QCFLAG_SENSE_VALID)
2287 qc->err_mask &= ~(AC_ERR_DEV | AC_ERR_OTHER);
2288
2289
2290 if (ata_eh_worth_retry(qc))
2291 qc->flags |= ATA_QCFLAG_RETRY;
2292
2293
2294 ehc->i.dev = qc->dev;
2295 all_err_mask |= qc->err_mask;
2296 if (qc->flags & ATA_QCFLAG_IO)
2297 eflags |= ATA_EFLAG_IS_IO;
2298 trace_ata_eh_link_autopsy_qc(qc);
2299 }
2300
2301
2302 if (ap->pflags & ATA_PFLAG_FROZEN ||
2303 all_err_mask & (AC_ERR_HSM | AC_ERR_TIMEOUT))
2304 ehc->i.action |= ATA_EH_RESET;
2305 else if (((eflags & ATA_EFLAG_IS_IO) && all_err_mask) ||
2306 (!(eflags & ATA_EFLAG_IS_IO) && (all_err_mask & ~AC_ERR_DEV)))
2307 ehc->i.action |= ATA_EH_REVALIDATE;
2308
2309
2310
2311
2312 if (ehc->i.dev) {
2313 ehc->i.dev_action[ehc->i.dev->devno] |=
2314 ehc->i.action & ATA_EH_PERDEV_MASK;
2315 ehc->i.action &= ~ATA_EH_PERDEV_MASK;
2316 }
2317
2318
2319 if ((all_err_mask & AC_ERR_TIMEOUT) && !ata_is_host_link(link))
2320 ap->link.eh_context.i.err_mask |= AC_ERR_TIMEOUT;
2321
2322
2323 dev = ehc->i.dev;
2324 if (!dev && ((ata_link_max_devices(link) == 1 &&
2325 ata_dev_enabled(link->device))))
2326 dev = link->device;
2327
2328 if (dev) {
2329 if (dev->flags & ATA_DFLAG_DUBIOUS_XFER)
2330 eflags |= ATA_EFLAG_DUBIOUS_XFER;
2331 ehc->i.action |= ata_eh_speed_down(dev, eflags, all_err_mask);
2332 }
2333 trace_ata_eh_link_autopsy(dev, ehc->i.action, all_err_mask);
2334 DPRINTK("EXIT\n");
2335}
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347void ata_eh_autopsy(struct ata_port *ap)
2348{
2349 struct ata_link *link;
2350
2351 ata_for_each_link(link, ap, EDGE)
2352 ata_eh_link_autopsy(link);
2353
2354
2355
2356
2357
2358 if (ap->slave_link) {
2359 struct ata_eh_context *mehc = &ap->link.eh_context;
2360 struct ata_eh_context *sehc = &ap->slave_link->eh_context;
2361
2362
2363 sehc->i.flags |= mehc->i.flags & ATA_EHI_TO_SLAVE_MASK;
2364
2365
2366 ata_eh_link_autopsy(ap->slave_link);
2367
2368
2369 ata_eh_about_to_do(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2370 mehc->i.action |= sehc->i.action;
2371 mehc->i.dev_action[1] |= sehc->i.dev_action[1];
2372 mehc->i.flags |= sehc->i.flags;
2373 ata_eh_done(ap->slave_link, NULL, ATA_EH_ALL_ACTIONS);
2374 }
2375
2376
2377
2378
2379 if (sata_pmp_attached(ap))
2380 ata_eh_link_autopsy(&ap->link);
2381}
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393const char *ata_get_cmd_descript(u8 command)
2394{
2395#ifdef CONFIG_ATA_VERBOSE_ERROR
2396 static const struct
2397 {
2398 u8 command;
2399 const char *text;
2400 } cmd_descr[] = {
2401 { ATA_CMD_DEV_RESET, "DEVICE RESET" },
2402 { ATA_CMD_CHK_POWER, "CHECK POWER MODE" },
2403 { ATA_CMD_STANDBY, "STANDBY" },
2404 { ATA_CMD_IDLE, "IDLE" },
2405 { ATA_CMD_EDD, "EXECUTE DEVICE DIAGNOSTIC" },
2406 { ATA_CMD_DOWNLOAD_MICRO, "DOWNLOAD MICROCODE" },
2407 { ATA_CMD_DOWNLOAD_MICRO_DMA, "DOWNLOAD MICROCODE DMA" },
2408 { ATA_CMD_NOP, "NOP" },
2409 { ATA_CMD_FLUSH, "FLUSH CACHE" },
2410 { ATA_CMD_FLUSH_EXT, "FLUSH CACHE EXT" },
2411 { ATA_CMD_ID_ATA, "IDENTIFY DEVICE" },
2412 { ATA_CMD_ID_ATAPI, "IDENTIFY PACKET DEVICE" },
2413 { ATA_CMD_SERVICE, "SERVICE" },
2414 { ATA_CMD_READ, "READ DMA" },
2415 { ATA_CMD_READ_EXT, "READ DMA EXT" },
2416 { ATA_CMD_READ_QUEUED, "READ DMA QUEUED" },
2417 { ATA_CMD_READ_STREAM_EXT, "READ STREAM EXT" },
2418 { ATA_CMD_READ_STREAM_DMA_EXT, "READ STREAM DMA EXT" },
2419 { ATA_CMD_WRITE, "WRITE DMA" },
2420 { ATA_CMD_WRITE_EXT, "WRITE DMA EXT" },
2421 { ATA_CMD_WRITE_QUEUED, "WRITE DMA QUEUED EXT" },
2422 { ATA_CMD_WRITE_STREAM_EXT, "WRITE STREAM EXT" },
2423 { ATA_CMD_WRITE_STREAM_DMA_EXT, "WRITE STREAM DMA EXT" },
2424 { ATA_CMD_WRITE_FUA_EXT, "WRITE DMA FUA EXT" },
2425 { ATA_CMD_WRITE_QUEUED_FUA_EXT, "WRITE DMA QUEUED FUA EXT" },
2426 { ATA_CMD_FPDMA_READ, "READ FPDMA QUEUED" },
2427 { ATA_CMD_FPDMA_WRITE, "WRITE FPDMA QUEUED" },
2428 { ATA_CMD_FPDMA_SEND, "SEND FPDMA QUEUED" },
2429 { ATA_CMD_FPDMA_RECV, "RECEIVE FPDMA QUEUED" },
2430 { ATA_CMD_PIO_READ, "READ SECTOR(S)" },
2431 { ATA_CMD_PIO_READ_EXT, "READ SECTOR(S) EXT" },
2432 { ATA_CMD_PIO_WRITE, "WRITE SECTOR(S)" },
2433 { ATA_CMD_PIO_WRITE_EXT, "WRITE SECTOR(S) EXT" },
2434 { ATA_CMD_READ_MULTI, "READ MULTIPLE" },
2435 { ATA_CMD_READ_MULTI_EXT, "READ MULTIPLE EXT" },
2436 { ATA_CMD_WRITE_MULTI, "WRITE MULTIPLE" },
2437 { ATA_CMD_WRITE_MULTI_EXT, "WRITE MULTIPLE EXT" },
2438 { ATA_CMD_WRITE_MULTI_FUA_EXT, "WRITE MULTIPLE FUA EXT" },
2439 { ATA_CMD_SET_FEATURES, "SET FEATURES" },
2440 { ATA_CMD_SET_MULTI, "SET MULTIPLE MODE" },
2441 { ATA_CMD_VERIFY, "READ VERIFY SECTOR(S)" },
2442 { ATA_CMD_VERIFY_EXT, "READ VERIFY SECTOR(S) EXT" },
2443 { ATA_CMD_WRITE_UNCORR_EXT, "WRITE UNCORRECTABLE EXT" },
2444 { ATA_CMD_STANDBYNOW1, "STANDBY IMMEDIATE" },
2445 { ATA_CMD_IDLEIMMEDIATE, "IDLE IMMEDIATE" },
2446 { ATA_CMD_SLEEP, "SLEEP" },
2447 { ATA_CMD_INIT_DEV_PARAMS, "INITIALIZE DEVICE PARAMETERS" },
2448 { ATA_CMD_READ_NATIVE_MAX, "READ NATIVE MAX ADDRESS" },
2449 { ATA_CMD_READ_NATIVE_MAX_EXT, "READ NATIVE MAX ADDRESS EXT" },
2450 { ATA_CMD_SET_MAX, "SET MAX ADDRESS" },
2451 { ATA_CMD_SET_MAX_EXT, "SET MAX ADDRESS EXT" },
2452 { ATA_CMD_READ_LOG_EXT, "READ LOG EXT" },
2453 { ATA_CMD_WRITE_LOG_EXT, "WRITE LOG EXT" },
2454 { ATA_CMD_READ_LOG_DMA_EXT, "READ LOG DMA EXT" },
2455 { ATA_CMD_WRITE_LOG_DMA_EXT, "WRITE LOG DMA EXT" },
2456 { ATA_CMD_TRUSTED_NONDATA, "TRUSTED NON-DATA" },
2457 { ATA_CMD_TRUSTED_RCV, "TRUSTED RECEIVE" },
2458 { ATA_CMD_TRUSTED_RCV_DMA, "TRUSTED RECEIVE DMA" },
2459 { ATA_CMD_TRUSTED_SND, "TRUSTED SEND" },
2460 { ATA_CMD_TRUSTED_SND_DMA, "TRUSTED SEND DMA" },
2461 { ATA_CMD_PMP_READ, "READ BUFFER" },
2462 { ATA_CMD_PMP_READ_DMA, "READ BUFFER DMA" },
2463 { ATA_CMD_PMP_WRITE, "WRITE BUFFER" },
2464 { ATA_CMD_PMP_WRITE_DMA, "WRITE BUFFER DMA" },
2465 { ATA_CMD_CONF_OVERLAY, "DEVICE CONFIGURATION OVERLAY" },
2466 { ATA_CMD_SEC_SET_PASS, "SECURITY SET PASSWORD" },
2467 { ATA_CMD_SEC_UNLOCK, "SECURITY UNLOCK" },
2468 { ATA_CMD_SEC_ERASE_PREP, "SECURITY ERASE PREPARE" },
2469 { ATA_CMD_SEC_ERASE_UNIT, "SECURITY ERASE UNIT" },
2470 { ATA_CMD_SEC_FREEZE_LOCK, "SECURITY FREEZE LOCK" },
2471 { ATA_CMD_SEC_DISABLE_PASS, "SECURITY DISABLE PASSWORD" },
2472 { ATA_CMD_CONFIG_STREAM, "CONFIGURE STREAM" },
2473 { ATA_CMD_SMART, "SMART" },
2474 { ATA_CMD_MEDIA_LOCK, "DOOR LOCK" },
2475 { ATA_CMD_MEDIA_UNLOCK, "DOOR UNLOCK" },
2476 { ATA_CMD_DSM, "DATA SET MANAGEMENT" },
2477 { ATA_CMD_CHK_MED_CRD_TYP, "CHECK MEDIA CARD TYPE" },
2478 { ATA_CMD_CFA_REQ_EXT_ERR, "CFA REQUEST EXTENDED ERROR" },
2479 { ATA_CMD_CFA_WRITE_NE, "CFA WRITE SECTORS WITHOUT ERASE" },
2480 { ATA_CMD_CFA_TRANS_SECT, "CFA TRANSLATE SECTOR" },
2481 { ATA_CMD_CFA_ERASE, "CFA ERASE SECTORS" },
2482 { ATA_CMD_CFA_WRITE_MULT_NE, "CFA WRITE MULTIPLE WITHOUT ERASE" },
2483 { ATA_CMD_REQ_SENSE_DATA, "REQUEST SENSE DATA EXT" },
2484 { ATA_CMD_SANITIZE_DEVICE, "SANITIZE DEVICE" },
2485 { ATA_CMD_ZAC_MGMT_IN, "ZAC MANAGEMENT IN" },
2486 { ATA_CMD_ZAC_MGMT_OUT, "ZAC MANAGEMENT OUT" },
2487 { ATA_CMD_READ_LONG, "READ LONG (with retries)" },
2488 { ATA_CMD_READ_LONG_ONCE, "READ LONG (without retries)" },
2489 { ATA_CMD_WRITE_LONG, "WRITE LONG (with retries)" },
2490 { ATA_CMD_WRITE_LONG_ONCE, "WRITE LONG (without retries)" },
2491 { ATA_CMD_RESTORE, "RECALIBRATE" },
2492 { 0, NULL }
2493 };
2494
2495 unsigned int i;
2496 for (i = 0; cmd_descr[i].text; i++)
2497 if (cmd_descr[i].command == command)
2498 return cmd_descr[i].text;
2499#endif
2500
2501 return NULL;
2502}
2503EXPORT_SYMBOL_GPL(ata_get_cmd_descript);
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514static void ata_eh_link_report(struct ata_link *link)
2515{
2516 struct ata_port *ap = link->ap;
2517 struct ata_eh_context *ehc = &link->eh_context;
2518 const char *frozen, *desc;
2519 char tries_buf[6] = "";
2520 int tag, nr_failed = 0;
2521
2522 if (ehc->i.flags & ATA_EHI_QUIET)
2523 return;
2524
2525 desc = NULL;
2526 if (ehc->i.desc[0] != '\0')
2527 desc = ehc->i.desc;
2528
2529 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2530 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2531
2532 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2533 ata_dev_phys_link(qc->dev) != link ||
2534 ((qc->flags & ATA_QCFLAG_QUIET) &&
2535 qc->err_mask == AC_ERR_DEV))
2536 continue;
2537 if (qc->flags & ATA_QCFLAG_SENSE_VALID && !qc->err_mask)
2538 continue;
2539
2540 nr_failed++;
2541 }
2542
2543 if (!nr_failed && !ehc->i.err_mask)
2544 return;
2545
2546 frozen = "";
2547 if (ap->pflags & ATA_PFLAG_FROZEN)
2548 frozen = " frozen";
2549
2550 if (ap->eh_tries < ATA_EH_MAX_TRIES)
2551 snprintf(tries_buf, sizeof(tries_buf), " t%d",
2552 ap->eh_tries);
2553
2554 if (ehc->i.dev) {
2555 ata_dev_err(ehc->i.dev, "exception Emask 0x%x "
2556 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2557 ehc->i.err_mask, link->sactive, ehc->i.serror,
2558 ehc->i.action, frozen, tries_buf);
2559 if (desc)
2560 ata_dev_err(ehc->i.dev, "%s\n", desc);
2561 } else {
2562 ata_link_err(link, "exception Emask 0x%x "
2563 "SAct 0x%x SErr 0x%x action 0x%x%s%s\n",
2564 ehc->i.err_mask, link->sactive, ehc->i.serror,
2565 ehc->i.action, frozen, tries_buf);
2566 if (desc)
2567 ata_link_err(link, "%s\n", desc);
2568 }
2569
2570#ifdef CONFIG_ATA_VERBOSE_ERROR
2571 if (ehc->i.serror)
2572 ata_link_err(link,
2573 "SError: { %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s}\n",
2574 ehc->i.serror & SERR_DATA_RECOVERED ? "RecovData " : "",
2575 ehc->i.serror & SERR_COMM_RECOVERED ? "RecovComm " : "",
2576 ehc->i.serror & SERR_DATA ? "UnrecovData " : "",
2577 ehc->i.serror & SERR_PERSISTENT ? "Persist " : "",
2578 ehc->i.serror & SERR_PROTOCOL ? "Proto " : "",
2579 ehc->i.serror & SERR_INTERNAL ? "HostInt " : "",
2580 ehc->i.serror & SERR_PHYRDY_CHG ? "PHYRdyChg " : "",
2581 ehc->i.serror & SERR_PHY_INT_ERR ? "PHYInt " : "",
2582 ehc->i.serror & SERR_COMM_WAKE ? "CommWake " : "",
2583 ehc->i.serror & SERR_10B_8B_ERR ? "10B8B " : "",
2584 ehc->i.serror & SERR_DISPARITY ? "Dispar " : "",
2585 ehc->i.serror & SERR_CRC ? "BadCRC " : "",
2586 ehc->i.serror & SERR_HANDSHAKE ? "Handshk " : "",
2587 ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
2588 ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
2589 ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
2590 ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
2591#endif
2592
2593 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
2594 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
2595 struct ata_taskfile *cmd = &qc->tf, *res = &qc->result_tf;
2596 char data_buf[20] = "";
2597 char cdb_buf[70] = "";
2598
2599 if (!(qc->flags & ATA_QCFLAG_FAILED) ||
2600 ata_dev_phys_link(qc->dev) != link || !qc->err_mask)
2601 continue;
2602
2603 if (qc->dma_dir != DMA_NONE) {
2604 static const char *dma_str[] = {
2605 [DMA_BIDIRECTIONAL] = "bidi",
2606 [DMA_TO_DEVICE] = "out",
2607 [DMA_FROM_DEVICE] = "in",
2608 };
2609 static const char *prot_str[] = {
2610 [ATA_PROT_UNKNOWN] = "unknown",
2611 [ATA_PROT_NODATA] = "nodata",
2612 [ATA_PROT_PIO] = "pio",
2613 [ATA_PROT_DMA] = "dma",
2614 [ATA_PROT_NCQ] = "ncq dma",
2615 [ATA_PROT_NCQ_NODATA] = "ncq nodata",
2616 [ATAPI_PROT_NODATA] = "nodata",
2617 [ATAPI_PROT_PIO] = "pio",
2618 [ATAPI_PROT_DMA] = "dma",
2619 };
2620
2621 snprintf(data_buf, sizeof(data_buf), " %s %u %s",
2622 prot_str[qc->tf.protocol], qc->nbytes,
2623 dma_str[qc->dma_dir]);
2624 }
2625
2626 if (ata_is_atapi(qc->tf.protocol)) {
2627 const u8 *cdb = qc->cdb;
2628 size_t cdb_len = qc->dev->cdb_len;
2629
2630 if (qc->scsicmd) {
2631 cdb = qc->scsicmd->cmnd;
2632 cdb_len = qc->scsicmd->cmd_len;
2633 }
2634 __scsi_format_command(cdb_buf, sizeof(cdb_buf),
2635 cdb, cdb_len);
2636 } else {
2637 const char *descr = ata_get_cmd_descript(cmd->command);
2638 if (descr)
2639 ata_dev_err(qc->dev, "failed command: %s\n",
2640 descr);
2641 }
2642
2643 ata_dev_err(qc->dev,
2644 "cmd %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
2645 "tag %d%s\n %s"
2646 "res %02x/%02x:%02x:%02x:%02x:%02x/%02x:%02x:%02x:%02x:%02x/%02x "
2647 "Emask 0x%x (%s)%s\n",
2648 cmd->command, cmd->feature, cmd->nsect,
2649 cmd->lbal, cmd->lbam, cmd->lbah,
2650 cmd->hob_feature, cmd->hob_nsect,
2651 cmd->hob_lbal, cmd->hob_lbam, cmd->hob_lbah,
2652 cmd->device, qc->tag, data_buf, cdb_buf,
2653 res->command, res->feature, res->nsect,
2654 res->lbal, res->lbam, res->lbah,
2655 res->hob_feature, res->hob_nsect,
2656 res->hob_lbal, res->hob_lbam, res->hob_lbah,
2657 res->device, qc->err_mask, ata_err_string(qc->err_mask),
2658 qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
2659
2660#ifdef CONFIG_ATA_VERBOSE_ERROR
2661 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
2662 ATA_SENSE | ATA_ERR)) {
2663 if (res->command & ATA_BUSY)
2664 ata_dev_err(qc->dev, "status: { Busy }\n");
2665 else
2666 ata_dev_err(qc->dev, "status: { %s%s%s%s%s}\n",
2667 res->command & ATA_DRDY ? "DRDY " : "",
2668 res->command & ATA_DF ? "DF " : "",
2669 res->command & ATA_DRQ ? "DRQ " : "",
2670 res->command & ATA_SENSE ? "SENSE " : "",
2671 res->command & ATA_ERR ? "ERR " : "");
2672 }
2673
2674 if (cmd->command != ATA_CMD_PACKET &&
2675 (res->feature & (ATA_ICRC | ATA_UNC | ATA_AMNF |
2676 ATA_IDNF | ATA_ABORTED)))
2677 ata_dev_err(qc->dev, "error: { %s%s%s%s%s}\n",
2678 res->feature & ATA_ICRC ? "ICRC " : "",
2679 res->feature & ATA_UNC ? "UNC " : "",
2680 res->feature & ATA_AMNF ? "AMNF " : "",
2681 res->feature & ATA_IDNF ? "IDNF " : "",
2682 res->feature & ATA_ABORTED ? "ABRT " : "");
2683#endif
2684 }
2685}
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696void ata_eh_report(struct ata_port *ap)
2697{
2698 struct ata_link *link;
2699
2700 ata_for_each_link(link, ap, HOST_FIRST)
2701 ata_eh_link_report(link);
2702}
2703
2704static int ata_do_reset(struct ata_link *link, ata_reset_fn_t reset,
2705 unsigned int *classes, unsigned long deadline,
2706 bool clear_classes)
2707{
2708 struct ata_device *dev;
2709
2710 if (clear_classes)
2711 ata_for_each_dev(dev, link, ALL)
2712 classes[dev->devno] = ATA_DEV_UNKNOWN;
2713
2714 return reset(link, classes, deadline);
2715}
2716
2717static int ata_eh_followup_srst_needed(struct ata_link *link, int rc)
2718{
2719 if ((link->flags & ATA_LFLAG_NO_SRST) || ata_link_offline(link))
2720 return 0;
2721 if (rc == -EAGAIN)
2722 return 1;
2723 if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
2724 return 1;
2725 return 0;
2726}
2727
2728int ata_eh_reset(struct ata_link *link, int classify,
2729 ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
2730 ata_reset_fn_t hardreset, ata_postreset_fn_t postreset)
2731{
2732 struct ata_port *ap = link->ap;
2733 struct ata_link *slave = ap->slave_link;
2734 struct ata_eh_context *ehc = &link->eh_context;
2735 struct ata_eh_context *sehc = slave ? &slave->eh_context : NULL;
2736 unsigned int *classes = ehc->classes;
2737 unsigned int lflags = link->flags;
2738 int verbose = !(ehc->i.flags & ATA_EHI_QUIET);
2739 int max_tries = 0, try = 0;
2740 struct ata_link *failed_link;
2741 struct ata_device *dev;
2742 unsigned long deadline, now;
2743 ata_reset_fn_t reset;
2744 unsigned long flags;
2745 u32 sstatus;
2746 int nr_unknown, rc;
2747
2748
2749
2750
2751 while (ata_eh_reset_timeouts[max_tries] != ULONG_MAX)
2752 max_tries++;
2753 if (link->flags & ATA_LFLAG_RST_ONCE)
2754 max_tries = 1;
2755 if (link->flags & ATA_LFLAG_NO_HRST)
2756 hardreset = NULL;
2757 if (link->flags & ATA_LFLAG_NO_SRST)
2758 softreset = NULL;
2759
2760
2761 if (ehc->i.flags & ATA_EHI_DID_RESET) {
2762 now = jiffies;
2763 WARN_ON(time_after(ehc->last_reset, now));
2764 deadline = ata_deadline(ehc->last_reset,
2765 ATA_EH_RESET_COOL_DOWN);
2766 if (time_before(now, deadline))
2767 schedule_timeout_uninterruptible(deadline - now);
2768 }
2769
2770 spin_lock_irqsave(ap->lock, flags);
2771 ap->pflags |= ATA_PFLAG_RESETTING;
2772 spin_unlock_irqrestore(ap->lock, flags);
2773
2774 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2775
2776 ata_for_each_dev(dev, link, ALL) {
2777
2778
2779
2780
2781
2782
2783
2784 dev->pio_mode = XFER_PIO_0;
2785 dev->dma_mode = 0xff;
2786
2787
2788
2789
2790
2791
2792 if (ap->ops->set_piomode)
2793 ap->ops->set_piomode(ap, dev);
2794 }
2795
2796
2797 reset = NULL;
2798 ehc->i.action &= ~ATA_EH_RESET;
2799 if (hardreset) {
2800 reset = hardreset;
2801 ehc->i.action |= ATA_EH_HARDRESET;
2802 } else if (softreset) {
2803 reset = softreset;
2804 ehc->i.action |= ATA_EH_SOFTRESET;
2805 }
2806
2807 if (prereset) {
2808 unsigned long deadline = ata_deadline(jiffies,
2809 ATA_EH_PRERESET_TIMEOUT);
2810
2811 if (slave) {
2812 sehc->i.action &= ~ATA_EH_RESET;
2813 sehc->i.action |= ehc->i.action;
2814 }
2815
2816 rc = prereset(link, deadline);
2817
2818
2819
2820
2821
2822 if (slave && (rc == 0 || rc == -ENOENT)) {
2823 int tmp;
2824
2825 tmp = prereset(slave, deadline);
2826 if (tmp != -ENOENT)
2827 rc = tmp;
2828
2829 ehc->i.action |= sehc->i.action;
2830 }
2831
2832 if (rc) {
2833 if (rc == -ENOENT) {
2834 ata_link_dbg(link, "port disabled--ignoring\n");
2835 ehc->i.action &= ~ATA_EH_RESET;
2836
2837 ata_for_each_dev(dev, link, ALL)
2838 classes[dev->devno] = ATA_DEV_NONE;
2839
2840 rc = 0;
2841 } else
2842 ata_link_err(link,
2843 "prereset failed (errno=%d)\n",
2844 rc);
2845 goto out;
2846 }
2847
2848
2849
2850
2851 if (reset && !(ehc->i.action & ATA_EH_RESET)) {
2852 ata_for_each_dev(dev, link, ALL)
2853 classes[dev->devno] = ATA_DEV_NONE;
2854 if ((ap->pflags & ATA_PFLAG_FROZEN) &&
2855 ata_is_host_link(link))
2856 ata_eh_thaw_port(ap);
2857 rc = 0;
2858 goto out;
2859 }
2860 }
2861
2862 retry:
2863
2864
2865
2866 if (ata_is_host_link(link))
2867 ata_eh_freeze_port(ap);
2868
2869 deadline = ata_deadline(jiffies, ata_eh_reset_timeouts[try++]);
2870
2871 if (reset) {
2872 if (verbose)
2873 ata_link_info(link, "%s resetting link\n",
2874 reset == softreset ? "soft" : "hard");
2875
2876
2877 ehc->last_reset = jiffies;
2878 if (reset == hardreset)
2879 ehc->i.flags |= ATA_EHI_DID_HARDRESET;
2880 else
2881 ehc->i.flags |= ATA_EHI_DID_SOFTRESET;
2882
2883 rc = ata_do_reset(link, reset, classes, deadline, true);
2884 if (rc && rc != -EAGAIN) {
2885 failed_link = link;
2886 goto fail;
2887 }
2888
2889
2890 if (slave && reset == hardreset) {
2891 int tmp;
2892
2893 if (verbose)
2894 ata_link_info(slave, "hard resetting link\n");
2895
2896 ata_eh_about_to_do(slave, NULL, ATA_EH_RESET);
2897 tmp = ata_do_reset(slave, reset, classes, deadline,
2898 false);
2899 switch (tmp) {
2900 case -EAGAIN:
2901 rc = -EAGAIN;
2902 case 0:
2903 break;
2904 default:
2905 failed_link = slave;
2906 rc = tmp;
2907 goto fail;
2908 }
2909 }
2910
2911
2912 if (reset == hardreset &&
2913 ata_eh_followup_srst_needed(link, rc)) {
2914 reset = softreset;
2915
2916 if (!reset) {
2917 ata_link_err(link,
2918 "follow-up softreset required but no softreset available\n");
2919 failed_link = link;
2920 rc = -EINVAL;
2921 goto fail;
2922 }
2923
2924 ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
2925 rc = ata_do_reset(link, reset, classes, deadline, true);
2926 if (rc) {
2927 failed_link = link;
2928 goto fail;
2929 }
2930 }
2931 } else {
2932 if (verbose)
2933 ata_link_info(link,
2934 "no reset method available, skipping reset\n");
2935 if (!(lflags & ATA_LFLAG_ASSUME_CLASS))
2936 lflags |= ATA_LFLAG_ASSUME_ATA;
2937 }
2938
2939
2940
2941
2942 ata_for_each_dev(dev, link, ALL) {
2943
2944
2945
2946
2947 dev->pio_mode = XFER_PIO_0;
2948 dev->flags &= ~ATA_DFLAG_SLEEPING;
2949
2950 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
2951 continue;
2952
2953
2954 if (lflags & ATA_LFLAG_ASSUME_ATA)
2955 classes[dev->devno] = ATA_DEV_ATA;
2956 else if (lflags & ATA_LFLAG_ASSUME_SEMB)
2957 classes[dev->devno] = ATA_DEV_SEMB_UNSUP;
2958 }
2959
2960
2961 if (sata_scr_read(link, SCR_STATUS, &sstatus) == 0)
2962 link->sata_spd = (sstatus >> 4) & 0xf;
2963 if (slave && sata_scr_read(slave, SCR_STATUS, &sstatus) == 0)
2964 slave->sata_spd = (sstatus >> 4) & 0xf;
2965
2966
2967 if (ata_is_host_link(link))
2968 ata_eh_thaw_port(ap);
2969
2970
2971
2972
2973
2974
2975
2976
2977 if (postreset) {
2978 postreset(link, classes);
2979 if (slave)
2980 postreset(slave, classes);
2981 }
2982
2983
2984
2985
2986
2987
2988
2989
2990 spin_lock_irqsave(link->ap->lock, flags);
2991 memset(&link->eh_info, 0, sizeof(link->eh_info));
2992 if (slave)
2993 memset(&slave->eh_info, 0, sizeof(link->eh_info));
2994 ap->pflags &= ~ATA_PFLAG_EH_PENDING;
2995 spin_unlock_irqrestore(link->ap->lock, flags);
2996
2997 if (ap->pflags & ATA_PFLAG_FROZEN)
2998 ata_eh_thaw_port(ap);
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008 nr_unknown = 0;
3009 ata_for_each_dev(dev, link, ALL) {
3010 if (ata_phys_link_online(ata_dev_phys_link(dev))) {
3011 if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
3012 ata_dev_dbg(dev, "link online but device misclassified\n");
3013 classes[dev->devno] = ATA_DEV_NONE;
3014 nr_unknown++;
3015 }
3016 } else if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
3017 if (ata_class_enabled(classes[dev->devno]))
3018 ata_dev_dbg(dev,
3019 "link offline, clearing class %d to NONE\n",
3020 classes[dev->devno]);
3021 classes[dev->devno] = ATA_DEV_NONE;
3022 } else if (classes[dev->devno] == ATA_DEV_UNKNOWN) {
3023 ata_dev_dbg(dev,
3024 "link status unknown, clearing UNKNOWN to NONE\n");
3025 classes[dev->devno] = ATA_DEV_NONE;
3026 }
3027 }
3028
3029 if (classify && nr_unknown) {
3030 if (try < max_tries) {
3031 ata_link_warn(link,
3032 "link online but %d devices misclassified, retrying\n",
3033 nr_unknown);
3034 failed_link = link;
3035 rc = -EAGAIN;
3036 goto fail;
3037 }
3038 ata_link_warn(link,
3039 "link online but %d devices misclassified, "
3040 "device detection might fail\n", nr_unknown);
3041 }
3042
3043
3044 ata_eh_done(link, NULL, ATA_EH_RESET);
3045 if (slave)
3046 ata_eh_done(slave, NULL, ATA_EH_RESET);
3047 ehc->last_reset = jiffies;
3048 ehc->i.action |= ATA_EH_REVALIDATE;
3049 link->lpm_policy = ATA_LPM_UNKNOWN;
3050
3051 rc = 0;
3052 out:
3053
3054 ehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
3055 if (slave)
3056 sehc->i.flags &= ~ATA_EHI_HOTPLUGGED;
3057
3058 spin_lock_irqsave(ap->lock, flags);
3059 ap->pflags &= ~ATA_PFLAG_RESETTING;
3060 spin_unlock_irqrestore(ap->lock, flags);
3061
3062 return rc;
3063
3064 fail:
3065
3066 if (!ata_is_host_link(link) &&
3067 sata_scr_read(link, SCR_STATUS, &sstatus))
3068 rc = -ERESTART;
3069
3070 if (try >= max_tries) {
3071
3072
3073
3074
3075
3076
3077 if (ata_is_host_link(link))
3078 ata_eh_thaw_port(ap);
3079 goto out;
3080 }
3081
3082 now = jiffies;
3083 if (time_before(now, deadline)) {
3084 unsigned long delta = deadline - now;
3085
3086 ata_link_warn(failed_link,
3087 "reset failed (errno=%d), retrying in %u secs\n",
3088 rc, DIV_ROUND_UP(jiffies_to_msecs(delta), 1000));
3089
3090 ata_eh_release(ap);
3091 while (delta)
3092 delta = schedule_timeout_uninterruptible(delta);
3093 ata_eh_acquire(ap);
3094 }
3095
3096
3097
3098
3099
3100 if (rc == -ERESTART) {
3101 if (ata_is_host_link(link))
3102 ata_eh_thaw_port(ap);
3103 goto out;
3104 }
3105
3106 if (try == max_tries - 1) {
3107 sata_down_spd_limit(link, 0);
3108 if (slave)
3109 sata_down_spd_limit(slave, 0);
3110 } else if (rc == -EPIPE)
3111 sata_down_spd_limit(failed_link, 0);
3112
3113 if (hardreset)
3114 reset = hardreset;
3115 goto retry;
3116}
3117
3118static inline void ata_eh_pull_park_action(struct ata_port *ap)
3119{
3120 struct ata_link *link;
3121 struct ata_device *dev;
3122 unsigned long flags;
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150 spin_lock_irqsave(ap->lock, flags);
3151 reinit_completion(&ap->park_req_pending);
3152 ata_for_each_link(link, ap, EDGE) {
3153 ata_for_each_dev(dev, link, ALL) {
3154 struct ata_eh_info *ehi = &link->eh_info;
3155
3156 link->eh_context.i.dev_action[dev->devno] |=
3157 ehi->dev_action[dev->devno] & ATA_EH_PARK;
3158 ata_eh_clear_action(link, dev, ehi, ATA_EH_PARK);
3159 }
3160 }
3161 spin_unlock_irqrestore(ap->lock, flags);
3162}
3163
3164static void ata_eh_park_issue_cmd(struct ata_device *dev, int park)
3165{
3166 struct ata_eh_context *ehc = &dev->link->eh_context;
3167 struct ata_taskfile tf;
3168 unsigned int err_mask;
3169
3170 ata_tf_init(dev, &tf);
3171 if (park) {
3172 ehc->unloaded_mask |= 1 << dev->devno;
3173 tf.command = ATA_CMD_IDLEIMMEDIATE;
3174 tf.feature = 0x44;
3175 tf.lbal = 0x4c;
3176 tf.lbam = 0x4e;
3177 tf.lbah = 0x55;
3178 } else {
3179 ehc->unloaded_mask &= ~(1 << dev->devno);
3180 tf.command = ATA_CMD_CHK_POWER;
3181 }
3182
3183 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
3184 tf.protocol = ATA_PROT_NODATA;
3185 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
3186 if (park && (err_mask || tf.lbal != 0xc4)) {
3187 ata_dev_err(dev, "head unload failed!\n");
3188 ehc->unloaded_mask &= ~(1 << dev->devno);
3189 }
3190}
3191
3192static int ata_eh_revalidate_and_attach(struct ata_link *link,
3193 struct ata_device **r_failed_dev)
3194{
3195 struct ata_port *ap = link->ap;
3196 struct ata_eh_context *ehc = &link->eh_context;
3197 struct ata_device *dev;
3198 unsigned int new_mask = 0;
3199 unsigned long flags;
3200 int rc = 0;
3201
3202 DPRINTK("ENTER\n");
3203
3204
3205
3206
3207
3208 ata_for_each_dev(dev, link, ALL_REVERSE) {
3209 unsigned int action = ata_eh_dev_action(dev);
3210 unsigned int readid_flags = 0;
3211
3212 if (ehc->i.flags & ATA_EHI_DID_RESET)
3213 readid_flags |= ATA_READID_POSTRESET;
3214
3215 if ((action & ATA_EH_REVALIDATE) && ata_dev_enabled(dev)) {
3216 WARN_ON(dev->class == ATA_DEV_PMP);
3217
3218 if (ata_phys_link_offline(ata_dev_phys_link(dev))) {
3219 rc = -EIO;
3220 goto err;
3221 }
3222
3223 ata_eh_about_to_do(link, dev, ATA_EH_REVALIDATE);
3224 rc = ata_dev_revalidate(dev, ehc->classes[dev->devno],
3225 readid_flags);
3226 if (rc)
3227 goto err;
3228
3229 ata_eh_done(link, dev, ATA_EH_REVALIDATE);
3230
3231
3232
3233
3234 ehc->i.flags |= ATA_EHI_SETMODE;
3235
3236
3237 schedule_work(&(ap->scsi_rescan_task));
3238 } else if (dev->class == ATA_DEV_UNKNOWN &&
3239 ehc->tries[dev->devno] &&
3240 ata_class_enabled(ehc->classes[dev->devno])) {
3241
3242
3243
3244
3245
3246
3247 dev->class = ehc->classes[dev->devno];
3248
3249 if (dev->class == ATA_DEV_PMP)
3250 rc = sata_pmp_attach(dev);
3251 else
3252 rc = ata_dev_read_id(dev, &dev->class,
3253 readid_flags, dev->id);
3254
3255
3256 ehc->classes[dev->devno] = dev->class;
3257 dev->class = ATA_DEV_UNKNOWN;
3258
3259 switch (rc) {
3260 case 0:
3261
3262 ata_ering_clear(&dev->ering);
3263 new_mask |= 1 << dev->devno;
3264 break;
3265 case -ENOENT:
3266
3267
3268
3269
3270 ata_eh_thaw_port(ap);
3271 break;
3272 default:
3273 goto err;
3274 }
3275 }
3276 }
3277
3278
3279 if ((ehc->i.flags & ATA_EHI_DID_RESET) && ata_is_host_link(link)) {
3280 if (ap->ops->cable_detect)
3281 ap->cbl = ap->ops->cable_detect(ap);
3282 ata_force_cbl(ap);
3283 }
3284
3285
3286
3287
3288 ata_for_each_dev(dev, link, ALL) {
3289 if (!(new_mask & (1 << dev->devno)))
3290 continue;
3291
3292 dev->class = ehc->classes[dev->devno];
3293
3294 if (dev->class == ATA_DEV_PMP)
3295 continue;
3296
3297 ehc->i.flags |= ATA_EHI_PRINTINFO;
3298 rc = ata_dev_configure(dev);
3299 ehc->i.flags &= ~ATA_EHI_PRINTINFO;
3300 if (rc) {
3301 dev->class = ATA_DEV_UNKNOWN;
3302 goto err;
3303 }
3304
3305 spin_lock_irqsave(ap->lock, flags);
3306 ap->pflags |= ATA_PFLAG_SCSI_HOTPLUG;
3307 spin_unlock_irqrestore(ap->lock, flags);
3308
3309
3310 ehc->i.flags |= ATA_EHI_SETMODE;
3311 }
3312
3313 return 0;
3314
3315 err:
3316 *r_failed_dev = dev;
3317 DPRINTK("EXIT rc=%d\n", rc);
3318 return rc;
3319}
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev)
3337{
3338 struct ata_port *ap = link->ap;
3339 struct ata_device *dev;
3340 int rc;
3341
3342
3343 ata_for_each_dev(dev, link, ENABLED) {
3344 if (!(dev->flags & ATA_DFLAG_DUBIOUS_XFER)) {
3345 struct ata_ering_entry *ent;
3346
3347 ent = ata_ering_top(&dev->ering);
3348 if (ent)
3349 ent->eflags &= ~ATA_EFLAG_DUBIOUS_XFER;
3350 }
3351 }
3352
3353
3354 if (ap->ops->set_mode)
3355 rc = ap->ops->set_mode(link, r_failed_dev);
3356 else
3357 rc = ata_do_set_mode(link, r_failed_dev);
3358
3359
3360 ata_for_each_dev(dev, link, ENABLED) {
3361 struct ata_eh_context *ehc = &link->eh_context;
3362 u8 saved_xfer_mode = ehc->saved_xfer_mode[dev->devno];
3363 u8 saved_ncq = !!(ehc->saved_ncq_enabled & (1 << dev->devno));
3364
3365 if (dev->xfer_mode != saved_xfer_mode ||
3366 ata_ncq_enabled(dev) != saved_ncq)
3367 dev->flags |= ATA_DFLAG_DUBIOUS_XFER;
3368 }
3369
3370 return rc;
3371}
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387static int atapi_eh_clear_ua(struct ata_device *dev)
3388{
3389 int i;
3390
3391 for (i = 0; i < ATA_EH_UA_TRIES; i++) {
3392 u8 *sense_buffer = dev->link->ap->sector_buf;
3393 u8 sense_key = 0;
3394 unsigned int err_mask;
3395
3396 err_mask = atapi_eh_tur(dev, &sense_key);
3397 if (err_mask != 0 && err_mask != AC_ERR_DEV) {
3398 ata_dev_warn(dev,
3399 "TEST_UNIT_READY failed (err_mask=0x%x)\n",
3400 err_mask);
3401 return -EIO;
3402 }
3403
3404 if (!err_mask || sense_key != UNIT_ATTENTION)
3405 return 0;
3406
3407 err_mask = atapi_eh_request_sense(dev, sense_buffer, sense_key);
3408 if (err_mask) {
3409 ata_dev_warn(dev, "failed to clear "
3410 "UNIT ATTENTION (err_mask=0x%x)\n", err_mask);
3411 return -EIO;
3412 }
3413 }
3414
3415 ata_dev_warn(dev, "UNIT ATTENTION persists after %d tries\n",
3416 ATA_EH_UA_TRIES);
3417
3418 return 0;
3419}
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438static int ata_eh_maybe_retry_flush(struct ata_device *dev)
3439{
3440 struct ata_link *link = dev->link;
3441 struct ata_port *ap = link->ap;
3442 struct ata_queued_cmd *qc;
3443 struct ata_taskfile tf;
3444 unsigned int err_mask;
3445 int rc = 0;
3446
3447
3448 if (!ata_tag_valid(link->active_tag))
3449 return 0;
3450
3451 qc = __ata_qc_from_tag(ap, link->active_tag);
3452 if (qc->dev != dev || (qc->tf.command != ATA_CMD_FLUSH_EXT &&
3453 qc->tf.command != ATA_CMD_FLUSH))
3454 return 0;
3455
3456
3457 if (qc->err_mask & AC_ERR_DEV)
3458 return 0;
3459
3460
3461 ata_tf_init(dev, &tf);
3462
3463 tf.command = qc->tf.command;
3464 tf.flags |= ATA_TFLAG_DEVICE;
3465 tf.protocol = ATA_PROT_NODATA;
3466
3467 ata_dev_warn(dev, "retrying FLUSH 0x%x Emask 0x%x\n",
3468 tf.command, qc->err_mask);
3469
3470 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
3471 if (!err_mask) {
3472
3473
3474
3475
3476
3477
3478
3479
3480 qc->scsicmd->allowed = max(qc->scsicmd->allowed, 1);
3481 } else {
3482 ata_dev_warn(dev, "FLUSH failed Emask 0x%x\n",
3483 err_mask);
3484 rc = -EIO;
3485
3486
3487 if (err_mask & AC_ERR_DEV) {
3488 qc->err_mask |= AC_ERR_DEV;
3489 qc->result_tf = tf;
3490 if (!(ap->pflags & ATA_PFLAG_FROZEN))
3491 rc = 0;
3492 }
3493 }
3494 return rc;
3495}
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514static int ata_eh_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
3515 struct ata_device **r_failed_dev)
3516{
3517 struct ata_port *ap = ata_is_host_link(link) ? link->ap : NULL;
3518 struct ata_eh_context *ehc = &link->eh_context;
3519 struct ata_device *dev, *link_dev = NULL, *lpm_dev = NULL;
3520 enum ata_lpm_policy old_policy = link->lpm_policy;
3521 bool no_dipm = link->ap->flags & ATA_FLAG_NO_DIPM;
3522 unsigned int hints = ATA_LPM_EMPTY | ATA_LPM_HIPM;
3523 unsigned int err_mask;
3524 int rc;
3525
3526
3527 if ((link->flags & ATA_LFLAG_NO_LPM) || (ap && !ap->ops->set_lpm))
3528 return 0;
3529
3530
3531
3532
3533
3534
3535
3536 ata_for_each_dev(dev, link, ENABLED) {
3537 bool hipm = ata_id_has_hipm(dev->id);
3538 bool dipm = ata_id_has_dipm(dev->id) && !no_dipm;
3539
3540
3541 if (!link_dev)
3542 link_dev = dev;
3543
3544 if (!lpm_dev && (hipm || dipm))
3545 lpm_dev = dev;
3546
3547 hints &= ~ATA_LPM_EMPTY;
3548 if (!hipm)
3549 hints &= ~ATA_LPM_HIPM;
3550
3551
3552 if (policy != ATA_LPM_MIN_POWER && dipm) {
3553 err_mask = ata_dev_set_feature(dev,
3554 SETFEATURES_SATA_DISABLE, SATA_DIPM);
3555 if (err_mask && err_mask != AC_ERR_DEV) {
3556 ata_dev_warn(dev,
3557 "failed to disable DIPM, Emask 0x%x\n",
3558 err_mask);
3559 rc = -EIO;
3560 goto fail;
3561 }
3562 }
3563 }
3564
3565 if (ap) {
3566 rc = ap->ops->set_lpm(link, policy, hints);
3567 if (!rc && ap->slave_link)
3568 rc = ap->ops->set_lpm(ap->slave_link, policy, hints);
3569 } else
3570 rc = sata_pmp_set_lpm(link, policy, hints);
3571
3572
3573
3574
3575
3576 if (rc) {
3577 if (rc == -EOPNOTSUPP) {
3578 link->flags |= ATA_LFLAG_NO_LPM;
3579 return 0;
3580 }
3581 dev = lpm_dev ? lpm_dev : link_dev;
3582 goto fail;
3583 }
3584
3585
3586
3587
3588
3589 link->lpm_policy = policy;
3590 if (ap && ap->slave_link)
3591 ap->slave_link->lpm_policy = policy;
3592
3593
3594 ata_for_each_dev(dev, link, ENABLED) {
3595 if (policy == ATA_LPM_MIN_POWER && !no_dipm &&
3596 ata_id_has_dipm(dev->id)) {
3597 err_mask = ata_dev_set_feature(dev,
3598 SETFEATURES_SATA_ENABLE, SATA_DIPM);
3599 if (err_mask && err_mask != AC_ERR_DEV) {
3600 ata_dev_warn(dev,
3601 "failed to enable DIPM, Emask 0x%x\n",
3602 err_mask);
3603 rc = -EIO;
3604 goto fail;
3605 }
3606 }
3607 }
3608
3609 link->last_lpm_change = jiffies;
3610 link->flags |= ATA_LFLAG_CHANGED;
3611
3612 return 0;
3613
3614fail:
3615
3616 link->lpm_policy = old_policy;
3617 if (ap && ap->slave_link)
3618 ap->slave_link->lpm_policy = old_policy;
3619
3620
3621 if (!dev || ehc->tries[dev->devno] <= 2) {
3622 ata_link_warn(link, "disabling LPM on the link\n");
3623 link->flags |= ATA_LFLAG_NO_LPM;
3624 }
3625 if (r_failed_dev)
3626 *r_failed_dev = dev;
3627 return rc;
3628}
3629
3630int ata_link_nr_enabled(struct ata_link *link)
3631{
3632 struct ata_device *dev;
3633 int cnt = 0;
3634
3635 ata_for_each_dev(dev, link, ENABLED)
3636 cnt++;
3637 return cnt;
3638}
3639
3640static int ata_link_nr_vacant(struct ata_link *link)
3641{
3642 struct ata_device *dev;
3643 int cnt = 0;
3644
3645 ata_for_each_dev(dev, link, ALL)
3646 if (dev->class == ATA_DEV_UNKNOWN)
3647 cnt++;
3648 return cnt;
3649}
3650
3651static int ata_eh_skip_recovery(struct ata_link *link)
3652{
3653 struct ata_port *ap = link->ap;
3654 struct ata_eh_context *ehc = &link->eh_context;
3655 struct ata_device *dev;
3656
3657
3658 if (link->flags & ATA_LFLAG_DISABLED)
3659 return 1;
3660
3661
3662 if (ehc->i.flags & ATA_EHI_NO_RECOVERY)
3663 return 1;
3664
3665
3666 if ((ap->pflags & ATA_PFLAG_FROZEN) || ata_link_nr_enabled(link))
3667 return 0;
3668
3669
3670 if ((ehc->i.action & ATA_EH_RESET) &&
3671 !(ehc->i.flags & ATA_EHI_DID_RESET))
3672 return 0;
3673
3674
3675 ata_for_each_dev(dev, link, ALL) {
3676 if (dev->class == ATA_DEV_UNKNOWN &&
3677 ehc->classes[dev->devno] != ATA_DEV_NONE)
3678 return 0;
3679 }
3680
3681 return 1;
3682}
3683
3684static int ata_count_probe_trials_cb(struct ata_ering_entry *ent, void *void_arg)
3685{
3686 u64 interval = msecs_to_jiffies(ATA_EH_PROBE_TRIAL_INTERVAL);
3687 u64 now = get_jiffies_64();
3688 int *trials = void_arg;
3689
3690 if ((ent->eflags & ATA_EFLAG_OLD_ER) ||
3691 (ent->timestamp < now - min(now, interval)))
3692 return -1;
3693
3694 (*trials)++;
3695 return 0;
3696}
3697
3698static int ata_eh_schedule_probe(struct ata_device *dev)
3699{
3700 struct ata_eh_context *ehc = &dev->link->eh_context;
3701 struct ata_link *link = ata_dev_phys_link(dev);
3702 int trials = 0;
3703
3704 if (!(ehc->i.probe_mask & (1 << dev->devno)) ||
3705 (ehc->did_probe_mask & (1 << dev->devno)))
3706 return 0;
3707
3708 ata_eh_detach_dev(dev);
3709 ata_dev_init(dev);
3710 ehc->did_probe_mask |= (1 << dev->devno);
3711 ehc->i.action |= ATA_EH_RESET;
3712 ehc->saved_xfer_mode[dev->devno] = 0;
3713 ehc->saved_ncq_enabled &= ~(1 << dev->devno);
3714
3715
3716 if (link->lpm_policy > ATA_LPM_MAX_POWER) {
3717 if (ata_is_host_link(link))
3718 link->ap->ops->set_lpm(link, ATA_LPM_MAX_POWER,
3719 ATA_LPM_EMPTY);
3720 else
3721 sata_pmp_set_lpm(link, ATA_LPM_MAX_POWER,
3722 ATA_LPM_EMPTY);
3723 }
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738 ata_ering_record(&dev->ering, 0, AC_ERR_OTHER);
3739 ata_ering_map(&dev->ering, ata_count_probe_trials_cb, &trials);
3740
3741 if (trials > ATA_EH_PROBE_TRIALS)
3742 sata_down_spd_limit(link, 1);
3743
3744 return 1;
3745}
3746
3747static int ata_eh_handle_dev_fail(struct ata_device *dev, int err)
3748{
3749 struct ata_eh_context *ehc = &dev->link->eh_context;
3750
3751
3752
3753
3754 if (err != -EAGAIN)
3755 ehc->tries[dev->devno]--;
3756
3757 switch (err) {
3758 case -ENODEV:
3759
3760 ehc->i.probe_mask |= (1 << dev->devno);
3761 case -EINVAL:
3762
3763 ehc->tries[dev->devno] = min(ehc->tries[dev->devno], 1);
3764 case -EIO:
3765 if (ehc->tries[dev->devno] == 1) {
3766
3767
3768
3769 sata_down_spd_limit(ata_dev_phys_link(dev), 0);
3770 if (dev->pio_mode > XFER_PIO_0)
3771 ata_down_xfermask_limit(dev, ATA_DNXFER_PIO);
3772 }
3773 }
3774
3775 if (ata_dev_enabled(dev) && !ehc->tries[dev->devno]) {
3776
3777 ata_dev_disable(dev);
3778
3779
3780 if (ata_phys_link_offline(ata_dev_phys_link(dev)))
3781 ata_eh_detach_dev(dev);
3782
3783
3784 if (ata_eh_schedule_probe(dev)) {
3785 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
3786 memset(ehc->cmd_timeout_idx[dev->devno], 0,
3787 sizeof(ehc->cmd_timeout_idx[dev->devno]));
3788 }
3789
3790 return 1;
3791 } else {
3792 ehc->i.action |= ATA_EH_RESET;
3793 return 0;
3794 }
3795}
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
3820 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
3821 ata_postreset_fn_t postreset,
3822 struct ata_link **r_failed_link)
3823{
3824 struct ata_link *link;
3825 struct ata_device *dev;
3826 int rc, nr_fails;
3827 unsigned long flags, deadline;
3828
3829 DPRINTK("ENTER\n");
3830
3831
3832 ata_for_each_link(link, ap, EDGE) {
3833 struct ata_eh_context *ehc = &link->eh_context;
3834
3835
3836 if (ehc->i.action & ATA_EH_ENABLE_LINK) {
3837 ata_eh_about_to_do(link, NULL, ATA_EH_ENABLE_LINK);
3838 spin_lock_irqsave(ap->lock, flags);
3839 link->flags &= ~ATA_LFLAG_DISABLED;
3840 spin_unlock_irqrestore(ap->lock, flags);
3841 ata_eh_done(link, NULL, ATA_EH_ENABLE_LINK);
3842 }
3843
3844 ata_for_each_dev(dev, link, ALL) {
3845 if (link->flags & ATA_LFLAG_NO_RETRY)
3846 ehc->tries[dev->devno] = 1;
3847 else
3848 ehc->tries[dev->devno] = ATA_EH_DEV_TRIES;
3849
3850
3851 ehc->i.action |= ehc->i.dev_action[dev->devno] &
3852 ~ATA_EH_PERDEV_MASK;
3853 ehc->i.dev_action[dev->devno] &= ATA_EH_PERDEV_MASK;
3854
3855
3856 if (dev->flags & ATA_DFLAG_DETACH)
3857 ata_eh_detach_dev(dev);
3858
3859
3860 if (!ata_dev_enabled(dev))
3861 ata_eh_schedule_probe(dev);
3862 }
3863 }
3864
3865 retry:
3866 rc = 0;
3867
3868
3869 if (ap->pflags & ATA_PFLAG_UNLOADING)
3870 goto out;
3871
3872
3873 ata_for_each_link(link, ap, EDGE) {
3874 struct ata_eh_context *ehc = &link->eh_context;
3875
3876
3877 if (ata_eh_skip_recovery(link))
3878 ehc->i.action = 0;
3879
3880 ata_for_each_dev(dev, link, ALL)
3881 ehc->classes[dev->devno] = ATA_DEV_UNKNOWN;
3882 }
3883
3884
3885 ata_for_each_link(link, ap, EDGE) {
3886 struct ata_eh_context *ehc = &link->eh_context;
3887
3888 if (!(ehc->i.action & ATA_EH_RESET))
3889 continue;
3890
3891 rc = ata_eh_reset(link, ata_link_nr_vacant(link),
3892 prereset, softreset, hardreset, postreset);
3893 if (rc) {
3894 ata_link_err(link, "reset failed, giving up\n");
3895 goto out;
3896 }
3897 }
3898
3899 do {
3900 unsigned long now;
3901
3902
3903
3904
3905
3906 ata_eh_pull_park_action(ap);
3907
3908 deadline = jiffies;
3909 ata_for_each_link(link, ap, EDGE) {
3910 ata_for_each_dev(dev, link, ALL) {
3911 struct ata_eh_context *ehc = &link->eh_context;
3912 unsigned long tmp;
3913
3914 if (dev->class != ATA_DEV_ATA &&
3915 dev->class != ATA_DEV_ZAC)
3916 continue;
3917 if (!(ehc->i.dev_action[dev->devno] &
3918 ATA_EH_PARK))
3919 continue;
3920 tmp = dev->unpark_deadline;
3921 if (time_before(deadline, tmp))
3922 deadline = tmp;
3923 else if (time_before_eq(tmp, jiffies))
3924 continue;
3925 if (ehc->unloaded_mask & (1 << dev->devno))
3926 continue;
3927
3928 ata_eh_park_issue_cmd(dev, 1);
3929 }
3930 }
3931
3932 now = jiffies;
3933 if (time_before_eq(deadline, now))
3934 break;
3935
3936 ata_eh_release(ap);
3937 deadline = wait_for_completion_timeout(&ap->park_req_pending,
3938 deadline - now);
3939 ata_eh_acquire(ap);
3940 } while (deadline);
3941 ata_for_each_link(link, ap, EDGE) {
3942 ata_for_each_dev(dev, link, ALL) {
3943 if (!(link->eh_context.unloaded_mask &
3944 (1 << dev->devno)))
3945 continue;
3946
3947 ata_eh_park_issue_cmd(dev, 0);
3948 ata_eh_done(link, dev, ATA_EH_PARK);
3949 }
3950 }
3951
3952
3953 nr_fails = 0;
3954 ata_for_each_link(link, ap, PMP_FIRST) {
3955 struct ata_eh_context *ehc = &link->eh_context;
3956
3957 if (sata_pmp_attached(ap) && ata_is_host_link(link))
3958 goto config_lpm;
3959
3960
3961 rc = ata_eh_revalidate_and_attach(link, &dev);
3962 if (rc)
3963 goto rest_fail;
3964
3965
3966 if (link->device->class == ATA_DEV_PMP) {
3967 ehc->i.action = 0;
3968 return 0;
3969 }
3970
3971
3972 if (ehc->i.flags & ATA_EHI_SETMODE) {
3973 rc = ata_set_mode(link, &dev);
3974 if (rc)
3975 goto rest_fail;
3976 ehc->i.flags &= ~ATA_EHI_SETMODE;
3977 }
3978
3979
3980
3981
3982 if (ehc->i.flags & ATA_EHI_DID_RESET) {
3983 ata_for_each_dev(dev, link, ALL) {
3984 if (dev->class != ATA_DEV_ATAPI)
3985 continue;
3986 rc = atapi_eh_clear_ua(dev);
3987 if (rc)
3988 goto rest_fail;
3989 if (zpodd_dev_enabled(dev))
3990 zpodd_post_poweron(dev);
3991 }
3992 }
3993
3994
3995 ata_for_each_dev(dev, link, ALL) {
3996 if (dev->class != ATA_DEV_ATA &&
3997 dev->class != ATA_DEV_ZAC)
3998 continue;
3999 rc = ata_eh_maybe_retry_flush(dev);
4000 if (rc)
4001 goto rest_fail;
4002 }
4003
4004 config_lpm:
4005
4006 if (link->lpm_policy != ap->target_lpm_policy) {
4007 rc = ata_eh_set_lpm(link, ap->target_lpm_policy, &dev);
4008 if (rc)
4009 goto rest_fail;
4010 }
4011
4012
4013 ehc->i.flags = 0;
4014 continue;
4015
4016 rest_fail:
4017 nr_fails++;
4018 if (dev)
4019 ata_eh_handle_dev_fail(dev, rc);
4020
4021 if (ap->pflags & ATA_PFLAG_FROZEN) {
4022
4023
4024
4025 if (sata_pmp_attached(ap))
4026 goto out;
4027 break;
4028 }
4029 }
4030
4031 if (nr_fails)
4032 goto retry;
4033
4034 out:
4035 if (rc && r_failed_link)
4036 *r_failed_link = link;
4037
4038 DPRINTK("EXIT, rc=%d\n", rc);
4039 return rc;
4040}
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052void ata_eh_finish(struct ata_port *ap)
4053{
4054 int tag;
4055
4056
4057 for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
4058 struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
4059
4060 if (!(qc->flags & ATA_QCFLAG_FAILED))
4061 continue;
4062
4063 if (qc->err_mask) {
4064
4065
4066
4067
4068 if (qc->flags & ATA_QCFLAG_RETRY)
4069 ata_eh_qc_retry(qc);
4070 else
4071 ata_eh_qc_complete(qc);
4072 } else {
4073 if (qc->flags & ATA_QCFLAG_SENSE_VALID) {
4074 ata_eh_qc_complete(qc);
4075 } else {
4076
4077 memset(&qc->result_tf, 0, sizeof(qc->result_tf));
4078 ata_eh_qc_retry(qc);
4079 }
4080 }
4081 }
4082
4083
4084 WARN_ON(ap->nr_active_links);
4085 ap->nr_active_links = 0;
4086}
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098
4099
4100
4101
4102void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
4103 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
4104 ata_postreset_fn_t postreset)
4105{
4106 struct ata_device *dev;
4107 int rc;
4108
4109 ata_eh_autopsy(ap);
4110 ata_eh_report(ap);
4111
4112 rc = ata_eh_recover(ap, prereset, softreset, hardreset, postreset,
4113 NULL);
4114 if (rc) {
4115 ata_for_each_dev(dev, &ap->link, ALL)
4116 ata_dev_disable(dev);
4117 }
4118
4119 ata_eh_finish(ap);
4120}
4121
4122
4123
4124
4125
4126
4127
4128
4129
4130
4131void ata_std_error_handler(struct ata_port *ap)
4132{
4133 struct ata_port_operations *ops = ap->ops;
4134 ata_reset_fn_t hardreset = ops->hardreset;
4135
4136
4137 if (hardreset == sata_std_hardreset && !sata_scr_valid(&ap->link))
4138 hardreset = NULL;
4139
4140 ata_do_eh(ap, ops->prereset, ops->softreset, hardreset, ops->postreset);
4141}
4142
4143#ifdef CONFIG_PM
4144
4145
4146
4147
4148
4149
4150
4151
4152
4153static void ata_eh_handle_port_suspend(struct ata_port *ap)
4154{
4155 unsigned long flags;
4156 int rc = 0;
4157 struct ata_device *dev;
4158
4159
4160 spin_lock_irqsave(ap->lock, flags);
4161 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
4162 ap->pm_mesg.event & PM_EVENT_RESUME) {
4163 spin_unlock_irqrestore(ap->lock, flags);
4164 return;
4165 }
4166 spin_unlock_irqrestore(ap->lock, flags);
4167
4168 WARN_ON(ap->pflags & ATA_PFLAG_SUSPENDED);
4169
4170
4171
4172
4173
4174
4175 if (PMSG_IS_AUTO(ap->pm_mesg)) {
4176 ata_for_each_dev(dev, &ap->link, ENABLED) {
4177 if (zpodd_dev_enabled(dev))
4178 zpodd_on_suspend(dev);
4179 }
4180 }
4181
4182
4183 rc = ata_acpi_on_suspend(ap);
4184 if (rc)
4185 goto out;
4186
4187
4188 ata_eh_freeze_port(ap);
4189
4190 if (ap->ops->port_suspend)
4191 rc = ap->ops->port_suspend(ap, ap->pm_mesg);
4192
4193 ata_acpi_set_state(ap, ap->pm_mesg);
4194 out:
4195
4196 spin_lock_irqsave(ap->lock, flags);
4197
4198 ap->pflags &= ~ATA_PFLAG_PM_PENDING;
4199 if (rc == 0)
4200 ap->pflags |= ATA_PFLAG_SUSPENDED;
4201 else if (ap->pflags & ATA_PFLAG_FROZEN)
4202 ata_port_schedule_eh(ap);
4203
4204 spin_unlock_irqrestore(ap->lock, flags);
4205
4206 return;
4207}
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218static void ata_eh_handle_port_resume(struct ata_port *ap)
4219{
4220 struct ata_link *link;
4221 struct ata_device *dev;
4222 unsigned long flags;
4223 int rc = 0;
4224
4225
4226 spin_lock_irqsave(ap->lock, flags);
4227 if (!(ap->pflags & ATA_PFLAG_PM_PENDING) ||
4228 !(ap->pm_mesg.event & PM_EVENT_RESUME)) {
4229 spin_unlock_irqrestore(ap->lock, flags);
4230 return;
4231 }
4232 spin_unlock_irqrestore(ap->lock, flags);
4233
4234 WARN_ON(!(ap->pflags & ATA_PFLAG_SUSPENDED));
4235
4236
4237
4238
4239
4240
4241
4242
4243 ata_for_each_link(link, ap, HOST_FIRST)
4244 ata_for_each_dev(dev, link, ALL)
4245 ata_ering_clear(&dev->ering);
4246
4247 ata_acpi_set_state(ap, ap->pm_mesg);
4248
4249 if (ap->ops->port_resume)
4250 rc = ap->ops->port_resume(ap);
4251
4252
4253 ata_acpi_on_resume(ap);
4254
4255
4256 spin_lock_irqsave(ap->lock, flags);
4257 ap->pflags &= ~(ATA_PFLAG_PM_PENDING | ATA_PFLAG_SUSPENDED);
4258 spin_unlock_irqrestore(ap->lock, flags);
4259}
4260#endif
4261