Commit 1fec1611 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'pm-pci' 

Merge PCI device power management updates for 5.16-rc1:

 - Make the association of ACPI device objects with PCI devices more
   straightforward and simplify the code doing that for all devices
   in general (Rafael Wysocki).

 - Eliminate struct pci_platform_pm_ops and handle the both of its
   users (PCI and Intel MID) directly in the PCI bus code (Rafael
   Wysocki).

 - Simplify and clarify ACPI PCI device PM helpers (Rafael Wysocki).

 - Fix ordering of operations in pci_back_from_sleep() (Rafael
   Wysocki).

* pm-pci:
  PCI: PM: Fix ordering of operations in pci_back_from_sleep()
  PCI: PM: Do not call platform_pci_power_manageable() unnecessarily
  PCI: PM: Make pci_choose_state() call pci_target_state()
  PCI: PM: Rearrange pci_target_state()
  PCI: PM: Simplify acpi_pci_power_manageable()
  PCI: PM: Drop struct pci_platform_pm_ops
  PCI: ACPI: PM: Do not use pci_platform_pm_ops for ACPI
  PCI: PM: Do not use pci_platform_pm_ops for Intel MID PM
  ACPI: glue: Look for ACPI bus type only if ACPI companion is not known
  ACPI: glue: Drop cleanup callback from struct acpi_bus_type
  PCI: ACPI: Drop acpi_pci_bus
parents 031eda18 6f9f0eef

drivers/acpi/glue.c

+22 −12
Original line number Diff line number Diff line
@@ -17,6 +17,8 @@ 
#include <linux/rwsem.h>

#include <linux/acpi.h>

#include <linux/dma-mapping.h>

#include <linux/pci.h>

#include <linux/pci-acpi.h>

#include <linux/platform_device.h>



#include "internal.h"
@@ -287,12 +289,13 @@ EXPORT_SYMBOL_GPL(acpi_unbind_one); 


void acpi_device_notify(struct device *dev)

{

	struct acpi_bus_type *type = acpi_get_bus_type(dev);

	struct acpi_device *adev;

	int ret;



	ret = acpi_bind_one(dev, NULL);

	if (ret) {

		struct acpi_bus_type *type = acpi_get_bus_type(dev);



		if (!type)

			goto err;
@@ -304,17 +307,26 @@ void acpi_device_notify(struct device *dev) 
		ret = acpi_bind_one(dev, adev);

		if (ret)

			goto err;



		if (type->setup) {

			type->setup(dev);

			goto done;

		}

	} else {

		adev = ACPI_COMPANION(dev);



	if (dev_is_platform(dev))

		if (dev_is_pci(dev)) {

			pci_acpi_setup(dev, adev);

			goto done;

		} else if (dev_is_platform(dev)) {

			acpi_configure_pmsi_domain(dev);

		}

	}



	if (type && type->setup)

		type->setup(dev);

	else if (adev->handler && adev->handler->bind)

	if (adev->handler && adev->handler->bind)

		adev->handler->bind(dev);



done:

	acpi_handle_debug(ACPI_HANDLE(dev), "Bound to device %s\n",

			  dev_name(dev));
@@ -327,14 +339,12 @@ void acpi_device_notify(struct device *dev) 
void acpi_device_notify_remove(struct device *dev)

{

	struct acpi_device *adev = ACPI_COMPANION(dev);

	struct acpi_bus_type *type;



	if (!adev)

		return;



	type = acpi_get_bus_type(dev);

	if (type && type->cleanup)

		type->cleanup(dev);

	if (dev_is_pci(dev))

		pci_acpi_cleanup(dev, adev);

	else if (adev->handler && adev->handler->unbind)

		adev->handler->unbind(dev);

drivers/pci/pci-acpi.c

+21 −53
Original line number Diff line number Diff line
@@ -906,7 +906,7 @@ acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev, 
 *	choose highest power _SxD or any lower power

 */



static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)

pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)

