Commit 3ba8b7c5 authored by Bjorn Helgaas's avatar Bjorn Helgaas
Browse files

Merge branch 'pci/bjorn-osc' into next 

* pci/bjorn-osc:
  PCI/ACPI: Decode _OSC bitmasks symbolically
  PCI/ACPI: Separate out _OSC "we don't support enough services" path
  PCI/ACPI: Separate out _OSC "PCIe port services disabled" path
  PCI/ACPI: Skip _OSC control tests if _OSC support call failed
  PCI/ACPI: Run _OSC only once for OSPM feature support
  PCI/ACPI: Split _OSC "support" and "control" flags into separate variables
  PCI/ACPI: Move _OSC stuff from acpi_pci_root_add() to negotiate_os_control()
  PCI/ACPI: Drop unnecessary _OSC existence tests
  PCI/ACPI: Name _OSC #defines more consistently
  ACPI: Write OSC_PCI_CONTROL_MASKS like OSC_PCI_SUPPORT_MASKS
  ACPI: Remove unused OSC_PCI_NATIVE_HOTPLUG
  ACPI: Tidy acpi_run_osc() declarations
  ACPI: Rename OSC_QUERY_TYPE to OSC_QUERY_DWORD
  ACPI: Write _OSC bit field definitions in hex
parents 4a10c2ac 955f14b4

drivers/acpi/apei/apei-base.c

+3 −3
Original line number Diff line number Diff line
@@ -758,9 +758,9 @@ int apei_osc_setup(void) 
		.cap.pointer	= capbuf,

	};



	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;

	capbuf[OSC_SUPPORT_TYPE] = 1;

	capbuf[OSC_CONTROL_TYPE] = 0;

	capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;

	capbuf[OSC_SUPPORT_DWORD] = 1;

	capbuf[OSC_CONTROL_DWORD] = 0;



	if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))

	    || ACPI_FAILURE(acpi_run_osc(handle, &context)))

drivers/acpi/bus.c

+9 −9
Original line number Diff line number Diff line
@@ -255,7 +255,7 @@ acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context) 
			acpi_print_osc_error(handle, context,

				"_OSC invalid revision");

		if (errors & OSC_CAPABILITIES_MASK_ERROR) {

			if (((u32 *)context->cap.pointer)[OSC_QUERY_TYPE]

			if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD]

			    & OSC_QUERY_ENABLE)

				goto out_success;

			status = AE_SUPPORT;
@@ -295,30 +295,30 @@ static void acpi_bus_osc_support(void) 
	};

	acpi_handle handle;



	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;

	capbuf[OSC_SUPPORT_TYPE] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */

	capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;

	capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */

#if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\

			defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE)

	capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT;

	capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT;

#endif



#if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)

	capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT;

	capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;

#endif



#ifdef ACPI_HOTPLUG_OST

	capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_HOTPLUG_OST_SUPPORT;

	capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;

#endif



	if (!ghes_disable)

		capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_APEI_SUPPORT;

		capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;

	if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))

		return;

	if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {

		u32 *capbuf_ret = context.ret.pointer;

		if (context.ret.length > OSC_SUPPORT_TYPE)

		if (context.ret.length > OSC_SUPPORT_DWORD)

			osc_sb_apei_support_acked =

				capbuf_ret[OSC_SUPPORT_TYPE] & OSC_SB_APEI_SUPPORT;

				capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;

		kfree(context.ret.pointer);

	}

	/* do we need to check other returned cap? Sounds no */

drivers/acpi/pci_root.c

+148 −98
Original line number Diff line number Diff line
@@ -49,10 +49,10 @@ static int acpi_pci_root_add(struct acpi_device *device, 
			     const struct acpi_device_id *not_used);

static void acpi_pci_root_remove(struct acpi_device *device);



#define ACPI_PCIE_REQ_SUPPORT (OSC_EXT_PCI_CONFIG_SUPPORT \

				| OSC_ACTIVE_STATE_PWR_SUPPORT \

				| OSC_CLOCK_PWR_CAPABILITY_SUPPORT \

				| OSC_MSI_SUPPORT)

#define ACPI_PCIE_REQ_SUPPORT (OSC_PCI_EXT_CONFIG_SUPPORT \

				| OSC_PCI_ASPM_SUPPORT \

				| OSC_PCI_CLOCK_PM_SUPPORT \

				| OSC_PCI_MSI_SUPPORT)



