Merge branch 'pci/hotplug'

event will be platform-dependent, but will follow the general

sequence described below.

STEP 0: Error Event: ERR_NONFATAL

STEP 0: Error Event

-------------------

A PCI bus error is detected by the PCI hardware.  On powerpc, the slot

is isolated, in that all I/O is blocked: all reads return 0xffffffff,

If any driver returned PCI_ERS_RESULT_NEED_RESET, then the platform

proceeds to STEP 4 (Slot Reset)

STEP 3: Slot Reset

STEP 3: Link Reset

------------------

The platform resets the link.  This is a PCI-Express specific step

and is done whenever a fatal error has been detected that can be

"solved" by resetting the link.

STEP 4: Slot Reset

------------------

In response to a return value of PCI_ERS_RESULT_NEED_RESET, the

>>> However, it probably should.

STEP 4: Resume Operations

STEP 5: Resume Operations

-------------------------

The platform will call the resume() callback on all affected device

drivers if all drivers on the segment have returned

At this point, if a new error happens, the platform will restart

a new error recovery sequence.

STEP 5: Permanent Failure

STEP 6: Permanent Failure

-------------------------

A "permanent failure" has occurred, and the platform cannot recover

the device.  The platform will call error_detected() with a

for additional detail on real-life experience of the causes of

software errors.

STEP 0: Error Event: ERR_FATAL

-------------------

PCI bus error is detected by the PCI hardware. On powerpc, the slot is

isolated, in that all I/O is blocked: all reads return 0xffffffff, all

writes are ignored.

STEP 1: Remove devices

--------------------

Platform removes the devices depending on the error agent, it could be

this port for all subordinates or upstream component (likely downstream

port)

STEP 2: Reset link

--------------------

The platform resets the link.  This is a PCI-Express specific step and is

done whenever a fatal error has been detected that can be "solved" by

resetting the link.

STEP 3: Re-enumerate the devices

--------------------

Initiates the re-enumeration.

Conclusion; General Remarks

---------------------------

struct pnv_php_slot {

	struct hotplug_slot		slot;

	struct hotplug_slot_info	slot_info;

	uint64_t			id;

	char				*name;

	int				slot_no;

	struct pci_dev			*pdev;

	struct pci_bus			*bus;

	bool				power_state_check;

	u8				attention_state;

	void				*fdt;

	void				*dt;

	struct of_changeset		ocs;

					acpi_object_type type,

					const union acpi_object **obj);

static const guid_t prp_guids[] = {

	/* ACPI _DSD device properties GUID: daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */

static const guid_t prp_guid =

	GUID_INIT(0xdaffd814, 0x6eba, 0x4d8c,

		  0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01);

/* ACPI _DSD data subnodes GUID: dbb8e3e6-5886-4ba6-8795-1319f52a966b */

		  0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01),

	/* Hotplug in D3 GUID: 6211e2c0-58a3-4af3-90e1-927a4e0c55a4 */

	GUID_INIT(0x6211e2c0, 0x58a3, 0x4af3,

		  0x90, 0xe1, 0x92, 0x7a, 0x4e, 0x0c, 0x55, 0xa4),

};

static const guid_t ads_guid =

	GUID_INIT(0xdbb8e3e6, 0x5886, 0x4ba6,

		  0x87, 0x95, 0x13, 0x19, 0xf5, 0x2a, 0x96, 0x6b);

	dn->name = link->package.elements[0].string.pointer;

	dn->fwnode.ops = &acpi_data_fwnode_ops;

	dn->parent = parent;

	INIT_LIST_HEAD(&dn->data.properties);

	INIT_LIST_HEAD(&dn->data.subnodes);

	result = acpi_extract_properties(desc, &dn->data);

	adev->flags.of_compatible_ok = 1;

}

static bool acpi_is_property_guid(const guid_t *guid)

{

	int i;

	for (i = 0; i < ARRAY_SIZE(prp_guids); i++) {

		if (guid_equal(guid, &prp_guids[i]))

			return true;

	}

	return false;

}

struct acpi_device_properties *

acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,

		    const union acpi_object *properties)

{

	struct acpi_device_properties *props;

	props = kzalloc(sizeof(*props), GFP_KERNEL);

	if (props) {

		INIT_LIST_HEAD(&props->list);

		props->guid = guid;

		props->properties = properties;

		list_add_tail(&props->list, &data->properties);

	}

	return props;

}

static bool acpi_extract_properties(const union acpi_object *desc,

				    struct acpi_device_data *data)

{

		    properties->type != ACPI_TYPE_PACKAGE)

			break;

		if (!guid_equal((guid_t *)guid->buffer.pointer, &prp_guid))

		if (!acpi_is_property_guid((guid_t *)guid->buffer.pointer))

			continue;

		/*

		 * package immediately following it.

		 */

		if (!acpi_properties_format_valid(properties))

			break;

			continue;

		data->properties = properties;

		return true;

		acpi_data_add_props(data, (const guid_t *)guid->buffer.pointer,

				    properties);

	}

	return false;

	return !list_empty(&data->properties);

}

void acpi_init_properties(struct acpi_device *adev)

	acpi_status status;

	bool acpi_of = false;

	INIT_LIST_HEAD(&adev->data.properties);

	INIT_LIST_HEAD(&adev->data.subnodes);

	if (!adev->handle)

void acpi_free_properties(struct acpi_device *adev)

{

	struct acpi_device_properties *props, *tmp;

	acpi_destroy_nondev_subnodes(&adev->data.subnodes);

	ACPI_FREE((void *)adev->data.pointer);

	adev->data.of_compatible = NULL;

	adev->data.pointer = NULL;

	adev->data.properties = NULL;

	list_for_each_entry_safe(props, tmp, &adev->data.properties, list) {

		list_del(&props->list);

		kfree(props);

	}

}

/**

				  const char *name, acpi_object_type type,

				  const union acpi_object **obj)

{

	const union acpi_object *properties;

	int i;

	const struct acpi_device_properties *props;

	if (!data || !name)

		return -EINVAL;

	if (!data->pointer || !data->properties)

	if (!data->pointer || list_empty(&data->properties))

		return -EINVAL;

	properties = data->properties;

	list_for_each_entry(props, &data->properties, list) {

		const union acpi_object *properties;

		unsigned int i;

		properties = props->properties;

		for (i = 0; i < properties->package.count; i++) {

			const union acpi_object *propname, *propvalue;

			const union acpi_object *property;

			propvalue = &property->package.elements[1];

			if (!strcmp(name, propname->string.pointer)) {

			if (type != ACPI_TYPE_ANY && propvalue->type != type)

				if (type != ACPI_TYPE_ANY &&

				    propvalue->type != type)

					return -EPROTO;

				if (obj)

					*obj = propvalue;

				return 0;

			}

		}

	}

	return -EINVAL;

}

	}

	WARN_ON(free_space != (void *)newprops + newsize);

	adev->data.properties = newprops;

	adev->data.pointer = newprops;

	acpi_data_add_props(&adev->data, &apple_prp_guid, newprops);

out_free:

	ACPI_FREE(props);

		pr_err("QAT: Can't find acceleration device\n");

		return PCI_ERS_RESULT_DISCONNECT;

	}

	pci_cleanup_aer_uncorrect_error_status(pdev);

	if (adf_dev_aer_schedule_reset(accel_dev, ADF_DEV_RESET_SYNC))

		return PCI_ERS_RESULT_DISCONNECT;