Commit d56557af authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes/pci-2.6 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes/pci-2.6:
  PCI: bus speed strings should be const
  PCI hotplug: Fix build with CONFIG_ACPI unset
  PCI: PCIe: Remove the port driver module exit routine
  PCI: PCIe: Move PCIe PME code to the pcie directory
  PCI: PCIe: Disable PCIe port services during port initialization
  PCI: PCIe: Ask BIOS for control of all native services at once
  ACPI/PCI: Negotiate _OSC control bits before requesting them
  ACPI/PCI: Do not preserve _OSC control bits returned by a query
  ACPI/PCI: Make acpi_pci_query_osc() return control bits
  ACPI/PCI: Reorder checks in acpi_pci_osc_control_set()
  PCI: PCIe: Introduce commad line switch for disabling port services
  PCI: PCIe AER: Introduce pci_aer_available()
  x86/PCI: only define pci_domain_nr if PCI and PCI_DOMAINS are set
  PCI: provide stub pci_domain_nr function for !CONFIG_PCI configs
parents fa2925cf 17134d96

Documentation/kernel-parameters.txt

+10 −7
Original line number Diff line number Diff line
@@ -1974,15 +1974,18 @@ and is between 256 and 4096 characters. It is defined in the file 
		force	Enable ASPM even on devices that claim not to support it.

			WARNING: Forcing ASPM on may cause system lockups.



	pcie_ports=	[PCIE] PCIe ports handling:

		auto	Ask the BIOS whether or not to use native PCIe services

			associated with PCIe ports (PME, hot-plug, AER).  Use

			them only if that is allowed by the BIOS.

		native	Use native PCIe services associated with PCIe ports

			unconditionally.

		compat	Treat PCIe ports as PCI-to-PCI bridges, disable the PCIe

			ports driver.



	pcie_pme=	[PCIE,PM] Native PCIe PME signaling options:

			Format: {auto|force}[,nomsi]

		auto	Use native PCIe PME signaling if the BIOS allows the

			kernel to control PCIe config registers of root ports.

		force	Use native PCIe PME signaling even if the BIOS refuses

			to allow the kernel to control the relevant PCIe config

			registers.

		nomsi	Do not use MSI for native PCIe PME signaling (this makes

			all PCIe root ports use INTx for everything).

			all PCIe root ports use INTx for all services).



	pcmv=		[HW,PCMCIA] BadgePAD 4

arch/x86/include/asm/pci.h

+4 −2
Original line number Diff line number Diff line
@@ -27,6 +27,9 @@ extern struct pci_bus *pci_scan_bus_on_node(int busno, struct pci_ops *ops, 
					    int node);

extern struct pci_bus *pci_scan_bus_with_sysdata(int busno);



#ifdef CONFIG_PCI



#ifdef CONFIG_PCI_DOMAINS

static inline int pci_domain_nr(struct pci_bus *bus)

{

	struct pci_sysdata *sd = bus->sysdata;
@@ -37,13 +40,12 @@ static inline int pci_proc_domain(struct pci_bus *bus) 
{

	return pci_domain_nr(bus);

}



#endif



/* Can be used to override the logic in pci_scan_bus for skipping

   already-configured bus numbers - to be used for buggy BIOSes

   or architectures with incomplete PCI setup by the loader */



#ifdef CONFIG_PCI

extern unsigned int pcibios_assign_all_busses(void);

extern int pci_legacy_init(void);

# ifdef CONFIG_ACPI

drivers/acpi/pci_root.c

+56 −41
Original line number Diff line number Diff line
@@ -33,7 +33,6 @@ 
#include <linux/pm_runtime.h>

#include <linux/pci.h>

#include <linux/pci-acpi.h>

#include <linux/pci-aspm.h>

#include <linux/acpi.h>

#include <linux/slab.h>

#include <acpi/acpi_bus.h>
@@ -226,22 +225,31 @@ static acpi_status acpi_pci_run_osc(acpi_handle handle, 
	return status;

}



static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root, u32 flags)

static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root,

					u32 support,

					u32 *control)

{

	acpi_status status;

	u32 support_set, result, capbuf[3];

	u32 result, capbuf[3];



	support &= OSC_PCI_SUPPORT_MASKS;

	support |= root->osc_support_set;



	/* do _OSC query for all possible controls */

	support_set = root->osc_support_set | (flags & OSC_PCI_SUPPORT_MASKS);

	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;

	capbuf[OSC_SUPPORT_TYPE] = support_set;

	capbuf[OSC_SUPPORT_TYPE] = support;

	if (control) {

		*control &= OSC_PCI_CONTROL_MASKS;

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

	} else {

		/* Run _OSC query for all possible controls. */

		capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS;

	}



	status = acpi_pci_run_osc(root->device->handle, capbuf, &result);

	if (ACPI_SUCCESS(status)) {

		root->osc_support_set = support_set;

		root->osc_control_qry = result;

		root->osc_queried = 1;

		root->osc_support_set = support;

		if (control)

			*control = result;

	}

	return status;

}
@@ -255,7 +263,7 @@ static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags) 
	if (ACPI_FAILURE(status))

		return status;

	mutex_lock(&osc_lock);

	status = acpi_pci_query_osc(root, flags);

	status = acpi_pci_query_osc(root, flags, NULL);

	mutex_unlock(&osc_lock);

	return status;

}
@@ -365,55 +373,70 @@ out: 
EXPORT_SYMBOL_GPL(acpi_get_pci_dev);