static const struct acpi_device_id root_device_ids[] = {

	{"PNP0A03", 0},
@@ -127,6 +127,55 @@ static acpi_status try_get_root_bridge_busnr(acpi_handle handle, 
	return AE_OK;

}



struct pci_osc_bit_struct {

	u32 bit;

	char *desc;

};



static struct pci_osc_bit_struct pci_osc_support_bit[] = {

	{ OSC_PCI_EXT_CONFIG_SUPPORT, "ExtendedConfig" },

	{ OSC_PCI_ASPM_SUPPORT, "ASPM" },

	{ OSC_PCI_CLOCK_PM_SUPPORT, "ClockPM" },

	{ OSC_PCI_SEGMENT_GROUPS_SUPPORT, "Segments" },

	{ OSC_PCI_MSI_SUPPORT, "MSI" },

};



static struct pci_osc_bit_struct pci_osc_control_bit[] = {

	{ OSC_PCI_EXPRESS_NATIVE_HP_CONTROL, "PCIeHotplug" },

	{ OSC_PCI_SHPC_NATIVE_HP_CONTROL, "SHPCHotplug" },

	{ OSC_PCI_EXPRESS_PME_CONTROL, "PME" },

	{ OSC_PCI_EXPRESS_AER_CONTROL, "AER" },

	{ OSC_PCI_EXPRESS_CAPABILITY_CONTROL, "PCIeCapability" },

};



static void decode_osc_bits(struct acpi_pci_root *root, char *msg, u32 word,

			    struct pci_osc_bit_struct *table, int size)

{

	char buf[80];

	int i, len = 0;

	struct pci_osc_bit_struct *entry;



	buf[0] = '\0';

	for (i = 0, entry = table; i < size; i++, entry++)

		if (word & entry->bit)

			len += snprintf(buf + len, sizeof(buf) - len, "%s%s",

					len ? " " : "", entry->desc);



	dev_info(&root->device->dev, "_OSC: %s [%s]\n", msg, buf);

}



static void decode_osc_support(struct acpi_pci_root *root, char *msg, u32 word)

{

	decode_osc_bits(root, msg, word, pci_osc_support_bit,

			ARRAY_SIZE(pci_osc_support_bit));

}



static void decode_osc_control(struct acpi_pci_root *root, char *msg, u32 word)

{

	decode_osc_bits(root, msg, word, pci_osc_control_bit,

			ARRAY_SIZE(pci_osc_control_bit));

}



static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";



static acpi_status acpi_pci_run_osc(acpi_handle handle,
@@ -158,14 +207,14 @@ static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root, 
	support &= OSC_PCI_SUPPORT_MASKS;

	support |= root->osc_support_set;



	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;

	capbuf[OSC_SUPPORT_TYPE] = support;

	capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;

	capbuf[OSC_SUPPORT_DWORD] = support;

	if (control) {

		*control &= OSC_PCI_CONTROL_MASKS;

		capbuf[OSC_CONTROL_TYPE] = *control | root->osc_control_set;

		capbuf[OSC_CONTROL_DWORD] = *control | root->osc_control_set;

	} else {

		/* Run _OSC query only with existing controls. */

		capbuf[OSC_CONTROL_TYPE] = root->osc_control_set;

		capbuf[OSC_CONTROL_DWORD] = root->osc_control_set;

	}



	status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
@@ -180,11 +229,7 @@ static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root, 
static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)

{

	acpi_status status;

	acpi_handle tmp;



	status = acpi_get_handle(root->device->handle, "_OSC", &tmp);

	if (ACPI_FAILURE(status))

		return status;

	mutex_lock(&osc_lock);

	status = acpi_pci_query_osc(root, flags, NULL);

	mutex_unlock(&osc_lock);
@@ -316,9 +361,8 @@ EXPORT_SYMBOL_GPL(acpi_get_pci_dev); 
acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)

{

	struct acpi_pci_root *root;

	acpi_status status;

	acpi_status status = AE_OK;

	u32 ctrl, capbuf[3];

	acpi_handle tmp;



	if (!mask)

		return AE_BAD_PARAMETER;
@@ -331,10 +375,6 @@ acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req) 
	if (!root)

		return AE_NOT_EXIST;



	status = acpi_get_handle(handle, "_OSC", &tmp);

	if (ACPI_FAILURE(status))

		return status;



	mutex_lock(&osc_lock);



	*mask = ctrl | root->osc_control_set;
@@ -349,17 +389,21 @@ acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req) 
			goto out;

		if (ctrl == *mask)

			break;

		decode_osc_control(root, "platform does not support",

				   ctrl & ~(*mask));

		ctrl = *mask;

	}



	if ((ctrl & req) != req) {

		decode_osc_control(root, "not requesting control; platform does not support",

				   req & ~(ctrl));

		status = AE_SUPPORT;

		goto out;

	}



	capbuf[OSC_QUERY_TYPE] = 0;

	capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;

	capbuf[OSC_CONTROL_TYPE] = ctrl;

	capbuf[OSC_QUERY_DWORD] = 0;

	capbuf[OSC_SUPPORT_DWORD] = root->osc_support_set;

	capbuf[OSC_CONTROL_DWORD] = ctrl;

	status = acpi_pci_run_osc(handle, capbuf, mask);

	if (ACPI_SUCCESS(status))

		root->osc_control_set = *mask;