{

	int acpi_state, d_max;
@@ -965,22 +965,20 @@ int pci_dev_acpi_reset(struct pci_dev *dev, bool probe) 
	return 0;

}



static bool acpi_pci_power_manageable(struct pci_dev *dev)

bool acpi_pci_power_manageable(struct pci_dev *dev)

{

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



	if (!adev)

		return false;

	return acpi_device_power_manageable(adev);

	return adev && acpi_device_power_manageable(adev);

}



static bool acpi_pci_bridge_d3(struct pci_dev *dev)

bool acpi_pci_bridge_d3(struct pci_dev *dev)

{

	const union acpi_object *obj;

	struct acpi_device *adev;

	struct pci_dev *rpdev;



	if (!dev->is_hotplug_bridge)

	if (acpi_pci_disabled || !dev->is_hotplug_bridge)

		return false;



	/* Assume D3 support if the bridge is power-manageable by ACPI. */
@@ -1008,7 +1006,7 @@ static bool acpi_pci_bridge_d3(struct pci_dev *dev) 
	return obj->integer.value == 1;

}



static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)

int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)

{

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

	static const u8 state_conv[] = {
@@ -1046,7 +1044,7 @@ 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)

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[] = {
@@ -1068,7 +1066,7 @@ static pci_power_t acpi_pci_get_power_state(struct pci_dev *dev) 
	return state_conv[state];

}



static void acpi_pci_refresh_power_state(struct pci_dev *dev)

void acpi_pci_refresh_power_state(struct pci_dev *dev)

{

	struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
@@ -1093,17 +1091,23 @@ static int acpi_pci_propagate_wakeup(struct pci_bus *bus, bool enable) 
	return 0;

}



static int acpi_pci_wakeup(struct pci_dev *dev, bool enable)

int acpi_pci_wakeup(struct pci_dev *dev, bool enable)

{

	if (acpi_pci_disabled)

		return 0;



	if (acpi_pm_device_can_wakeup(&dev->dev))

		return acpi_pm_set_device_wakeup(&dev->dev, enable);



	return acpi_pci_propagate_wakeup(dev->bus, enable);

}



static bool acpi_pci_need_resume(struct pci_dev *dev)

bool acpi_pci_need_resume(struct pci_dev *dev)

{

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

	struct acpi_device *adev;



	if (acpi_pci_disabled)

		return false;



	/*

	 * In some cases (eg. Samsung 305V4A) leaving a bridge in suspend over
@@ -1115,6 +1119,7 @@ static bool acpi_pci_need_resume(struct pci_dev *dev) 
	if (pci_is_bridge(dev) && acpi_target_system_state() != ACPI_STATE_S0)

		return true;



	adev = ACPI_COMPANION(&dev->dev);

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

		return false;
@@ -1128,17 +1133,6 @@ static bool acpi_pci_need_resume(struct pci_dev *dev) 
	return !!adev->power.flags.dsw_present;

}



static const struct pci_platform_pm_ops acpi_pci_platform_pm = {

	.bridge_d3 = acpi_pci_bridge_d3,

	.is_manageable = acpi_pci_power_manageable,

	.set_state = acpi_pci_set_power_state,

	.get_state = acpi_pci_get_power_state,

	.refresh_state = acpi_pci_refresh_power_state,

	.choose_state = acpi_pci_choose_state,

	.set_wakeup = acpi_pci_wakeup,

	.need_resume = acpi_pci_need_resume,

};



void acpi_pci_add_bus(struct pci_bus *bus)

{

	union acpi_object *obj;
@@ -1356,13 +1350,9 @@ static void pci_acpi_set_external_facing(struct pci_dev *dev) 
		dev->external_facing = 1;

}



static void pci_acpi_setup(struct device *dev)

void pci_acpi_setup(struct device *dev, struct acpi_device *adev)

{

	struct pci_dev *pci_dev = to_pci_dev(dev);

	struct acpi_device *adev = ACPI_COMPANION(dev);



	if (!adev)

		return;



	pci_acpi_optimize_delay(pci_dev, adev->handle);

	pci_acpi_set_external_facing(pci_dev);
@@ -1386,14 +1376,10 @@ static void pci_acpi_setup(struct device *dev) 
	acpi_device_power_add_dependent(adev, dev);

}



static void pci_acpi_cleanup(struct device *dev)

void pci_acpi_cleanup(struct device *dev, struct acpi_device *adev)

{

	struct acpi_device *adev = ACPI_COMPANION(dev);

	struct pci_dev *pci_dev = to_pci_dev(dev);



	if (!adev)

		return;



	pci_acpi_remove_edr_notifier(pci_dev);

	pci_acpi_remove_pm_notifier(adev);

	if (adev->wakeup.flags.valid) {
@@ -1405,20 +1391,6 @@ static void pci_acpi_cleanup(struct device *dev) 
	}

}



static bool pci_acpi_bus_match(struct device *dev)

{

	return dev_is_pci(dev);

}



static struct acpi_bus_type acpi_pci_bus = {

	.name = "PCI",

	.match = pci_acpi_bus_match,

	.find_companion = acpi_pci_find_companion,

	.setup = pci_acpi_setup,

	.cleanup = pci_acpi_cleanup,

};





static struct fwnode_handle *(*pci_msi_get_fwnode_cb)(struct device *dev);



/**
@@ -1460,8 +1432,6 @@ struct irq_domain *pci_host_bridge_acpi_msi_domain(struct pci_bus *bus) 


static int __init acpi_pci_init(void)

{

	int ret;



	if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {

		pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");

		pci_no_msi();
@@ -1472,11 +1442,9 @@ static int __init acpi_pci_init(void) 
		pcie_no_aspm();

	}



	ret = register_acpi_bus_type(&acpi_pci_bus);

	if (ret)

	if (acpi_pci_disabled)

		return 0;



	pci_set_platform_pm(&acpi_pci_platform_pm);

	acpi_pci_slot_init();

	acpiphp_init();

drivers/pci/pci-mid.c

+8 −29
Original line number Diff line number Diff line
@@ -16,45 +16,23 @@ 


#include "pci.h"



static bool mid_pci_power_manageable(struct pci_dev *dev)

static bool pci_mid_pm_enabled __read_mostly;



bool pci_use_mid_pm(void)

{

	return true;

	return pci_mid_pm_enabled;

}



static int mid_pci_set_power_state(struct pci_dev *pdev, pci_power_t state)

int mid_pci_set_power_state(struct pci_dev *pdev, pci_power_t state)

{

	return intel_mid_pci_set_power_state(pdev, state);

}



static pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)

pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)

{

	return intel_mid_pci_get_power_state(pdev);

}



static pci_power_t mid_pci_choose_state(struct pci_dev *pdev)

{

	return PCI_D3hot;

}



static int mid_pci_wakeup(struct pci_dev *dev, bool enable)

{

	return 0;

}



static bool mid_pci_need_resume(struct pci_dev *dev)

{

	return false;

}



static const struct pci_platform_pm_ops mid_pci_platform_pm = {

	.is_manageable	= mid_pci_power_manageable,

	.set_state	= mid_pci_set_power_state,

	.get_state	= mid_pci_get_power_state,

	.choose_state	= mid_pci_choose_state,

	.set_wakeup	= mid_pci_wakeup,

	.need_resume	= mid_pci_need_resume,

};



/*

 * This table should be in sync with the one in

 * arch/x86/platform/intel-mid/pwr.c.
@@ -71,7 +49,8 @@ static int __init mid_pci_init(void) 


	id = x86_match_cpu(lpss_cpu_ids);

	if (id)

		pci_set_platform_pm(&mid_pci_platform_pm);

		pci_mid_pm_enabled = true;



	return 0;

}

arch_initcall(mid_pci_init);

drivers/pci/pci.c

+66 −88
Original line number Diff line number Diff line
@@ -972,61 +972,67 @@ static void pci_restore_bars(struct pci_dev *dev) 
		pci_update_resource(dev, i);

}



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->get_state ||

	    !ops->choose_state  || !ops->set_wakeup || !ops->need_resume)

		return -EINVAL;

	pci_platform_pm = ops;

	return 0;

}



static inline bool platform_pci_power_manageable(struct pci_dev *dev)

{

	return pci_platform_pm ? pci_platform_pm->is_manageable(dev) : false;

	if (pci_use_mid_pm())

		return true;



	return acpi_pci_power_manageable(dev);

}



static inline int platform_pci_set_power_state(struct pci_dev *dev,

					       pci_power_t t)

{

	return pci_platform_pm ? pci_platform_pm->set_state(dev, t) : -ENOSYS;

	if (pci_use_mid_pm())

		return mid_pci_set_power_state(dev, t);



	return acpi_pci_set_power_state(dev, t);

}



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;

	if (pci_use_mid_pm())

		return mid_pci_get_power_state(dev);



	return acpi_pci_get_power_state(dev);

}



static inline void platform_pci_refresh_power_state(struct pci_dev *dev)

{

	if (pci_platform_pm && pci_platform_pm->refresh_state)

		pci_platform_pm->refresh_state(dev);

	if (!pci_use_mid_pm())

		acpi_pci_refresh_power_state(dev);

}



static inline pci_power_t platform_pci_choose_state(struct pci_dev *dev)

{

	return pci_platform_pm ?

			pci_platform_pm->choose_state(dev) : PCI_POWER_ERROR;

	if (pci_use_mid_pm())

		return PCI_POWER_ERROR;



	return acpi_pci_choose_state(dev);

}



static inline int platform_pci_set_wakeup(struct pci_dev *dev, bool enable)

{

	return pci_platform_pm ?

			pci_platform_pm->set_wakeup(dev, enable) : -ENODEV;

	if (pci_use_mid_pm())

		return PCI_POWER_ERROR;



	return acpi_pci_wakeup(dev, enable);

}



static inline bool platform_pci_need_resume(struct pci_dev *dev)

{

	return pci_platform_pm ? pci_platform_pm->need_resume(dev) : false;

	if (pci_use_mid_pm())

		return false;



	return acpi_pci_need_resume(dev);

}



static inline bool platform_pci_bridge_d3(struct pci_dev *dev)

{

	if (pci_platform_pm && pci_platform_pm->bridge_d3)

		return pci_platform_pm->bridge_d3(dev);

	if (pci_use_mid_pm())

		return false;



	return acpi_pci_bridge_d3(dev);

}



/**
@@ -1185,9 +1191,7 @@ void pci_update_current_state(struct pci_dev *dev, pci_power_t state) 
 */

void pci_refresh_power_state(struct pci_dev *dev)

{

	if (platform_pci_power_manageable(dev))

	platform_pci_refresh_power_state(dev);



	pci_update_current_state(dev, dev->current_state);

}
@@ -1200,14 +1204,10 @@ int pci_platform_power_transition(struct pci_dev *dev, pci_power_t state) 
{

	int error;



	if (platform_pci_power_manageable(dev)) {

	error = platform_pci_set_power_state(dev, state);

	if (!error)

		pci_update_current_state(dev, state);

	} else

		error = -ENODEV;



	if (error && !dev->pm_cap) /* Fall back to PCI_D0 */

	else if (!dev->pm_cap) /* Fall back to PCI_D0 */

		dev->current_state = PCI_D0;



	return error;
@@ -1388,44 +1388,6 @@ int pci_set_power_state(struct pci_dev *dev, pci_power_t state) 
}

EXPORT_SYMBOL(pci_set_power_state);



/**

 * pci_choose_state - Choose the power state of a PCI device

 * @dev: PCI device to be suspended

 * @state: target sleep state for the whole system. This is the value

 *	   that is passed to suspend() function.

 *

 * Returns PCI power state suitable for given device and given system

 * message.

 */

pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state)

{

	pci_power_t ret;



	if (!dev->pm_cap)

		return PCI_D0;



	ret = platform_pci_choose_state(dev);

	if (ret != PCI_POWER_ERROR)

		return ret;



	switch (state.event) {

	case PM_EVENT_ON:

		return PCI_D0;

	case PM_EVENT_FREEZE:

	case PM_EVENT_PRETHAW:

		/* REVISIT both freeze and pre-thaw "should" use D0 */

	case PM_EVENT_SUSPEND:

	case PM_EVENT_HIBERNATE:

		return PCI_D3hot;

	default:

		pci_info(dev, "unrecognized suspend event %d\n",

			 state.event);

		BUG();

	}

	return PCI_D0;

}

EXPORT_SYMBOL(pci_choose_state);



#define PCI_EXP_SAVE_REGS	7



static struct pci_cap_saved_state *_pci_find_saved_cap(struct pci_dev *pci_dev,
@@ -2577,8 +2539,6 @@ EXPORT_SYMBOL(pci_wake_from_d3); 
 */

static pci_power_t pci_target_state(struct pci_dev *dev, bool wakeup)

{

	pci_power_t target_state = PCI_D3hot;



	if (platform_pci_power_manageable(dev)) {

		/*

		 * Call the platform to find the target state for the device.
@@ -2588,32 +2548,29 @@ static pci_power_t pci_target_state(struct pci_dev *dev, bool wakeup) 
		switch (state) {

		case PCI_POWER_ERROR:

		case PCI_UNKNOWN:

			break;

			return PCI_D3hot;



		case PCI_D1:

		case PCI_D2:

			if (pci_no_d1d2(dev))

				break;

			fallthrough;

		default:

			target_state = state;

				return PCI_D3hot;

		}



		return target_state;

		return state;

	}



	if (!dev->pm_cap)

		target_state = PCI_D0;



	/*

	 * 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;

		return PCI_D3cold;

	else if (!dev->pm_cap)

		return PCI_D0;



	if (wakeup && dev->pme_support) {

		pci_power_t state = target_state;

		pci_power_t state = PCI_D3hot;



		/*

		 * Find the deepest state from which the device can generate
@@ -2628,7 +2585,7 @@ static pci_power_t pci_target_state(struct pci_dev *dev, bool wakeup) 
			return PCI_D0;

	}



	return target_state;

	return PCI_D3hot;

}



/**
@@ -2681,8 +2638,13 @@ EXPORT_SYMBOL(pci_prepare_to_sleep); 
 */

int pci_back_from_sleep(struct pci_dev *dev)

{

	int ret = pci_set_power_state(dev, PCI_D0);



	if (ret)

		return ret;



	pci_enable_wake(dev, PCI_D0, false);

	return pci_set_power_state(dev, PCI_D0);

	return 0;

}

EXPORT_SYMBOL(pci_back_from_sleep);
@@ -2842,6 +2804,22 @@ void pci_dev_complete_resume(struct pci_dev *pci_dev) 
	spin_unlock_irq(&dev->power.lock);

}



/**

 * pci_choose_state - Choose the power state of a PCI device.

 * @dev: Target PCI device.

 * @state: Target state for the whole system.

 *

 * Returns PCI power state suitable for @dev and @state.

 */

pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state)

{

	if (state.event == PM_EVENT_ON)

		return PCI_D0;



	return pci_target_state(dev, false);

}

EXPORT_SYMBOL(pci_choose_state);



void pci_config_pm_runtime_get(struct pci_dev *pdev)

{

	struct device *dev = &pdev->dev;

drivers/pci/pci.h

+56 −40
Original line number Diff line number Diff line
@@ -63,45 +63,6 @@ struct pci_cap_saved_state *pci_find_saved_ext_cap(struct pci_dev *dev, 
#define PCI_PM_D3HOT_WAIT       10	/* msec */

#define PCI_PM_D3COLD_WAIT      100	/* msec */



/**

 * struct pci_platform_pm_ops - Firmware PM callbacks

 *

 * @bridge_d3: Does the bridge allow entering into D3

 *

 * @is_manageable: returns 'true' if given device is power manageable by the

 *		   platform firmware

 *

 * @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

 *

 * @refresh_state: asks the platform to refresh the device's power state data

 *

 * @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

 *

 * @set_wakeup: enables/disables wakeup capability for the device

 *

 * @need_resume: returns 'true' if the given device (which is currently

 *		 suspended) needs to be resumed to be configured for system

 *		 wakeup.

 *

 * If given platform is generally capable of power managing PCI devices, all of

 * these callbacks are mandatory.

 */

struct pci_platform_pm_ops {

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

	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);

	void (*refresh_state)(struct pci_dev *dev);

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

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

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

};



int pci_set_platform_pm(const struct pci_platform_pm_ops *ops);

void pci_update_current_state(struct pci_dev *dev, pci_power_t state);

void pci_refresh_power_state(struct pci_dev *dev);

int pci_power_up(struct pci_dev *dev);
@@ -725,17 +686,53 @@ int pci_acpi_program_hp_params(struct pci_dev *dev); 
extern const struct attribute_group pci_dev_acpi_attr_group;

void pci_set_acpi_fwnode(struct pci_dev *dev);

int pci_dev_acpi_reset(struct pci_dev *dev, bool probe);

bool acpi_pci_power_manageable(struct pci_dev *dev);

bool acpi_pci_bridge_d3(struct pci_dev *dev);

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

pci_power_t acpi_pci_get_power_state(struct pci_dev *dev);

void acpi_pci_refresh_power_state(struct pci_dev *dev);

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

bool acpi_pci_need_resume(struct pci_dev *dev);

pci_power_t acpi_pci_choose_state(struct pci_dev *pdev);

#else

static inline int pci_dev_acpi_reset(struct pci_dev *dev, bool probe)

{

	return -ENOTTY;

}



static inline void pci_set_acpi_fwnode(struct pci_dev *dev) {}

static inline int pci_acpi_program_hp_params(struct pci_dev *dev)

{

	return -ENODEV;

}

static inline bool acpi_pci_power_manageable(struct pci_dev *dev)

{

	return false;

}

static inline bool acpi_pci_bridge_d3(struct pci_dev *dev)

{

	return false;

}

static inline int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)

{

	return -ENODEV;

}

static inline pci_power_t acpi_pci_get_power_state(struct pci_dev *dev)

{

	return PCI_UNKNOWN;

}

static inline void acpi_pci_refresh_power_state(struct pci_dev *dev) {}

static inline int acpi_pci_wakeup(struct pci_dev *dev, bool enable)

{

	return -ENODEV;

}

static inline bool acpi_pci_need_resume(struct pci_dev *dev)

{

	return false;

}

static inline pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)

{

	return PCI_POWER_ERROR;

}

#endif



#ifdef CONFIG_PCIEASPM
@@ -744,4 +741,23 @@ extern const struct attribute_group aspm_ctrl_attr_group; 


extern const struct attribute_group pci_dev_reset_method_attr_group;



#ifdef CONFIG_X86_INTEL_MID

bool pci_use_mid_pm(void);

int mid_pci_set_power_state(struct pci_dev *pdev, pci_power_t state);

pci_power_t mid_pci_get_power_state(struct pci_dev *pdev);

#else

static inline bool pci_use_mid_pm(void)

{

	return false;

}

static inline int mid_pci_set_power_state(struct pci_dev *pdev, pci_power_t state)

{

	return -ENODEV;

}

static inline pci_power_t mid_pci_get_power_state(struct pci_dev *pdev)

{

	return PCI_UNKNOWN;

}

#endif



#endif /* DRIVERS_PCI_H */