err.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * This file implements the error recovery as a core part of PCIe error
  4. * reporting. When a PCIe error is delivered, an error message will be
  5. * collected and printed to console, then, an error recovery procedure
  6. * will be executed by following the PCI error recovery rules.
  7. *
  8. * Copyright (C) 2006 Intel Corp.
  9. * Tom Long Nguyen (tom.l.nguyen@intel.com)
  10. * Zhang Yanmin (yanmin.zhang@intel.com)
  11. */
  12. #define dev_fmt(fmt) "AER: " fmt
  13. #include <linux/pci.h>
  14. #include <linux/module.h>
  15. #include <linux/kernel.h>
  16. #include <linux/errno.h>
  17. #include <linux/aer.h>
  18. #include "portdrv.h"
  19. #include "../pci.h"
  20. static pci_ers_result_t merge_result(enum pci_ers_result orig,
  21. enum pci_ers_result new)
  22. {
  23. if (new == PCI_ERS_RESULT_NO_AER_DRIVER)
  24. return PCI_ERS_RESULT_NO_AER_DRIVER;
  25. if (new == PCI_ERS_RESULT_NONE)
  26. return orig;
  27. switch (orig) {
  28. case PCI_ERS_RESULT_CAN_RECOVER:
  29. case PCI_ERS_RESULT_RECOVERED:
  30. orig = new;
  31. break;
  32. case PCI_ERS_RESULT_DISCONNECT:
  33. if (new == PCI_ERS_RESULT_NEED_RESET)
  34. orig = PCI_ERS_RESULT_NEED_RESET;
  35. break;
  36. default:
  37. break;
  38. }
  39. return orig;
  40. }
  41. static int report_error_detected(struct pci_dev *dev,
  42. pci_channel_state_t state,
  43. enum pci_ers_result *result)
  44. {
  45. pci_ers_result_t vote;
  46. const struct pci_error_handlers *err_handler;
  47. device_lock(&dev->dev);
  48. if (!pci_dev_set_io_state(dev, state) ||
  49. !dev->driver ||
  50. !dev->driver->err_handler ||
  51. !dev->driver->err_handler->error_detected) {
  52. /*
  53. * If any device in the subtree does not have an error_detected
  54. * callback, PCI_ERS_RESULT_NO_AER_DRIVER prevents subsequent
  55. * error callbacks of "any" device in the subtree, and will
  56. * exit in the disconnected error state.
  57. */
  58. if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
  59. vote = PCI_ERS_RESULT_NO_AER_DRIVER;
  60. pci_info(dev, "can't recover (no error_detected callback)\n");
  61. } else {
  62. vote = PCI_ERS_RESULT_NONE;
  63. }
  64. } else {
  65. err_handler = dev->driver->err_handler;
  66. vote = err_handler->error_detected(dev, state);
  67. }
  68. pci_uevent_ers(dev, vote);
  69. *result = merge_result(*result, vote);
  70. device_unlock(&dev->dev);
  71. return 0;
  72. }
  73. static int report_frozen_detected(struct pci_dev *dev, void *data)
  74. {
  75. return report_error_detected(dev, pci_channel_io_frozen, data);
  76. }
  77. static int report_normal_detected(struct pci_dev *dev, void *data)
  78. {
  79. return report_error_detected(dev, pci_channel_io_normal, data);
  80. }
  81. static int report_mmio_enabled(struct pci_dev *dev, void *data)
  82. {
  83. pci_ers_result_t vote, *result = data;
  84. const struct pci_error_handlers *err_handler;
  85. device_lock(&dev->dev);
  86. if (!dev->driver ||
  87. !dev->driver->err_handler ||
  88. !dev->driver->err_handler->mmio_enabled)
  89. goto out;
  90. err_handler = dev->driver->err_handler;
  91. vote = err_handler->mmio_enabled(dev);
  92. *result = merge_result(*result, vote);
  93. out:
  94. device_unlock(&dev->dev);
  95. return 0;
  96. }
  97. static int report_slot_reset(struct pci_dev *dev, void *data)
  98. {
  99. pci_ers_result_t vote, *result = data;
  100. const struct pci_error_handlers *err_handler;
  101. device_lock(&dev->dev);
  102. if (!dev->driver ||
  103. !dev->driver->err_handler ||
  104. !dev->driver->err_handler->slot_reset)
  105. goto out;
  106. err_handler = dev->driver->err_handler;
  107. vote = err_handler->slot_reset(dev);
  108. *result = merge_result(*result, vote);
  109. out:
  110. device_unlock(&dev->dev);
  111. return 0;
  112. }
  113. static int report_resume(struct pci_dev *dev, void *data)
  114. {
  115. const struct pci_error_handlers *err_handler;
  116. device_lock(&dev->dev);
  117. if (!pci_dev_set_io_state(dev, pci_channel_io_normal) ||
  118. !dev->driver ||
  119. !dev->driver->err_handler ||
  120. !dev->driver->err_handler->resume)
  121. goto out;
  122. err_handler = dev->driver->err_handler;
  123. err_handler->resume(dev);
  124. out:
  125. pci_uevent_ers(dev, PCI_ERS_RESULT_RECOVERED);
  126. device_unlock(&dev->dev);
  127. return 0;
  128. }
  129. pci_ers_result_t pcie_do_recovery(struct pci_dev *dev,
  130. pci_channel_state_t state,
  131. pci_ers_result_t (*reset_link)(struct pci_dev *pdev))
  132. {
  133. pci_ers_result_t status = PCI_ERS_RESULT_CAN_RECOVER;
  134. struct pci_bus *bus;
  135. /*
  136. * Error recovery runs on all subordinates of the first downstream port.
  137. * If the downstream port detected the error, it is cleared at the end.
  138. */
  139. if (!(pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT ||
  140. pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM))
  141. dev = dev->bus->self;
  142. bus = dev->subordinate;
  143. pci_dbg(dev, "broadcast error_detected message\n");
  144. if (state == pci_channel_io_frozen) {
  145. pci_walk_bus(bus, report_frozen_detected, &status);
  146. status = reset_link(dev);
  147. if (status != PCI_ERS_RESULT_RECOVERED) {
  148. pci_warn(dev, "link reset failed\n");
  149. goto failed;
  150. }
  151. } else {
  152. pci_walk_bus(bus, report_normal_detected, &status);
  153. }
  154. if (status == PCI_ERS_RESULT_CAN_RECOVER) {
  155. status = PCI_ERS_RESULT_RECOVERED;
  156. pci_dbg(dev, "broadcast mmio_enabled message\n");
  157. pci_walk_bus(bus, report_mmio_enabled, &status);
  158. }
  159. if (status == PCI_ERS_RESULT_NEED_RESET) {
  160. /*
  161. * TODO: Should call platform-specific
  162. * functions to reset slot before calling
  163. * drivers' slot_reset callbacks?
  164. */
  165. status = PCI_ERS_RESULT_RECOVERED;
  166. pci_dbg(dev, "broadcast slot_reset message\n");
  167. pci_walk_bus(bus, report_slot_reset, &status);
  168. }
  169. if (status != PCI_ERS_RESULT_RECOVERED)
  170. goto failed;
  171. pci_dbg(dev, "broadcast resume message\n");
  172. pci_walk_bus(bus, report_resume, &status);
  173. if (pcie_aer_is_native(dev))
  174. pcie_clear_device_status(dev);
  175. pci_aer_clear_nonfatal_status(dev);
  176. pci_info(dev, "device recovery successful\n");
  177. return status;
  178. failed:
  179. pci_uevent_ers(dev, PCI_ERS_RESULT_DISCONNECT);
  180. /* TODO: Should kernel panic here? */
  181. pci_info(dev, "device recovery failed\n");
  182. return status;
  183. }