@@ -369,6 +413,87 @@ out: 
}

EXPORT_SYMBOL(acpi_pci_osc_control_set);



static void negotiate_os_control(struct acpi_pci_root *root, int *no_aspm,

				 int *clear_aspm)

{

	u32 support, control, requested;

	acpi_status status;

	struct acpi_device *device = root->device;

	acpi_handle handle = device->handle;



	/*

	 * All supported architectures that use ACPI have support for

	 * PCI domains, so we indicate this in _OSC support capabilities.

	 */

	support = OSC_PCI_SEGMENT_GROUPS_SUPPORT;

	if (pci_ext_cfg_avail())

		support |= OSC_PCI_EXT_CONFIG_SUPPORT;

	if (pcie_aspm_support_enabled())

		support |= OSC_PCI_ASPM_SUPPORT | OSC_PCI_CLOCK_PM_SUPPORT;

	if (pci_msi_enabled())

		support |= OSC_PCI_MSI_SUPPORT;



	decode_osc_support(root, "OS supports", support);

	status = acpi_pci_osc_support(root, support);

	if (ACPI_FAILURE(status)) {

		dev_info(&device->dev, "_OSC failed (%s); disabling ASPM\n",

			 acpi_format_exception(status));

		*no_aspm = 1;

		return;

	}



	if (pcie_ports_disabled) {

		dev_info(&device->dev, "PCIe port services disabled; not requesting _OSC control\n");

		return;

	}



	if ((support & ACPI_PCIE_REQ_SUPPORT) != ACPI_PCIE_REQ_SUPPORT) {

		decode_osc_support(root, "not requesting OS control; OS requires",

				   ACPI_PCIE_REQ_SUPPORT);

		return;

	}



	control = OSC_PCI_EXPRESS_CAPABILITY_CONTROL

		| OSC_PCI_EXPRESS_NATIVE_HP_CONTROL

		| OSC_PCI_EXPRESS_PME_CONTROL;



	if (pci_aer_available()) {

		if (aer_acpi_firmware_first())

			dev_info(&device->dev,

				 "PCIe AER handled by firmware\n");

		else

			control |= OSC_PCI_EXPRESS_AER_CONTROL;

	}



	requested = control;

	status = acpi_pci_osc_control_set(handle, &control,

					  OSC_PCI_EXPRESS_CAPABILITY_CONTROL);

	if (ACPI_SUCCESS(status)) {

		decode_osc_control(root, "OS now controls", control);

		if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {

			/*

			 * We have ASPM control, but the FADT indicates

			 * that it's unsupported. Clear it.

			 */

			*clear_aspm = 1;

		}

	} else {

		decode_osc_control(root, "OS requested", requested);

		decode_osc_control(root, "platform willing to grant", control);

		dev_info(&device->dev, "_OSC failed (%s); disabling ASPM\n",

			acpi_format_exception(status));



		/*

		 * We want to disable ASPM here, but aspm_disabled

		 * needs to remain in its state from boot so that we

		 * properly handle PCIe 1.1 devices.  So we set this

		 * flag here, to defer the action until after the ACPI

		 * root scan.

		 */

		*no_aspm = 1;

	}

}



static int acpi_pci_root_add(struct acpi_device *device,

			     const struct acpi_device_id *not_used)

