]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - arch/powerpc/kernel/eeh_driver.c
89eb4bc34d3a8934a0a15c4d2c428f373e5eb0ba
[mirror_ubuntu-bionic-kernel.git] / arch / powerpc / kernel / eeh_driver.c
1 /*
2 * PCI Error Recovery Driver for RPA-compliant PPC64 platform.
3 * Copyright IBM Corp. 2004 2005
4 * Copyright Linas Vepstas <linas@linas.org> 2004, 2005
5 *
6 * All rights reserved.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or (at
11 * your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
16 * NON INFRINGEMENT. See the GNU General Public License for more
17 * details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 * Send comments and feedback to Linas Vepstas <linas@austin.ibm.com>
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
37 /**
38 * eeh_pcid_name - Retrieve name of PCI device driver
39 * @pdev: PCI device
40 *
41 * This routine is used to retrieve the name of PCI device driver
42 * if that's valid.
43 */
44 static inline const char *eeh_pcid_name(struct pci_dev *pdev)
45 {
46 if (pdev && pdev->dev.driver)
47 return pdev->dev.driver->name;
48 return "";
49 }
50
51 /**
52 * eeh_pcid_get - Get the PCI device driver
53 * @pdev: PCI device
54 *
55 * The function is used to retrieve the PCI device driver for
56 * the indicated PCI device. Besides, we will increase the reference
57 * of the PCI device driver to prevent that being unloaded on
58 * the fly. Otherwise, kernel crash would be seen.
59 */
60 static inline struct pci_driver *eeh_pcid_get(struct pci_dev *pdev)
61 {
62 if (!pdev || !pdev->driver)
63 return NULL;
64
65 if (!try_module_get(pdev->driver->driver.owner))
66 return NULL;
67
68 return pdev->driver;
69 }
70
71 /**
72 * eeh_pcid_put - Dereference on the PCI device driver
73 * @pdev: PCI device
74 *
75 * The function is called to do dereference on the PCI device
76 * driver of the indicated PCI device.
77 */
78 static inline void eeh_pcid_put(struct pci_dev *pdev)
79 {
80 if (!pdev || !pdev->driver)
81 return;
82
83 module_put(pdev->driver->driver.owner);
84 }
85
86 /**
87 * eeh_disable_irq - Disable interrupt for the recovering device
88 * @dev: PCI device
89 *
90 * This routine must be called when reporting temporary or permanent
91 * error to the particular PCI device to disable interrupt of that
92 * device. If the device has enabled MSI or MSI-X interrupt, we needn't
93 * do real work because EEH should freeze DMA transfers for those PCI
94 * devices encountering EEH errors, which includes MSI or MSI-X.
95 */
96 static void eeh_disable_irq(struct pci_dev *dev)
97 {
98 struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
99
100 /* Don't disable MSI and MSI-X interrupts. They are
101 * effectively disabled by the DMA Stopped state
102 * when an EEH error occurs.
103 */
104 if (dev->msi_enabled || dev->msix_enabled)
105 return;
106
107 if (!irq_has_action(dev->irq))
108 return;
109
110 edev->mode |= EEH_DEV_IRQ_DISABLED;
111 disable_irq_nosync(dev->irq);
112 }
113
114 /**
115 * eeh_enable_irq - Enable interrupt for the recovering device
116 * @dev: PCI device
117 *
118 * This routine must be called to enable interrupt while failed
119 * device could be resumed.
120 */
121 static void eeh_enable_irq(struct pci_dev *dev)
122 {
123 struct eeh_dev *edev = pci_dev_to_eeh_dev(dev);
124
125 if ((edev->mode) & EEH_DEV_IRQ_DISABLED) {
126 edev->mode &= ~EEH_DEV_IRQ_DISABLED;
127 /*
128 * FIXME !!!!!
129 *
130 * This is just ass backwards. This maze has
131 * unbalanced irq_enable/disable calls. So instead of
132 * finding the root cause it works around the warning
133 * in the irq_enable code by conditionally calling
134 * into it.
135 *
136 * That's just wrong.The warning in the core code is
137 * there to tell people to fix their assymetries in
138 * their own code, not by abusing the core information
139 * to avoid it.
140 *
141 * I so wish that the assymetry would be the other way
142 * round and a few more irq_disable calls render that
143 * shit unusable forever.
144 *
145 * tglx
146 */
147 if (irqd_irq_disabled(irq_get_irq_data(dev->irq)))
148 enable_irq(dev->irq);
149 }
150 }
151
152 static bool eeh_dev_removed(struct eeh_dev *edev)
153 {
154 /* EEH device removed ? */
155 if (!edev || (edev->mode & EEH_DEV_REMOVED))
156 return true;
157
158 return false;
159 }
160
161 static void *eeh_dev_save_state(void *data, void *userdata)
162 {
163 struct eeh_dev *edev = data;
164 struct pci_dev *pdev;
165
166 if (!edev)
167 return NULL;
168
169 pdev = eeh_dev_to_pci_dev(edev);
170 if (!pdev)
171 return NULL;
172
173 pci_save_state(pdev);
174 return NULL;
175 }
176
177 /**
178 * eeh_report_error - Report pci error to each device driver
179 * @data: eeh device
180 * @userdata: return value
181 *
182 * Report an EEH error to each device driver, collect up and
183 * merge the device driver responses. Cumulative response
184 * passed back in "userdata".
185 */
186 static void *eeh_report_error(void *data, void *userdata)
187 {
188 struct eeh_dev *edev = (struct eeh_dev *)data;
189 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
190 enum pci_ers_result rc, *res = userdata;
191 struct pci_driver *driver;
192
193 if (!dev || eeh_dev_removed(edev))
194 return NULL;
195 dev->error_state = pci_channel_io_frozen;
196
197 driver = eeh_pcid_get(dev);
198 if (!driver) return NULL;
199
200 eeh_disable_irq(dev);
201
202 if (!driver->err_handler ||
203 !driver->err_handler->error_detected) {
204 eeh_pcid_put(dev);
205 return NULL;
206 }
207
208 rc = driver->err_handler->error_detected(dev, pci_channel_io_frozen);
209
210 /* A driver that needs a reset trumps all others */
211 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
212 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
213
214 eeh_pcid_put(dev);
215 return NULL;
216 }
217
218 /**
219 * eeh_report_mmio_enabled - Tell drivers that MMIO has been enabled
220 * @data: eeh device
221 * @userdata: return value
222 *
223 * Tells each device driver that IO ports, MMIO and config space I/O
224 * are now enabled. Collects up and merges the device driver responses.
225 * Cumulative response passed back in "userdata".
226 */
227 static void *eeh_report_mmio_enabled(void *data, void *userdata)
228 {
229 struct eeh_dev *edev = (struct eeh_dev *)data;
230 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
231 enum pci_ers_result rc, *res = userdata;
232 struct pci_driver *driver;
233
234 if (!dev || eeh_dev_removed(edev))
235 return NULL;
236
237 driver = eeh_pcid_get(dev);
238 if (!driver) return NULL;
239
240 if (!driver->err_handler ||
241 !driver->err_handler->mmio_enabled ||
242 (edev->mode & EEH_DEV_NO_HANDLER)) {
243 eeh_pcid_put(dev);
244 return NULL;
245 }
246
247 rc = driver->err_handler->mmio_enabled(dev);
248
249 /* A driver that needs a reset trumps all others */
250 if (rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
251 if (*res == PCI_ERS_RESULT_NONE) *res = rc;
252
253 eeh_pcid_put(dev);
254 return NULL;
255 }
256
257 /**
258 * eeh_report_reset - Tell device that slot has been reset
259 * @data: eeh device
260 * @userdata: return value
261 *
262 * This routine must be called while EEH tries to reset particular
263 * PCI device so that the associated PCI device driver could take
264 * some actions, usually to save data the driver needs so that the
265 * driver can work again while the device is recovered.
266 */
267 static void *eeh_report_reset(void *data, void *userdata)
268 {
269 struct eeh_dev *edev = (struct eeh_dev *)data;
270 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
271 enum pci_ers_result rc, *res = userdata;
272 struct pci_driver *driver;
273
274 if (!dev || eeh_dev_removed(edev))
275 return NULL;
276 dev->error_state = pci_channel_io_normal;
277
278 driver = eeh_pcid_get(dev);
279 if (!driver) return NULL;
280
281 eeh_enable_irq(dev);
282
283 if (!driver->err_handler ||
284 !driver->err_handler->slot_reset ||
285 (edev->mode & EEH_DEV_NO_HANDLER)) {
286 eeh_pcid_put(dev);
287 return NULL;
288 }
289
290 rc = driver->err_handler->slot_reset(dev);
291 if ((*res == PCI_ERS_RESULT_NONE) ||
292 (*res == PCI_ERS_RESULT_RECOVERED)) *res = rc;
293 if (*res == PCI_ERS_RESULT_DISCONNECT &&
294 rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
295
296 eeh_pcid_put(dev);
297 return NULL;
298 }
299
300 static void *eeh_dev_restore_state(void *data, void *userdata)
301 {
302 struct eeh_dev *edev = data;
303 struct pci_dev *pdev;
304
305 if (!edev)
306 return NULL;
307
308 pdev = eeh_dev_to_pci_dev(edev);
309 if (!pdev)
310 return NULL;
311
312 pci_restore_state(pdev);
313 return NULL;
314 }
315
316 /**
317 * eeh_report_resume - Tell device to resume normal operations
318 * @data: eeh device
319 * @userdata: return value
320 *
321 * This routine must be called to notify the device driver that it
322 * could resume so that the device driver can do some initialization
323 * to make the recovered device work again.
324 */
325 static void *eeh_report_resume(void *data, void *userdata)
326 {
327 struct eeh_dev *edev = (struct eeh_dev *)data;
328 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
329 struct pci_driver *driver;
330
331 if (!dev || eeh_dev_removed(edev))
332 return NULL;
333 dev->error_state = pci_channel_io_normal;
334
335 driver = eeh_pcid_get(dev);
336 if (!driver) return NULL;
337
338 eeh_enable_irq(dev);
339
340 if (!driver->err_handler ||
341 !driver->err_handler->resume ||
342 (edev->mode & EEH_DEV_NO_HANDLER)) {
343 edev->mode &= ~EEH_DEV_NO_HANDLER;
344 eeh_pcid_put(dev);
345 return NULL;
346 }
347
348 driver->err_handler->resume(dev);
349
350 eeh_pcid_put(dev);
351 return NULL;
352 }
353
354 /**
355 * eeh_report_failure - Tell device driver that device is dead.
356 * @data: eeh device
357 * @userdata: return value
358 *
359 * This informs the device driver that the device is permanently
360 * dead, and that no further recovery attempts will be made on it.
361 */
362 static void *eeh_report_failure(void *data, void *userdata)
363 {
364 struct eeh_dev *edev = (struct eeh_dev *)data;
365 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
366 struct pci_driver *driver;
367
368 if (!dev || eeh_dev_removed(edev))
369 return NULL;
370 dev->error_state = pci_channel_io_perm_failure;
371
372 driver = eeh_pcid_get(dev);
373 if (!driver) return NULL;
374
375 eeh_disable_irq(dev);
376
377 if (!driver->err_handler ||
378 !driver->err_handler->error_detected) {
379 eeh_pcid_put(dev);
380 return NULL;
381 }
382
383 driver->err_handler->error_detected(dev, pci_channel_io_perm_failure);
384
385 eeh_pcid_put(dev);
386 return NULL;
387 }
388
389 static void *eeh_rmv_device(void *data, void *userdata)
390 {
391 struct pci_driver *driver;
392 struct eeh_dev *edev = (struct eeh_dev *)data;
393 struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
394 int *removed = (int *)userdata;
395
396 /*
397 * Actually, we should remove the PCI bridges as well.
398 * However, that's lots of complexity to do that,
399 * particularly some of devices under the bridge might
400 * support EEH. So we just care about PCI devices for
401 * simplicity here.
402 */
403 if (!dev || (dev->hdr_type & PCI_HEADER_TYPE_BRIDGE))
404 return NULL;
405
406 /*
407 * We rely on count-based pcibios_release_device() to
408 * detach permanently offlined PEs. Unfortunately, that's
409 * not reliable enough. We might have the permanently
410 * offlined PEs attached, but we needn't take care of
411 * them and their child devices.
412 */
413 if (eeh_dev_removed(edev))
414 return NULL;
415
416 driver = eeh_pcid_get(dev);
417 if (driver) {
418 eeh_pcid_put(dev);
419 if (driver->err_handler)
420 return NULL;
421 }
422
423 /* Remove it from PCI subsystem */
424 pr_debug("EEH: Removing %s without EEH sensitive driver\n",
425 pci_name(dev));
426 edev->bus = dev->bus;
427 edev->mode |= EEH_DEV_DISCONNECTED;
428 (*removed)++;
429
430 pci_lock_rescan_remove();
431 pci_stop_and_remove_bus_device(dev);
432 pci_unlock_rescan_remove();
433
434 return NULL;
435 }
436
437 static void *eeh_pe_detach_dev(void *data, void *userdata)
438 {
439 struct eeh_pe *pe = (struct eeh_pe *)data;
440 struct eeh_dev *edev, *tmp;
441
442 eeh_pe_for_each_dev(pe, edev, tmp) {
443 if (!(edev->mode & EEH_DEV_DISCONNECTED))
444 continue;
445
446 edev->mode &= ~(EEH_DEV_DISCONNECTED | EEH_DEV_IRQ_DISABLED);
447 eeh_rmv_from_parent_pe(edev);
448 }
449
450 return NULL;
451 }
452
453 /*
454 * Explicitly clear PE's frozen state for PowerNV where
455 * we have frozen PE until BAR restore is completed. It's
456 * harmless to clear it for pSeries. To be consistent with
457 * PE reset (for 3 times), we try to clear the frozen state
458 * for 3 times as well.
459 */
460 static void *__eeh_clear_pe_frozen_state(void *data, void *flag)
461 {
462 struct eeh_pe *pe = (struct eeh_pe *)data;
463 bool *clear_sw_state = flag;
464 int i, rc = 1;
465
466 for (i = 0; rc && i < 3; i++)
467 rc = eeh_unfreeze_pe(pe, clear_sw_state);
468
469 /* Stop immediately on any errors */
470 if (rc) {
471 pr_warn("%s: Failure %d unfreezing PHB#%x-PE#%x\n",
472 __func__, rc, pe->phb->global_number, pe->addr);
473 return (void *)pe;
474 }
475
476 return NULL;
477 }
478
479 static int eeh_clear_pe_frozen_state(struct eeh_pe *pe,
480 bool clear_sw_state)
481 {
482 void *rc;
483
484 rc = eeh_pe_traverse(pe, __eeh_clear_pe_frozen_state, &clear_sw_state);
485 if (!rc)
486 eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
487
488 return rc ? -EIO : 0;
489 }
490
491 int eeh_pe_reset_and_recover(struct eeh_pe *pe)
492 {
493 int result, ret;
494
495 /* Bail if the PE is being recovered */
496 if (pe->state & EEH_PE_RECOVERING)
497 return 0;
498
499 /* Put the PE into recovery mode */
500 eeh_pe_state_mark(pe, EEH_PE_RECOVERING);
501
502 /* Save states */
503 eeh_pe_dev_traverse(pe, eeh_dev_save_state, NULL);
504
505 /* Report error */
506 eeh_pe_dev_traverse(pe, eeh_report_error, &result);
507
508 /* Issue reset */
509 ret = eeh_reset_pe(pe);
510 if (ret) {
511 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
512 return ret;
513 }
514
515 /* Unfreeze the PE */
516 ret = eeh_clear_pe_frozen_state(pe, true);
517 if (ret) {
518 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
519 return ret;
520 }
521
522 /* Notify completion of reset */
523 eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
524
525 /* Restore device state */
526 eeh_pe_dev_traverse(pe, eeh_dev_restore_state, NULL);
527
528 /* Resume */
529 eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
530
531 /* Clear recovery mode */
532 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
533
534 return 0;
535 }
536
537 /**
538 * eeh_reset_device - Perform actual reset of a pci slot
539 * @pe: EEH PE
540 * @bus: PCI bus corresponding to the isolcated slot
541 *
542 * This routine must be called to do reset on the indicated PE.
543 * During the reset, udev might be invoked because those affected
544 * PCI devices will be removed and then added.
545 */
546 static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus)
547 {
548 struct pci_bus *frozen_bus = eeh_pe_bus_get(pe);
549 struct timeval tstamp;
550 int cnt, rc, removed = 0;
551
552 /* pcibios will clear the counter; save the value */
553 cnt = pe->freeze_count;
554 tstamp = pe->tstamp;
555
556 /*
557 * We don't remove the corresponding PE instances because
558 * we need the information afterwords. The attached EEH
559 * devices are expected to be attached soon when calling
560 * into pcibios_add_pci_devices().
561 */
562 eeh_pe_state_mark(pe, EEH_PE_KEEP);
563 if (bus) {
564 pci_lock_rescan_remove();
565 pcibios_remove_pci_devices(bus);
566 pci_unlock_rescan_remove();
567 } else if (frozen_bus) {
568 eeh_pe_dev_traverse(pe, eeh_rmv_device, &removed);
569 }
570
571 /*
572 * Reset the pci controller. (Asserts RST#; resets config space).
573 * Reconfigure bridges and devices. Don't try to bring the system
574 * up if the reset failed for some reason.
575 *
576 * During the reset, it's very dangerous to have uncontrolled PCI
577 * config accesses. So we prefer to block them. However, controlled
578 * PCI config accesses initiated from EEH itself are allowed.
579 */
580 rc = eeh_reset_pe(pe);
581 if (rc)
582 return rc;
583
584 pci_lock_rescan_remove();
585
586 /* Restore PE */
587 eeh_ops->configure_bridge(pe);
588 eeh_pe_restore_bars(pe);
589
590 /* Clear frozen state */
591 rc = eeh_clear_pe_frozen_state(pe, false);
592 if (rc)
593 return rc;
594
595 /* Give the system 5 seconds to finish running the user-space
596 * hotplug shutdown scripts, e.g. ifdown for ethernet. Yes,
597 * this is a hack, but if we don't do this, and try to bring
598 * the device up before the scripts have taken it down,
599 * potentially weird things happen.
600 */
601 if (bus) {
602 pr_info("EEH: Sleep 5s ahead of complete hotplug\n");
603 ssleep(5);
604
605 /*
606 * The EEH device is still connected with its parent
607 * PE. We should disconnect it so the binding can be
608 * rebuilt when adding PCI devices.
609 */
610 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
611 pcibios_add_pci_devices(bus);
612 } else if (frozen_bus && removed) {
613 pr_info("EEH: Sleep 5s ahead of partial hotplug\n");
614 ssleep(5);
615
616 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
617 pcibios_add_pci_devices(frozen_bus);
618 }
619 eeh_pe_state_clear(pe, EEH_PE_KEEP);
620
621 pe->tstamp = tstamp;
622 pe->freeze_count = cnt;
623
624 pci_unlock_rescan_remove();
625 return 0;
626 }
627
628 /* The longest amount of time to wait for a pci device
629 * to come back on line, in seconds.
630 */
631 #define MAX_WAIT_FOR_RECOVERY 300
632
633 static void eeh_handle_normal_event(struct eeh_pe *pe)
634 {
635 struct pci_bus *frozen_bus;
636 int rc = 0;
637 enum pci_ers_result result = PCI_ERS_RESULT_NONE;
638
639 frozen_bus = eeh_pe_bus_get(pe);
640 if (!frozen_bus) {
641 pr_err("%s: Cannot find PCI bus for PHB#%d-PE#%x\n",
642 __func__, pe->phb->global_number, pe->addr);
643 return;
644 }
645
646 eeh_pe_update_time_stamp(pe);
647 pe->freeze_count++;
648 if (pe->freeze_count > eeh_max_freezes)
649 goto excess_failures;
650 pr_warn("EEH: This PCI device has failed %d times in the last hour\n",
651 pe->freeze_count);
652
653 /* Walk the various device drivers attached to this slot through
654 * a reset sequence, giving each an opportunity to do what it needs
655 * to accomplish the reset. Each child gets a report of the
656 * status ... if any child can't handle the reset, then the entire
657 * slot is dlpar removed and added.
658 */
659 pr_info("EEH: Notify device drivers to shutdown\n");
660 eeh_pe_dev_traverse(pe, eeh_report_error, &result);
661
662 /* Get the current PCI slot state. This can take a long time,
663 * sometimes over 300 seconds for certain systems.
664 */
665 rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
666 if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
667 pr_warn("EEH: Permanent failure\n");
668 goto hard_fail;
669 }
670
671 /* Since rtas may enable MMIO when posting the error log,
672 * don't post the error log until after all dev drivers
673 * have been informed.
674 */
675 pr_info("EEH: Collect temporary log\n");
676 eeh_slot_error_detail(pe, EEH_LOG_TEMP);
677
678 /* If all device drivers were EEH-unaware, then shut
679 * down all of the device drivers, and hope they
680 * go down willingly, without panicing the system.
681 */
682 if (result == PCI_ERS_RESULT_NONE) {
683 pr_info("EEH: Reset with hotplug activity\n");
684 rc = eeh_reset_device(pe, frozen_bus);
685 if (rc) {
686 pr_warn("%s: Unable to reset, err=%d\n",
687 __func__, rc);
688 goto hard_fail;
689 }
690 }
691
692 /* If all devices reported they can proceed, then re-enable MMIO */
693 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
694 pr_info("EEH: Enable I/O for affected devices\n");
695 rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
696
697 if (rc < 0)
698 goto hard_fail;
699 if (rc) {
700 result = PCI_ERS_RESULT_NEED_RESET;
701 } else {
702 pr_info("EEH: Notify device drivers to resume I/O\n");
703 eeh_pe_dev_traverse(pe, eeh_report_mmio_enabled, &result);
704 }
705 }
706
707 /* If all devices reported they can proceed, then re-enable DMA */
708 if (result == PCI_ERS_RESULT_CAN_RECOVER) {
709 pr_info("EEH: Enabled DMA for affected devices\n");
710 rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
711
712 if (rc < 0)
713 goto hard_fail;
714 if (rc) {
715 result = PCI_ERS_RESULT_NEED_RESET;
716 } else {
717 /*
718 * We didn't do PE reset for the case. The PE
719 * is still in frozen state. Clear it before
720 * resuming the PE.
721 */
722 eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
723 result = PCI_ERS_RESULT_RECOVERED;
724 }
725 }
726
727 /* If any device has a hard failure, then shut off everything. */
728 if (result == PCI_ERS_RESULT_DISCONNECT) {
729 pr_warn("EEH: Device driver gave up\n");
730 goto hard_fail;
731 }
732
733 /* If any device called out for a reset, then reset the slot */
734 if (result == PCI_ERS_RESULT_NEED_RESET) {
735 pr_info("EEH: Reset without hotplug activity\n");
736 rc = eeh_reset_device(pe, NULL);
737 if (rc) {
738 pr_warn("%s: Cannot reset, err=%d\n",
739 __func__, rc);
740 goto hard_fail;
741 }
742
743 pr_info("EEH: Notify device drivers "
744 "the completion of reset\n");
745 result = PCI_ERS_RESULT_NONE;
746 eeh_pe_dev_traverse(pe, eeh_report_reset, &result);
747 }
748
749 /* All devices should claim they have recovered by now. */
750 if ((result != PCI_ERS_RESULT_RECOVERED) &&
751 (result != PCI_ERS_RESULT_NONE)) {
752 pr_warn("EEH: Not recovered\n");
753 goto hard_fail;
754 }
755
756 /* Tell all device drivers that they can resume operations */
757 pr_info("EEH: Notify device driver to resume\n");
758 eeh_pe_dev_traverse(pe, eeh_report_resume, NULL);
759
760 return;
761
762 excess_failures:
763 /*
764 * About 90% of all real-life EEH failures in the field
765 * are due to poorly seated PCI cards. Only 10% or so are
766 * due to actual, failed cards.
767 */
768 pr_err("EEH: PHB#%d-PE#%x has failed %d times in the\n"
769 "last hour and has been permanently disabled.\n"
770 "Please try reseating or replacing it.\n",
771 pe->phb->global_number, pe->addr,
772 pe->freeze_count);
773 goto perm_error;
774
775 hard_fail:
776 pr_err("EEH: Unable to recover from failure from PHB#%d-PE#%x.\n"
777 "Please try reseating or replacing it\n",
778 pe->phb->global_number, pe->addr);
779
780 perm_error:
781 eeh_slot_error_detail(pe, EEH_LOG_PERM);
782
783 /* Notify all devices that they're about to go down. */
784 eeh_pe_dev_traverse(pe, eeh_report_failure, NULL);
785
786 /* Mark the PE to be removed permanently */
787 eeh_pe_state_mark(pe, EEH_PE_REMOVED);
788
789 /*
790 * Shut down the device drivers for good. We mark
791 * all removed devices correctly to avoid access
792 * the their PCI config any more.
793 */
794 if (frozen_bus) {
795 eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
796
797 pci_lock_rescan_remove();
798 pcibios_remove_pci_devices(frozen_bus);
799 pci_unlock_rescan_remove();
800 }
801 }
802
803 static void eeh_handle_special_event(void)
804 {
805 struct eeh_pe *pe, *phb_pe;
806 struct pci_bus *bus;
807 struct pci_controller *hose;
808 unsigned long flags;
809 int rc;
810
811
812 do {
813 rc = eeh_ops->next_error(&pe);
814
815 switch (rc) {
816 case EEH_NEXT_ERR_DEAD_IOC:
817 /* Mark all PHBs in dead state */
818 eeh_serialize_lock(&flags);
819
820 /* Purge all events */
821 eeh_remove_event(NULL, true);
822
823 list_for_each_entry(hose, &hose_list, list_node) {
824 phb_pe = eeh_phb_pe_get(hose);
825 if (!phb_pe) continue;
826
827 eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
828 }
829
830 eeh_serialize_unlock(flags);
831
832 break;
833 case EEH_NEXT_ERR_FROZEN_PE:
834 case EEH_NEXT_ERR_FENCED_PHB:
835 case EEH_NEXT_ERR_DEAD_PHB:
836 /* Mark the PE in fenced state */
837 eeh_serialize_lock(&flags);
838
839 /* Purge all events of the PHB */
840 eeh_remove_event(pe, true);
841
842 if (rc == EEH_NEXT_ERR_DEAD_PHB)
843 eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
844 else
845 eeh_pe_state_mark(pe,
846 EEH_PE_ISOLATED | EEH_PE_RECOVERING);
847
848 eeh_serialize_unlock(flags);
849
850 break;
851 case EEH_NEXT_ERR_NONE:
852 return;
853 default:
854 pr_warn("%s: Invalid value %d from next_error()\n",
855 __func__, rc);
856 return;
857 }
858
859 /*
860 * For fenced PHB and frozen PE, it's handled as normal
861 * event. We have to remove the affected PHBs for dead
862 * PHB and IOC
863 */
864 if (rc == EEH_NEXT_ERR_FROZEN_PE ||
865 rc == EEH_NEXT_ERR_FENCED_PHB) {
866 eeh_handle_normal_event(pe);
867 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
868 } else {
869 pci_lock_rescan_remove();
870 list_for_each_entry(hose, &hose_list, list_node) {
871 phb_pe = eeh_phb_pe_get(hose);
872 if (!phb_pe ||
873 !(phb_pe->state & EEH_PE_ISOLATED) ||
874 (phb_pe->state & EEH_PE_RECOVERING))
875 continue;
876
877 /* Notify all devices to be down */
878 bus = eeh_pe_bus_get(phb_pe);
879 eeh_pe_dev_traverse(pe,
880 eeh_report_failure, NULL);
881 pcibios_remove_pci_devices(bus);
882 }
883 pci_unlock_rescan_remove();
884 }
885
886 /*
887 * If we have detected dead IOC, we needn't proceed
888 * any more since all PHBs would have been removed
889 */
890 if (rc == EEH_NEXT_ERR_DEAD_IOC)
891 break;
892 } while (rc != EEH_NEXT_ERR_NONE);
893 }
894
895 /**
896 * eeh_handle_event - Reset a PCI device after hard lockup.
897 * @pe: EEH PE
898 *
899 * While PHB detects address or data parity errors on particular PCI
900 * slot, the associated PE will be frozen. Besides, DMA's occurring
901 * to wild addresses (which usually happen due to bugs in device
902 * drivers or in PCI adapter firmware) can cause EEH error. #SERR,
903 * #PERR or other misc PCI-related errors also can trigger EEH errors.
904 *
905 * Recovery process consists of unplugging the device driver (which
906 * generated hotplug events to userspace), then issuing a PCI #RST to
907 * the device, then reconfiguring the PCI config space for all bridges
908 * & devices under this slot, and then finally restarting the device
909 * drivers (which cause a second set of hotplug events to go out to
910 * userspace).
911 */
912 void eeh_handle_event(struct eeh_pe *pe)
913 {
914 if (pe)
915 eeh_handle_normal_event(pe);
916 else
917 eeh_handle_special_event();
918 }