/**

 * acpi_pci_osc_control_set - commit requested control to Firmware

 * @handle: acpi_handle for the target ACPI object

 * @flags: driver's requested control bits

 * acpi_pci_osc_control_set - Request control of PCI root _OSC features.

 * @handle: ACPI handle of a PCI root bridge (or PCIe Root Complex).

 * @mask: Mask of _OSC bits to request control of, place to store control mask.

 * @req: Mask of _OSC bits the control of is essential to the caller.

 *

 * Run _OSC query for @mask and if that is successful, compare the returned

 * mask of control bits with @req.  If all of the @req bits are set in the

 * returned mask, run _OSC request for it.

 *

 * Attempt to take control from Firmware on requested control bits.

 * The variable at the @mask address may be modified regardless of whether or

 * not the function returns success.  On success it will contain the mask of

 * _OSC bits the BIOS has granted control of, but its contents are meaningless

 * on failure.

 **/

acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags)

acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)

{

	struct acpi_pci_root *root;

	acpi_status status;

	u32 control_req, result, capbuf[3];

	u32 ctrl, capbuf[3];

	acpi_handle tmp;

	struct acpi_pci_root *root;



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

	if (ACPI_FAILURE(status))

		return status;

	if (!mask)

		return AE_BAD_PARAMETER;



	control_req = (flags & OSC_PCI_CONTROL_MASKS);

	if (!control_req)

	ctrl = *mask & OSC_PCI_CONTROL_MASKS;

	if ((ctrl & req) != req)

		return AE_TYPE;



	root = acpi_pci_find_root(handle);

	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;

	/* No need to evaluate _OSC if the control was already granted. */

	if ((root->osc_control_set & control_req) == control_req)

	if ((root->osc_control_set & ctrl) == ctrl)

		goto out;



	/* Need to query controls first before requesting them */

	if (!root->osc_queried) {

		status = acpi_pci_query_osc(root, root->osc_support_set);

	/* Need to check the available controls bits before requesting them. */

	while (*mask) {

		status = acpi_pci_query_osc(root, root->osc_support_set, mask);

		if (ACPI_FAILURE(status))

			goto out;

		if (ctrl == *mask)

			break;

		ctrl = *mask;

	}

	if ((root->osc_control_qry & control_req) != control_req) {

		printk(KERN_DEBUG

		       "Firmware did not grant requested _OSC control\n");



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

		status = AE_SUPPORT;

		goto out;

	}



	capbuf[OSC_QUERY_TYPE] = 0;

	capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;

	capbuf[OSC_CONTROL_TYPE] = root->osc_control_set | control_req;

	status = acpi_pci_run_osc(handle, capbuf, &result);

	capbuf[OSC_CONTROL_TYPE] = ctrl;

	status = acpi_pci_run_osc(handle, capbuf, mask);

	if (ACPI_SUCCESS(status))

		root->osc_control_set = result;

		root->osc_control_set = *mask;

out:

	mutex_unlock(&osc_lock);

	return status;
@@ -544,14 +567,6 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device) 
	if (flags != base_flags)

		acpi_pci_osc_support(root, flags);



	status = acpi_pci_osc_control_set(root->device->handle,

					  OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);



	if (ACPI_FAILURE(status)) {

		printk(KERN_INFO "Unable to assume PCIe control: Disabling ASPM\n");

		pcie_no_aspm();

	}



	pci_acpi_add_bus_pm_notifier(device, root->bus);

	if (device->wakeup.flags.run_wake)

		device_set_run_wake(root->bus->bridge, true);

drivers/pci/hotplug/acpi_pcihp.c

+2 −4
Original line number Diff line number Diff line
@@ -338,9 +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_PCI_EXPRESS_NATIVE_HP_CONTROL |

		  OSC_SHPC_NATIVE_HP_CONTROL |

		  OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);

	flags &= OSC_SHPC_NATIVE_HP_CONTROL;

	if (!flags) {

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

		return -EINVAL;
@@ -360,7 +358,7 @@ int acpi_get_hp_hw_control_from_firmware(struct pci_dev *pdev, u32 flags) 
		acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);

		dbg("Trying to get hotplug control for %s\n",

				(char *)string.pointer);

		status = acpi_pci_osc_control_set(handle, flags);

		status = acpi_pci_osc_control_set(handle, &flags, flags);

		if (ACPI_SUCCESS(status))

			goto got_one;

		if (status == AE_SUPPORT)

drivers/pci/hotplug/pciehp.h

+4 −12
Original line number Diff line number Diff line
@@ -176,19 +176,11 @@ static inline void pciehp_firmware_init(void) 
{

	pciehp_acpi_slot_detection_init();

}



static inline int pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev)

{

	int retval;

	u32 flags = (OSC_PCI_EXPRESS_NATIVE_HP_CONTROL |

		     OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);

	retval = acpi_get_hp_hw_control_from_firmware(dev, flags);

	if (retval)

		return retval;

	return pciehp_acpi_slot_detection_check(dev);

}

#else

#define pciehp_firmware_init()				do {} while (0)

#define pciehp_get_hp_hw_control_from_firmware(dev) 	0

static inline int pciehp_acpi_slot_detection_check(struct pci_dev *dev)

{

	return 0;

}

#endif 				/* CONFIG_ACPI */

#endif				/* _PCIEHP_H */

CRA Git | Maintained and supported by SUSTech CRA and CCSE