{
@@ -376,9 +501,8 @@ static int acpi_pci_root_add(struct acpi_device *device, 
	acpi_status status;

	int result;

	struct acpi_pci_root *root;

	u32 flags, base_flags;

	acpi_handle handle = device->handle;

	bool no_aspm = false, clear_aspm = false;

	int no_aspm = 0, clear_aspm = 0;



	root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);

	if (!root)
@@ -431,81 +555,7 @@ static int acpi_pci_root_add(struct acpi_device *device, 


	root->mcfg_addr = acpi_pci_root_get_mcfg_addr(handle);



	/*

	 * All supported architectures that use ACPI have support for

	 * PCI domains, so we indicate this in _OSC support capabilities.

	 */

	flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;

	acpi_pci_osc_support(root, flags);



	if (pci_ext_cfg_avail())

		flags |= OSC_EXT_PCI_CONFIG_SUPPORT;

	if (pcie_aspm_support_enabled()) {

		flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |

		OSC_CLOCK_PWR_CAPABILITY_SUPPORT;

	}

	if (pci_msi_enabled())

		flags |= OSC_MSI_SUPPORT;

	if (flags != base_flags) {

		status = acpi_pci_osc_support(root, flags);

		if (ACPI_FAILURE(status)) {

			dev_info(&device->dev, "ACPI _OSC support "

				"notification failed, disabling PCIe ASPM\n");

			no_aspm = true;

			flags = base_flags;

		}

	}



	if (!pcie_ports_disabled

	    && (flags & ACPI_PCIE_REQ_SUPPORT) == ACPI_PCIE_REQ_SUPPORT) {

		flags = OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL

			| OSC_PCI_EXPRESS_NATIVE_HP_CONTROL

			| OSC_PCI_EXPRESS_PME_CONTROL;



		if (pci_aer_available()) {

			if (aer_acpi_firmware_first())

				dev_dbg(&device->dev,

					"PCIe errors handled by BIOS.\n");

			else

				flags |= OSC_PCI_EXPRESS_AER_CONTROL;

		}



		dev_info(&device->dev,

			"Requesting ACPI _OSC control (0x%02x)\n", flags);



		status = acpi_pci_osc_control_set(handle, &flags,

				       OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);

		if (ACPI_SUCCESS(status)) {

			dev_info(&device->dev,

				"ACPI _OSC control (0x%02x) granted\n", flags);

			if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {

				/*

				 * We have ASPM control, but the FADT indicates

				 * that it's unsupported. Clear it.

				 */

				clear_aspm = true;

			}

		} else {

			dev_info(&device->dev,

				"ACPI _OSC request failed (%s), "

				"returned control mask: 0x%02x\n",

				acpi_format_exception(status), flags);

			dev_info(&device->dev,

				 "ACPI _OSC control for PCIe not granted, disabling ASPM\n");

			/*

			 * We want to disable ASPM here, but aspm_disabled

			 * needs to remain in its state from boot so that we

			 * properly handle PCIe 1.1 devices.  So we set this

			 * flag here, to defer the action until after the ACPI

			 * root scan.

			 */

			no_aspm = true;

		}

	} else {

		dev_info(&device->dev,

			 "Unable to request _OSC control "

			 "(_OSC support mask: 0x%02x)\n", flags);

	}

	negotiate_os_control(root, &no_aspm, &clear_aspm);



	/*

	 * TBD: Need PCI interface for enumeration/configuration of roots.

drivers/pci/hotplug/acpi_pcihp.c

+1 −1
Original line number Diff line number Diff line
@@ -338,7 +338,7 @@ int acpi_get_hp_hw_control_from_firmware(struct pci_dev *pdev, u32 flags) 
	acpi_handle chandle, handle;

	struct acpi_buffer string = { ACPI_ALLOCATE_BUFFER, NULL };



	flags &= OSC_SHPC_NATIVE_HP_CONTROL;

	flags &= OSC_PCI_SHPC_NATIVE_HP_CONTROL;

	if (!flags) {

		err("Invalid flags %u specified!\n", flags);

		return -EINVAL;

drivers/pci/hotplug/shpchp.h

+1 −1
Original line number Diff line number Diff line
@@ -191,7 +191,7 @@ static inline const char *slot_name(struct slot *slot) 
#include <linux/pci-acpi.h>

static inline int get_hp_hw_control_from_firmware(struct pci_dev *dev)

{

	u32 flags = OSC_SHPC_NATIVE_HP_CONTROL;

	u32 flags = OSC_PCI_SHPC_NATIVE_HP_CONTROL;

	return acpi_get_hp_hw_control_from_firmware(dev, flags);

}

#else

CRA Git | Maintained and supported by SUSTech CRA and CCSE