Merge branch 'pci/aer' into next (f1901324) · Commits · EulixOS / Software / Kernel

drivers/pci/pcie/aer/aerdrv.c

+1 −24

Original line number	Diff line number	Diff line
		@@ -32,16 +32,9 @@

		static int aer_probe(struct pcie_device *dev);
		static void aer_remove(struct pcie_device *dev);
		static pci_ers_result_t aer_error_detected(struct pci_dev *dev,
		enum pci_channel_state error);
		static void aer_error_resume(struct pci_dev *dev);
		static pci_ers_result_t aer_root_reset(struct pci_dev *dev);

		static const struct pci_error_handlers aer_error_handlers = {
		.error_detected = aer_error_detected,
		.resume = aer_error_resume,
		};

		static struct pcie_port_service_driver aerdriver = {
		.name = "aer",
		.port_type = PCI_EXP_TYPE_ROOT_PORT,
		@@ -49,9 +42,7 @@ static struct pcie_port_service_driver aerdriver = {

		.probe = aer_probe,
		.remove = aer_remove,

		.err_handler = &aer_error_handlers,

		.error_resume = aer_error_resume,
		.reset_link = aer_root_reset,
		};

		@@ -349,20 +340,6 @@ static pci_ers_result_t aer_root_reset(struct pci_dev *dev)
		return PCI_ERS_RESULT_RECOVERED;
		}

		/**
		* aer_error_detected - update severity status
		* @dev: pointer to Root Port's pci_dev data structure
		* @error: error severity being notified by port bus
		*
		* Invoked by Port Bus driver during error recovery.
		*/
		static pci_ers_result_t aer_error_detected(struct pci_dev *dev,
		enum pci_channel_state error)
		{
		/* Root Port has no impact. Always recovers. */
		return PCI_ERS_RESULT_CAN_RECOVER;
		}

		/**
		* aer_error_resume - clean up corresponding error status bits
		* @dev: pointer to Root Port's pci_dev data structure

drivers/pci/pcie/portdrv_pci.c

+6 −99

Original line number	Diff line number	Diff line
		@@ -21,7 +21,6 @@

		#include "../pci.h"
		#include "portdrv.h"
		#include "aer/aerdrv.h"

		/* If this switch is set, PCIe port native services should not be enabled. */
		bool pcie_ports_disabled;
		@@ -177,108 +176,20 @@ static void pcie_portdrv_remove(struct pci_dev *dev)
		pcie_port_device_remove(dev);
		}

		static int error_detected_iter(struct device device, void data)
		{
		struct pcie_device *pcie_device;
		struct pcie_port_service_driver *driver;
		struct aer_broadcast_data *result_data;
		pci_ers_result_t status;

		result_data = (struct aer_broadcast_data *) data;

		if (device->bus == &pcie_port_bus_type && device->driver) {
		driver = to_service_driver(device->driver);
		if (!driver \|\|
		!driver->err_handler \|\|
		!driver->err_handler->error_detected)
		return 0;

		pcie_device = to_pcie_device(device);

		/* Forward error detected message to service drivers */
		status = driver->err_handler->error_detected(
		pcie_device->port,
		result_data->state);
		result_data->result =
		merge_result(result_data->result, status);
		}

		return 0;
		}

		static pci_ers_result_t pcie_portdrv_error_detected(struct pci_dev *dev,
		enum pci_channel_state error)
		{
		struct aer_broadcast_data data = {error, PCI_ERS_RESULT_CAN_RECOVER};

		/* get true return value from &data */
		device_for_each_child(&dev->dev, &data, error_detected_iter);
		return data.result;
		}

		static int mmio_enabled_iter(struct device device, void data)
		{
		struct pcie_device *pcie_device;
		struct pcie_port_service_driver *driver;
		pci_ers_result_t status, *result;

		result = (pci_ers_result_t *) data;

		if (device->bus == &pcie_port_bus_type && device->driver) {
		driver = to_service_driver(device->driver);
		if (driver &&
		driver->err_handler &&
		driver->err_handler->mmio_enabled) {
		pcie_device = to_pcie_device(device);

		/* Forward error message to service drivers */
		status = driver->err_handler->mmio_enabled(
		pcie_device->port);
		result = merge_result(result, status);
		}
		}

		return 0;
		/* Root Port has no impact. Always recovers. */
		return PCI_ERS_RESULT_CAN_RECOVER;
		}

		static pci_ers_result_t pcie_portdrv_mmio_enabled(struct pci_dev *dev)
		{
		pci_ers_result_t status = PCI_ERS_RESULT_RECOVERED;

		/* get true return value from &status */
		device_for_each_child(&dev->dev, &status, mmio_enabled_iter);
		return status;
		}

		static int slot_reset_iter(struct device device, void data)
		{
		struct pcie_device *pcie_device;
		struct pcie_port_service_driver *driver;
		pci_ers_result_t status, *result;

		result = (pci_ers_result_t *) data;

		if (device->bus == &pcie_port_bus_type && device->driver) {
		driver = to_service_driver(device->driver);
		if (driver &&
		driver->err_handler &&
		driver->err_handler->slot_reset) {
		pcie_device = to_pcie_device(device);

		/* Forward error message to service drivers */
		status = driver->err_handler->slot_reset(
		pcie_device->port);
		result = merge_result(result, status);
		}
		}

		return 0;
		return PCI_ERS_RESULT_RECOVERED;
		}

		static pci_ers_result_t pcie_portdrv_slot_reset(struct pci_dev *dev)
		{
		pci_ers_result_t status = PCI_ERS_RESULT_RECOVERED;

		/* If fatal, restore cfg space for possible link reset at upstream */
		if (dev->error_state == pci_channel_io_frozen) {
		dev->state_saved = true;
		@@ -287,9 +198,7 @@ static pci_ers_result_t pcie_portdrv_slot_reset(struct pci_dev *dev)
		pci_enable_pcie_error_reporting(dev);
		}

		/* get true return value from &status */
		device_for_each_child(&dev->dev, &status, slot_reset_iter);
		return status;
		return PCI_ERS_RESULT_RECOVERED;
		}

		static int resume_iter(struct device device, void data)
		@@ -299,13 +208,11 @@ static int resume_iter(struct device device, void data)

		if (device->bus == &pcie_port_bus_type && device->driver) {
		driver = to_service_driver(device->driver);
		if (driver &&
		driver->err_handler &&
		driver->err_handler->resume) {
		if (driver && driver->error_resume) {
		pcie_device = to_pcie_device(device);

		/* Forward error message to service drivers */
		driver->err_handler->resume(pcie_device->port);
		driver->error_resume(pcie_device->port);
		}
		}

include/linux/pcieport_if.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -50,8 +50,8 @@ struct pcie_port_service_driver {
		int (suspend) (struct pcie_device dev);
		int (resume) (struct pcie_device dev);

		/* Service Error Recovery Handler */
		const struct pci_error_handlers *err_handler;
		/* Device driver may resume normal operations */
		void (error_resume)(struct pci_dev dev);

		/* Link Reset Capability - AER service driver specific */
		pci_ers_result_t (reset_link) (struct pci_dev dev);

include/uapi/linux/pci_regs.h

+10 −16

Original line number	Diff line number	Diff line
		@@ -733,21 +733,15 @@
		#define PCI_ERR_CAP_ECRC_CHKE 0x00000100 /* ECRC Check Enable */
		#define PCI_ERR_HEADER_LOG 28 /* Header Log Register (16 bytes) */
		#define PCI_ERR_ROOT_COMMAND 44 /* Root Error Command */
		/* Correctable Err Reporting Enable */
		#define PCI_ERR_ROOT_CMD_COR_EN 0x00000001
		/* Non-fatal Err Reporting Enable */
		#define PCI_ERR_ROOT_CMD_NONFATAL_EN 0x00000002
		/* Fatal Err Reporting Enable */
		#define PCI_ERR_ROOT_CMD_FATAL_EN 0x00000004
		#define PCI_ERR_ROOT_CMD_COR_EN 0x00000001 /* Correctable Err Reporting Enable */
		#define PCI_ERR_ROOT_CMD_NONFATAL_EN 0x00000002 /* Non-Fatal Err Reporting Enable */
		#define PCI_ERR_ROOT_CMD_FATAL_EN 0x00000004 /* Fatal Err Reporting Enable */
		#define PCI_ERR_ROOT_STATUS 48
		#define PCI_ERR_ROOT_COR_RCV 0x00000001 /* ERR_COR Received */
		/* Multi ERR_COR Received */
		#define PCI_ERR_ROOT_MULTI_COR_RCV 0x00000002
		/* ERR_FATAL/NONFATAL Received */
		#define PCI_ERR_ROOT_UNCOR_RCV 0x00000004
		/* Multi ERR_FATAL/NONFATAL Received */
		#define PCI_ERR_ROOT_MULTI_UNCOR_RCV 0x00000008
		#define PCI_ERR_ROOT_FIRST_FATAL 0x00000010 /* First Fatal */
		#define PCI_ERR_ROOT_MULTI_COR_RCV 0x00000002 /* Multiple ERR_COR */
		#define PCI_ERR_ROOT_UNCOR_RCV 0x00000004 /* ERR_FATAL/NONFATAL */
		#define PCI_ERR_ROOT_MULTI_UNCOR_RCV 0x00000008 /* Multiple FATAL/NONFATAL */
		#define PCI_ERR_ROOT_FIRST_FATAL 0x00000010 /* First UNC is Fatal */
		#define PCI_ERR_ROOT_NONFATAL_RCV 0x00000020 /* Non-Fatal Received */
		#define PCI_ERR_ROOT_FATAL_RCV 0x00000040 /* Fatal Received */
		#define PCI_ERR_ROOT_ERR_SRC 52 /* Error Source Identification */