Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

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

Merge branch 'pci/pm' into next 

* pci/pm:
  PCI: Avoid unnecessary resume after direct-complete
  PCI: Recognize D3cold in pci_update_current_state()
  PCI: Query platform firmware for device power state
  PCI: Afford direct-complete to devices with non-standard PM
parents 6c6cba49 a0d2a959

drivers/pci/pci-acpi.c

+22 −0
Original line number Diff line number Diff line
@@ -452,6 +452,27 @@ static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) 
	return error;

}



static pci_power_t acpi_pci_get_power_state(struct pci_dev *dev)

{

	struct acpi_device *adev = ACPI_COMPANION(&dev->dev);

	static const pci_power_t state_conv[] = {

		[ACPI_STATE_D0]      = PCI_D0,

		[ACPI_STATE_D1]      = PCI_D1,

		[ACPI_STATE_D2]      = PCI_D2,

		[ACPI_STATE_D3_HOT]  = PCI_D3hot,

		[ACPI_STATE_D3_COLD] = PCI_D3cold,

	};

	int state;



	if (!adev || !acpi_device_power_manageable(adev))

		return PCI_UNKNOWN;



	if (acpi_device_get_power(adev, &state) || state == ACPI_STATE_UNKNOWN)

		return PCI_UNKNOWN;



	return state_conv[state];

}



static bool acpi_pci_can_wakeup(struct pci_dev *dev)

{

	struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
@@ -534,6 +555,7 @@ static bool acpi_pci_need_resume(struct pci_dev *dev) 
static const struct pci_platform_pm_ops acpi_pci_platform_pm = {

	.is_manageable = acpi_pci_power_manageable,

	.set_state = acpi_pci_set_power_state,

	.get_state = acpi_pci_get_power_state,

	.choose_state = acpi_pci_choose_state,

	.sleep_wake = acpi_pci_sleep_wake,

	.run_wake = acpi_pci_run_wake,

drivers/pci/pci-driver.c

+13 −2
Original line number Diff line number Diff line
@@ -682,8 +682,19 @@ static int pci_pm_prepare(struct device *dev) 


static void pci_pm_complete(struct device *dev)

{

	pci_dev_complete_resume(to_pci_dev(dev));

	pm_complete_with_resume_check(dev);

	struct pci_dev *pci_dev = to_pci_dev(dev);



	pci_dev_complete_resume(pci_dev);

	pm_generic_complete(dev);



	/* Resume device if platform firmware has put it in reset-power-on */

	if (dev->power.direct_complete && pm_resume_via_firmware()) {

		pci_power_t pre_sleep_state = pci_dev->current_state;



		pci_update_current_state(pci_dev, pci_dev->current_state);

		if (pci_dev->current_state < pre_sleep_state)

			pm_request_resume(dev);

	}

}



#else /* !CONFIG_PM_SLEEP */

drivers/pci/pci.c

+35 −17
Original line number Diff line number Diff line
@@ -552,8 +552,9 @@ static const struct pci_platform_pm_ops *pci_platform_pm; 


int pci_set_platform_pm(const struct pci_platform_pm_ops *ops)

{

	if (!ops->is_manageable || !ops->set_state || !ops->choose_state ||

	    !ops->sleep_wake || !ops->run_wake || !ops->need_resume)

	if (!ops->is_manageable || !ops->set_state  || !ops->get_state ||

	    !ops->choose_state  || !ops->sleep_wake || !ops->run_wake  ||

	    !ops->need_resume)

		return -EINVAL;

	pci_platform_pm = ops;

	return 0;
@@ -570,6 +571,11 @@ static inline int platform_pci_set_power_state(struct pci_dev *dev, 
	return pci_platform_pm ? pci_platform_pm->set_state(dev, t) : -ENOSYS;

}



static inline pci_power_t platform_pci_get_power_state(struct pci_dev *dev)

{

	return pci_platform_pm ? pci_platform_pm->get_state(dev) : PCI_UNKNOWN;

}



static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)

{

	return pci_platform_pm ?
@@ -701,26 +707,25 @@ static int pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state) 
}



/**

 * pci_update_current_state - Read PCI power state of given device from its

 *                            PCI PM registers and cache it

 * pci_update_current_state - Read power state of given device and cache it

 * @dev: PCI device to handle.

 * @state: State to cache in case the device doesn't have the PM capability

 *

 * The power state is read from the PMCSR register, which however is

 * inaccessible in D3cold.  The platform firmware is therefore queried first

 * to detect accessibility of the register.  In case the platform firmware

 * reports an incorrect state or the device isn't power manageable by the

 * platform at all, we try to detect D3cold by testing accessibility of the

 * vendor ID in config space.

 */

void pci_update_current_state(struct pci_dev *dev, pci_power_t state)

{

	if (dev->pm_cap) {

	if (platform_pci_get_power_state(dev) == PCI_D3cold ||

	    !pci_device_is_present(dev)) {

		dev->current_state = PCI_D3cold;

	} else if (dev->pm_cap) {

		u16 pmcsr;



		/*

		 * Configuration space is not accessible for device in

		 * D3cold, so just keep or set D3cold for safety

		 */

		if (dev->current_state == PCI_D3cold)

			return;

		if (state == PCI_D3cold) {

			dev->current_state = PCI_D3cold;

			return;

		}

		pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);

		dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);

	} else {
@@ -1959,9 +1964,22 @@ static pci_power_t pci_target_state(struct pci_dev *dev) 
		default:

			target_state = state;

		}

	} else if (!dev->pm_cap) {



		return target_state;

	}



	if (!dev->pm_cap)

		target_state = PCI_D0;

	} else if (device_may_wakeup(&dev->dev)) {



	/*

	 * If the device is in D3cold even though it's not power-manageable by

	 * the platform, it may have been powered down by non-standard means.

	 * Best to let it slumber.

	 */

	if (dev->current_state == PCI_D3cold)

		target_state = PCI_D3cold;



	if (device_may_wakeup(&dev->dev)) {

		/*

		 * Find the deepest state from which the device can generate

		 * wake-up events, make it the target state and enable device

drivers/pci/pci.h

+3 −0
Original line number Diff line number Diff line
@@ -42,6 +42,8 @@ int pci_probe_reset_function(struct pci_dev *dev); 
 *

 * @set_state: invokes the platform firmware to set the device's power state

 *

 * @get_state: queries the platform firmware for a device's current power state

 *

 * @choose_state: returns PCI power state of given device preferred by the

 *                platform; to be used during system-wide transitions from a

 *                sleeping state to the working state and vice versa
@@ -62,6 +64,7 @@ int pci_probe_reset_function(struct pci_dev *dev); 
struct pci_platform_pm_ops {

	bool (*is_manageable)(struct pci_dev *dev);

	int (*set_state)(struct pci_dev *dev, pci_power_t state);

	pci_power_t (*get_state)(struct pci_dev *dev);

	pci_power_t (*choose_state)(struct pci_dev *dev);

	int (*sleep_wake)(struct pci_dev *dev, bool enable);

	int (*run_wake)(struct pci_dev *dev, bool enable);