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#include <linux/delay.h>
26#include <linux/interrupt.h>
27#include <linux/irq.h>
28#include <linux/module.h>
29#include <linux/pci.h>
30#include <asm/eeh.h>
31#include <asm/eeh_event.h>
32#include <asm/ppc-pci.h>
33#include <asm/pci-bridge.h>
34#include <asm/prom.h>
35#include <asm/rtas.h>
36
37struct eeh_rmv_data {
38 struct list_head edev_list;
39 int removed;
40};
41
42
43
44
45
46
47
48
49static inline const char *eeh_pcid_name(struct pci_dev *pdev)
50{
51 if (pdev && pdev->dev.driver)
52 return pdev->dev.driver->name;
53 return "";
54}
55
56
57
58
59
60
61
62
63
64
65static inline struct pci_driver *eeh_pcid_get(struct pci_dev *pdev)
66{
67 if (!pdev || !pdev->driver)
68 return NULL;
69
70 if (!try_module_get(pdev->driver->driver.owner))
71 return NULL;
72
73 return pdev->driver;
74}
75
76
77
78
79
80
81
82
83static inline void eeh_pcid_put(struct pci_dev *pdev)
84{
85 if (!pdev || !pdev->driver)
86 return;
87
88 module_put(pdev->driver->driver.owner);
89}
90
91
92
93
94
95
96
97
98
99
100
101static void eeh_disable_irq(struct pci_dev *dev)
102{
103 struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
104
105
106
107
108
109 if (dev->msi_enabled || dev->msix_enabled)
110 return;
111
112 if (!irq_has_action(dev->irq))
113 return;
114
115 edev->mode |= EEH_DEV_IRQ_DISABLED;
116 disable_irq_nosync(dev->irq);
117}
118
119
120
121
122
123
124
125
126static void eeh_enable_irq(struct pci_dev *dev)
127{
128 struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
129
130 if ((edev->mode) & EEH_DEV_IRQ_DISABLED) {
131 edev->mode &= ~EEH_DEV_IRQ_DISABLED;
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152 if (irqd_irq_disabled(irq_get_irq_data(dev->irq)))
153 enable_irq(dev->irq);
154 }
155}
156
157static bool eeh_dev_removed(struct eeh_dev *edev)
158{
159
160 if (!edev || (edev->mode & EEH_DEV_REMOVED))
161 return true;
162
163 return false;
164}
165
166static void *eeh_dev_save_state(void *data, void *userdata)
167{
168 struct eeh_dev *edev = data;
169 struct pci_dev *pdev;
170
171 if (!edev)
172 return NULL;
173
174
175
176
177
178
179
180
181 if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED))
182 return NULL;
183
184 pdev = eeh_dev_to_pci_dev(edev);
185 if (!pdev)
186 return NULL;
187
188 pci_save_state(pdev);
189 return NULL;
190}
191
192
193
194
195
196
197
198
199
200
201static void *eeh_report_error(void *data, void *userdata)
202{
203 struct eeh_dev *edev = (struct eeh_dev *)data;
204 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
205 enum pci_ers_result rc, *res = userdata;
206 struct pci_driver *driver;
207
208 if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
209 return NULL;
210 dev->error_state = pci_channel_io_frozen;
211
212 driver = eeh_pcid_get(dev);
213 if (!driver) return NULL;
214
215 eeh_disable_irq(dev);
216
217 if (!driver->err_handler ||
218 !driver->err_handler->error_detected) {
219 eeh_pcid_put(dev);
220 return NULL;
221 }
222
223 rc = driver->err_handler->error_detected(dev, pci_channel_io_frozen);
224
225
226 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
227 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
228
229 edev->in_error = true;
230 eeh_pcid_put(dev);
231 return NULL;
232}
233
234
235
236
237
238
239
240
241
242
243static void *eeh_report_mmio_enabled(void *data, void *userdata)
244{
245 struct eeh_dev *edev = (struct eeh_dev *)data;
246 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
247 enum pci_ers_result rc, *res = userdata;
248 struct pci_driver *driver;
249
250 if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
251 return NULL;
252
253 driver = eeh_pcid_get(dev);
254 if (!driver) return NULL;
255
256 if (!driver->err_handler ||
257 !driver->err_handler->mmio_enabled ||
258 (edev->mode & EEH_DEV_NO_HANDLER)) {
259 eeh_pcid_put(dev);
260 return NULL;
261 }
262
263 rc = driver->err_handler->mmio_enabled(dev);
264
265
266 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
267 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
268
269 eeh_pcid_put(dev);
270 return NULL;
271}
272
273
274
275
276
277
278
279
280
281
282
283static void *eeh_report_reset(void *data, void *userdata)
284{
285 struct eeh_dev *edev = (struct eeh_dev *)data;
286 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
287 enum pci_ers_result rc, *res = userdata;
288 struct pci_driver *driver;
289
290 if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
291 return NULL;
292 dev->error_state = pci_channel_io_normal;
293
294 driver = eeh_pcid_get(dev);
295 if (!driver) return NULL;
296
297 eeh_enable_irq(dev);
298
299 if (!driver->err_handler ||
300 !driver->err_handler->slot_reset ||
301 (edev->mode & EEH_DEV_NO_HANDLER) ||
302 (!edev->in_error)) {
303 eeh_pcid_put(dev);
304 return NULL;
305 }
306
307 rc = driver->err_handler->slot_reset(dev);
308 if ((*res == PCI_ERS_RESULT_NONE) ||
309 (*res == PCI_ERS_RESULT_RECOVERED)) *res = rc;
310 if (*res == PCI_ERS_RESULT_DISCONNECT &&
311 rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
312
313 eeh_pcid_put(dev);
314 return NULL;
315}
316
317static void *eeh_dev_restore_state(void *data, void *userdata)
318{
319 struct eeh_dev *edev = data;
320 struct pci_dev *pdev;
321
322 if (!edev)
323 return NULL;
324
325
326
327
328
329
330
331 if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED)) {
332 if (list_is_last(&edev->list, &edev->pe->edevs))
333 eeh_pe_restore_bars(edev->pe);
334
335 return NULL;
336 }
337
338 pdev = eeh_dev_to_pci_dev(edev);
339 if (!pdev)
340 return NULL;
341
342 pci_restore_state(pdev);
343 return NULL;
344}
345
346
347
348
349
350
351
352
353
354
355static void *eeh_report_resume(void *data, void *userdata)
356{
357 struct eeh_dev *edev = (struct eeh_dev *)data;
358 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
359 bool was_in_error;
360 struct pci_driver *driver;
361
362 if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
363 return NULL;
364 dev->error_state = pci_channel_io_normal;
365
366 driver = eeh_pcid_get(dev);
367 if (!driver) return NULL;
368
369 was_in_error = edev->in_error;
370 edev->in_error = false;
371 eeh_enable_irq(dev);
372
373 if (!driver->err_handler ||
374 !driver->err_handler->resume ||
375 (edev->mode & EEH_DEV_NO_HANDLER) || !was_in_error) {
376 edev->mode &= ~EEH_DEV_NO_HANDLER;
377 eeh_pcid_put(dev);
378 return NULL;
379 }
380
381 driver->err_handler->resume(dev);
382
383 eeh_pcid_put(dev);
384 return NULL;
385}
386
387
388
389
390
391
392
393
394
395static void *eeh_report_failure(void *data, void *userdata)
396{
397 struct eeh_dev *edev = (struct eeh_dev *)data;
398 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
399 struct pci_driver *driver;
400
401 if (!dev || eeh_dev_removed(edev) || eeh_pe_passed(edev->pe))
402 return NULL;
403 dev->error_state = pci_channel_io_perm_failure;
404
405 driver = eeh_pcid_get(dev);
406 if (!driver) return NULL;
407
408 eeh_disable_irq(dev);
409
410 if (!driver->err_handler ||
411 !driver->err_handler->error_detected) {
412 eeh_pcid_put(dev);
413 return NULL;
414 }
415
416 driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
417
418 eeh_pcid_put(dev);
419 return NULL;
420}
421
422static void *eeh_add_virt_device(void *data, void *userdata)
423{
424 struct pci_driver *driver;
425 struct eeh_dev *edev = (struct eeh_dev *)data;
426 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
427 struct pci_dn *pdn = eeh_dev_to_pdn(edev);
428
429 if (!(edev->physfn)) {
430 pr_warn("%s: EEH dev %04x:%02x:%02x.%01x not for VF\n",
431 __func__, edev->phb->global_number, pdn->busno,
432 PCI_SLOT(pdn->devfn), PCI_FUNC(pdn->devfn));
433 return NULL;
434 }
435
436 driver = eeh_pcid_get(dev);
437 if (driver) {
438 eeh_pcid_put(dev);
439 if (driver->err_handler)
440 return NULL;
441 }
442
443#ifdef CONFIG_PPC_POWERNV
444 pci_iov_add_virtfn(edev->physfn, pdn->vf_index, 0);
445#endif
446 return NULL;
447}
448
449static void *eeh_rmv_device(void *data, void *userdata)
450{
451 struct pci_driver *driver;
452 struct eeh_dev *edev = (struct eeh_dev *)data;
453 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
454 struct eeh_rmv_data *rmv_data = (struct eeh_rmv_data *)userdata;
455 int *removed = rmv_data ? &rmv_data->removed : NULL;
456
457
458
459
460
461
462
463
464 if (!dev || (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE))
465 return NULL;
466
467
468
469
470
471
472
473
474 if (eeh_dev_removed(edev))
475 return NULL;
476
477 driver = eeh_pcid_get(dev);
478 if (driver) {
479 eeh_pcid_put(dev);
480 if (removed &&
481 eeh_pe_passed(edev->pe))
482 return NULL;
483 if (removed &&
484 driver->err_handler &&
485 driver->err_handler->error_detected &&
486 driver->err_handler->slot_reset)
487 return NULL;
488 }
489
490
491 pr_debug("EEH: Removing %s without EEH sensitive driver\n",
492 pci_name(dev));
493 edev->bus = dev->bus;
494 edev->mode |= EEH_DEV_DISCONNECTED;
495 if (removed)
496 (*removed)++;
497
498 if (edev->physfn) {
499#ifdef CONFIG_PPC_POWERNV
500 struct pci_dn *pdn = eeh_dev_to_pdn(edev);
501
502 pci_iov_remove_virtfn(edev->physfn, pdn->vf_index, 0);
503 edev->pdev = NULL;
504
505
506
507
508
509 pdn->pe_number = IODA_INVALID_PE;
510#endif
511 if (rmv_data)
512 list_add(&edev->rmv_list, &rmv_data->edev_list);
513 } else {
514 pci_lock_rescan_remove();
515 pci_stop_and_remove_bus_device(dev);
516 pci_unlock_rescan_remove();
517 }
518
519 return NULL;
520}
521
522static void *eeh_pe_detach_dev(void *data, void *userdata)
523{
524 struct eeh_pe *pe = (struct eeh_pe *)data;
525 struct eeh_dev *edev, *tmp;
526
527 eeh_pe_for_each_dev(pe, edev, tmp) {
528 if (!(edev->mode & EEH_DEV_DISCONNECTED))
529 continue;
530
531 edev->mode &= ~(EEH_DEV_DISCONNECTED | EEH_DEV_IRQ_DISABLED);
532 eeh_rmv_from_parent_pe(edev);
533 }
534
535 return NULL;
536}
537
538
539
540
541
542
543
544
545static void *__eeh_clear_pe_frozen_state(void *data, void *flag)
546{
547 struct eeh_pe *pe = (struct eeh_pe *)data;
548 bool clear_sw_state = *(bool *)flag;
549 int i, rc = 1;
550
551 for (i = 0; rc && i < 3; i++)
552 rc = eeh_unfreeze_pe(pe, clear_sw_state);
553
554
555 if (rc) {
556 pr_warn("%s: Failure %d unfreezing PHB#%x-PE#%x\n",
557 __func__, rc, pe->phb->global_number, pe->addr);
558 return (void *)pe;
559 }
560
561 return NULL;
562}
563
564static int eeh_clear_pe_frozen_state(struct eeh_pe *pe,
565 bool clear_sw_state)
566{
567 void *rc;
568
569 rc = eeh_pe_traverse(pe, __eeh_clear_pe_frozen_state, &clear_sw_state);
570 if (!rc)
571 eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
572
573 return rc ? -EIO : 0;
574}
575
576int eeh_pe_reset_and_recover(struct eeh_pe *pe)
577{
578 int ret;
579
580
581 if (pe->state & EEH_PE_RECOVERING)
582 return 0;
583
584
585 eeh_pe_state_mark(pe, EEH_PE_RECOVERING);
586
587
588 eeh_pe_dev_traverse(pe, eeh_dev_save_state, NULL);
589
590
591 ret = eeh_pe_reset_full(pe);
592 if (ret) {
593 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
594 return ret;
595 }
596
597
598 ret = eeh_clear_pe_frozen_state(pe, true);
599 if (ret) {
600 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
601 return ret;
602 }
603
604
605 eeh_pe_dev_traverse(pe, eeh_dev_restore_state, NULL);
606
607
608 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
609
610 return 0;
611}
612
613
614
615
616
617
618
619
620
621
622static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,
623 struct eeh_rmv_data *rmv_data)
624{
625 struct pci_bus *frozen_bus = eeh_pe_bus_get(pe);
626 struct timeval tstamp;
627 int cnt, rc;
628 struct eeh_dev *edev;
629
630
631 cnt = pe->freeze_count;
632 tstamp = pe->tstamp;
633
634
635
636
637
638
639
640 eeh_pe_state_mark(pe, EEH_PE_KEEP);
641 if (bus) {
642 if (pe->type & EEH_PE_VF) {
643 eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
644 } else {
645 pci_lock_rescan_remove();
646 pci_hp_remove_devices(bus);
647 pci_unlock_rescan_remove();
648 }
649 } else if (frozen_bus) {
650 eeh_pe_dev_traverse(pe, eeh_rmv_device, rmv_data);
651 }
652
653
654
655
656
657
658
659
660
661
662 rc = eeh_pe_reset_full(pe);
663 if (rc)
664 return rc;
665
666 pci_lock_rescan_remove();
667
668
669 eeh_ops->configure_bridge(pe);
670 eeh_pe_restore_bars(pe);
671
672
673 rc = eeh_clear_pe_frozen_state(pe, false);
674 if (rc) {
675 pci_unlock_rescan_remove();
676 return rc;
677 }
678
679
680
681
682
683
684
685 if (bus) {
686 pr_info("EEH: Sleep 5s ahead of complete hotplug\n");
687 ssleep(5);
688
689
690
691
692
693
694 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
695 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
696 if (pe->type & EEH_PE_VF) {
697 eeh_add_virt_device(edev, NULL);
698 } else {
699 eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
700 pci_hp_add_devices(bus);
701 }
702 } else if (frozen_bus && rmv_data->removed) {
703 pr_info("EEH: Sleep 5s ahead of partial hotplug\n");
704 ssleep(5);
705
706 edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
707 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
708 if (pe->type & EEH_PE_VF)
709 eeh_add_virt_device(edev, NULL);
710 else
711 pci_hp_add_devices(frozen_bus);
712 }
713 eeh_pe_state_clear(pe, EEH_PE_KEEP);
714
715 pe->tstamp = tstamp;
716 pe->freeze_count = cnt;
717
718 pci_unlock_rescan_remove();
719 return 0;
720}
721
722
723
724
725#define MAX_WAIT_FOR_RECOVERY 300
726
727static void eeh_handle_normal_event(struct eeh_pe *pe)
728{
729 struct pci_bus *frozen_bus;
730 struct eeh_dev *edev, *tmp;
731 int rc = 0;
732 enum pci_ers_result result = PCI_ERS_RESULT_NONE;
733 struct eeh_rmv_data rmv_data = {LIST_HEAD_INIT(rmv_data.edev_list), 0};
734
735 frozen_bus = eeh_pe_bus_get(pe);
736 if (!frozen_bus) {
737 pr_err("%s: Cannot find PCI bus for PHB#%x-PE#%x\n",
738 __func__, pe->phb->global_number, pe->addr);
739 return;
740 }
741
742 eeh_pe_update_time_stamp(pe);
743 pe->freeze_count++;
744 if (pe->freeze_count > eeh_max_freezes)
745 goto excess_failures;
746 pr_warn("EEH: This PCI device has failed %d times in the last hour\n",
747 pe->freeze_count);
748
749
750
751
752
753
754
755
756
757
758
759 pr_info("EEH: Notify device drivers to shutdown\n");
760 eeh_pe_dev_traverse(pe, eeh_report_error, &result);
761 if ((pe->type & EEH_PE_PHB) &&
762 result != PCI_ERS_RESULT_NONE &&
763 result != PCI_ERS_RESULT_NEED_RESET)
764 result = PCI_ERS_RESULT_NEED_RESET;
765
766
767
768
769 rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
770 if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
771 pr_warn("EEH: Permanent failure\n");
772 goto hard_fail;
773 }
774
775
776
777
778
779 pr_info("EEH: Collect temporary log\n");
780 eeh_slot_error_detail(pe, EEH_LOG_TEMP);
781
782
783
784
785
786 if (result == PCI_ERS_RESULT_NONE) {
787 pr_info("EEH: Reset with hotplug activity\n");
788 rc = eeh_reset_device(pe, frozen_bus, NULL);
789 if (rc) {
790 pr_warn("%s: Unable to reset, err=%d\n",
791 __func__, rc);
792 goto hard_fail;
793 }
794 }
795
796
797 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
798 pr_info("EEH: Enable I/O for affected devices\n");
799 rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
800
801 if (rc < 0)
802 goto hard_fail;
803 if (rc) {
804 result = PCI_ERS_RESULT_NEED_RESET;
805 } else {
806 pr_info("EEH: Notify device drivers to resume I/O\n");
807 eeh_pe_dev_traverse(pe, eeh_report_mmio_enabled, &result);
808 }
809 }
810
811
812 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
813 pr_info("EEH: Enabled DMA for affected devices\n");
814 rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
815
816 if (rc < 0)
817 goto hard_fail;
818 if (rc) {
819 result = PCI_ERS_RESULT_NEED_RESET;
820 } else {
821
822
823
824
825
826 eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
827 result = PCI_ERS_RESULT_RECOVERED;
828 }
829 }
830
831
832 if (result == PCI_ERS_RESULT_DISCONNECT) {
833 pr_warn("EEH: Device driver gave up\n");
834 goto hard_fail;
835 }
836
837
838 if (result == PCI_ERS_RESULT_NEED_RESET) {
839 pr_info("EEH: Reset without hotplug activity\n");
840 rc = eeh_reset_device(pe, NULL, &rmv_data);
841 if (rc) {
842 pr_warn("%s: Cannot reset, err=%d\n",
843 __func__, rc);
844 goto hard_fail;
845 }
846
847 pr_info("EEH: Notify device drivers "
848 "the completion of reset\n");
849 result = PCI_ERS_RESULT_NONE;
850 eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
851 }
852
853
854 if ((result != PCI_ERS_RESULT_RECOVERED) &&
855 (result != PCI_ERS_RESULT_NONE)) {
856 pr_warn("EEH: Not recovered\n");
857 goto hard_fail;
858 }
859
860
861
862
863
864 list_for_each_entry_safe(edev, tmp, &rmv_data.edev_list, rmv_list) {
865 eeh_add_virt_device(edev, NULL);
866 list_del(&edev->rmv_list);
867 }
868
869
870 pr_info("EEH: Notify device driver to resume\n");
871 eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
872
873 return;
874
875excess_failures:
876
877
878
879
880
881 pr_err("EEH: PHB#%x-PE#%x has failed %d times in the\n"
882 "last hour and has been permanently disabled.\n"
883 "Please try reseating or replacing it.\n",
884 pe->phb->global_number, pe->addr,
885 pe->freeze_count);
886 goto perm_error;
887
888hard_fail:
889 pr_err("EEH: Unable to recover from failure from PHB#%x-PE#%x.\n"
890 "Please try reseating or replacing it\n",
891 pe->phb->global_number, pe->addr);
892
893perm_error:
894 eeh_slot_error_detail(pe, EEH_LOG_PERM);
895
896
897 eeh_pe_dev_traverse(pe, eeh_report_failure, NULL);
898
899
900 eeh_pe_state_mark(pe, EEH_PE_REMOVED);
901
902
903
904
905
906
907 if (frozen_bus) {
908 if (pe->type & EEH_PE_VF) {
909 eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
910 eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
911 } else {
912 eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
913 eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
914
915 pci_lock_rescan_remove();
916 pci_hp_remove_devices(frozen_bus);
917 pci_unlock_rescan_remove();
918 }
919 }
920}
921
922static void eeh_handle_special_event(void)
923{
924 struct eeh_pe *pe, *phb_pe;
925 struct pci_bus *bus;
926 struct pci_controller *hose;
927 unsigned long flags;
928 int rc;
929
930
931 do {
932 rc = eeh_ops->next_error(&pe);
933
934 switch (rc) {
935 case EEH_NEXT_ERR_DEAD_IOC:
936
937 eeh_serialize_lock(&flags);
938
939
940 eeh_remove_event(NULL, true);
941
942 list_for_each_entry(hose, &hose_list, list_node) {
943 phb_pe = eeh_phb_pe_get(hose);
944 if (!phb_pe) continue;
945
946 eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
947 }
948
949 eeh_serialize_unlock(flags);
950
951 break;
952 case EEH_NEXT_ERR_FROZEN_PE:
953 case EEH_NEXT_ERR_FENCED_PHB:
954 case EEH_NEXT_ERR_DEAD_PHB:
955
956 eeh_serialize_lock(&flags);
957
958
959 eeh_remove_event(pe, true);
960
961 if (rc == EEH_NEXT_ERR_DEAD_PHB)
962 eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
963 else
964 eeh_pe_state_mark(pe,
965 EEH_PE_ISOLATED | EEH_PE_RECOVERING);
966
967 eeh_serialize_unlock(flags);
968
969 break;
970 case EEH_NEXT_ERR_NONE:
971 return;
972 default:
973 pr_warn("%s: Invalid value %d from next_error()\n",
974 __func__, rc);
975 return;
976 }
977
978
979
980
981
982
983 if (rc == EEH_NEXT_ERR_FROZEN_PE ||
984 rc == EEH_NEXT_ERR_FENCED_PHB) {
985 eeh_handle_normal_event(pe);
986 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
987 } else {
988 pci_lock_rescan_remove();
989 list_for_each_entry(hose, &hose_list, list_node) {
990 phb_pe = eeh_phb_pe_get(hose);
991 if (!phb_pe ||
992 !(phb_pe->state & EEH_PE_ISOLATED) ||
993 (phb_pe->state & EEH_PE_RECOVERING))
994 continue;
995
996
997 eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
998 eeh_pe_dev_traverse(pe,
999 eeh_report_failure, NULL);
1000 bus = eeh_pe_bus_get(phb_pe);
1001 if (!bus) {
1002 pr_err("%s: Cannot find PCI bus for "
1003 "PHB#%x-PE#%x\n",
1004 __func__,
1005 pe->phb->global_number,
1006 pe->addr);
1007 break;
1008 }
1009 pci_hp_remove_devices(bus);
1010 }
1011 pci_unlock_rescan_remove();
1012 }
1013
1014
1015
1016
1017
1018 if (rc == EEH_NEXT_ERR_DEAD_IOC)
1019 break;
1020 } while (rc != EEH_NEXT_ERR_NONE);
1021}
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040void eeh_handle_event(struct eeh_pe *pe)
1041{
1042 if (pe)
1043 eeh_handle_normal_event(pe);
1044 else
1045 eeh_handle_special_event();
1046}
1047