Merge branches 'acpi-pm' and 'pm-pci' (50e163d4) · Commits · 戴 / test

drivers/acpi/acpi_lpit.c

+3 −4

Original line number	Diff line number	Diff line
		@@ -129,7 +129,7 @@ static void lpit_update_residency(struct lpit_residency_info *info,

		static void lpit_process(u64 begin, u64 end)
		{
		while (begin + sizeof(struct acpi_lpit_native) < end) {
		while (begin + sizeof(struct acpi_lpit_native) <= end) {
		struct acpi_lpit_native lpit_native = (struct acpi_lpit_native )begin;

		if (!lpit_native->header.type && !lpit_native->header.flags) {
		@@ -148,7 +148,6 @@ static void lpit_process(u64 begin, u64 end)
		void acpi_init_lpit(void)
		{
		acpi_status status;
		u64 lpit_begin;
		struct acpi_table_lpit *lpit;

		status = acpi_get_table(ACPI_SIG_LPIT, 0, (struct acpi_table_header **)&lpit);
		@@ -156,6 +155,6 @@ void acpi_init_lpit(void)
		if (ACPI_FAILURE(status))
		return;

		lpit_begin = (u64)lpit + sizeof(*lpit);
		lpit_process(lpit_begin, lpit_begin + lpit->header.length);
		lpit_process((u64)lpit + sizeof(*lpit),
		(u64)lpit + lpit->header.length);
		}

drivers/acpi/device_pm.c

+59 −12

Original line number	Diff line number	Diff line
		@@ -45,6 +45,19 @@ const char *acpi_power_state_string(int state)
		}
		}

		static int acpi_dev_pm_explicit_get(struct acpi_device device, int state)
		{
		unsigned long long psc;
		acpi_status status;

		status = acpi_evaluate_integer(device->handle, "_PSC", NULL, &psc);
		if (ACPI_FAILURE(status))
		return -ENODEV;

		*state = psc;
		return 0;
		}

		/**
		* acpi_device_get_power - Get power state of an ACPI device.
		* @device: Device to get the power state of.
		@@ -53,10 +66,16 @@ const char *acpi_power_state_string(int state)
		* This function does not update the device's power.state field, but it may
		* update its parent's power.state field (when the parent's power state is
		* unknown and the device's power state turns out to be D0).
		*
		* Also, it does not update power resource reference counters to ensure that
		* the power state returned by it will be persistent and it may return a power
		* state shallower than previously set by acpi_device_set_power() for @device
		* (if that power state depends on any power resources).
		*/
		int acpi_device_get_power(struct acpi_device device, int state)
		{
		int result = ACPI_STATE_UNKNOWN;
		int error;

		if (!device \|\| !state)
		return -EINVAL;
		@@ -73,18 +92,16 @@ int acpi_device_get_power(struct acpi_device device, int state)
		* if available.
		*/
		if (device->power.flags.power_resources) {
		int error = acpi_power_get_inferred_state(device, &result);
		error = acpi_power_get_inferred_state(device, &result);
		if (error)
		return error;
		}
		if (device->power.flags.explicit_get) {
		acpi_handle handle = device->handle;
		unsigned long long psc;
		acpi_status status;
		int psc;

		status = acpi_evaluate_integer(handle, "_PSC", NULL, &psc);
		if (ACPI_FAILURE(status))
		return -ENODEV;
		error = acpi_dev_pm_explicit_get(device, &psc);
		if (error)
		return error;

		/*
		* The power resources settings may indicate a power state
		@@ -118,7 +135,6 @@ int acpi_device_get_power(struct acpi_device device, int state)

		return 0;
		}
		EXPORT_SYMBOL(acpi_device_get_power);

		static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
		{
		@@ -152,7 +168,8 @@ int acpi_device_set_power(struct acpi_device *device, int state)

		/* Make sure this is a valid target state */

		if (state == device->power.state) {
		/* There is a special case for D0 addressed below. */
		if (state > ACPI_STATE_D0 && state == device->power.state) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
		device->pnp.bus_id,
		acpi_power_state_string(state)));
		@@ -202,9 +219,15 @@ int acpi_device_set_power(struct acpi_device *device, int state)
		return -ENODEV;
		}

		/*
		* If the device goes from D3hot to D3cold, _PS3 has been
		* evaluated for it already, so skip it in that case.
		*/
		if (device->power.state < ACPI_STATE_D3_HOT) {
		result = acpi_dev_pm_explicit_set(device, state);
		if (result)
		goto end;
		}

		if (device->power.flags.power_resources)
		result = acpi_power_transition(device, target_state);
		@@ -214,6 +237,30 @@ int acpi_device_set_power(struct acpi_device *device, int state)
		if (result)
		goto end;
		}

		if (device->power.state == ACPI_STATE_D0) {
		int psc;

		/* Nothing to do here if _PSC is not present. */
		if (!device->power.flags.explicit_get)
		return 0;

		/*
		* The power state of the device was set to D0 last
		* time, but that might have happened before a
		* system-wide transition involving the platform
		* firmware, so it may be necessary to evaluate _PS0
		* for the device here. However, use extra care here
		* and evaluate _PSC to check the device's current power
		* state, and only invoke _PS0 if the evaluation of _PSC
		* is successful and it returns a power state different
		* from D0.
		*/
		result = acpi_dev_pm_explicit_get(device, &psc);
		if (result \|\| psc == ACPI_STATE_D0)
		return 0;
		}

		result = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
		}

drivers/acpi/internal.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -139,8 +139,15 @@ int acpi_power_get_inferred_state(struct acpi_device device, int state);
		int acpi_power_on_resources(struct acpi_device *device, int state);
		int acpi_power_transition(struct acpi_device *device, int state);

		/* --------------------------------------------------------------------------
		Device Power Management
		-------------------------------------------------------------------------- */
		int acpi_device_get_power(struct acpi_device device, int state);
		int acpi_wakeup_device_init(void);

		/* --------------------------------------------------------------------------
		Processor
		-------------------------------------------------------------------------- */
		#ifdef CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC
		void acpi_early_processor_set_pdc(void);
		#else

drivers/acpi/power.c

+135 −0

Original line number	Diff line number	Diff line
		@@ -42,6 +42,11 @@ ACPI_MODULE_NAME("power");
		#define ACPI_POWER_RESOURCE_STATE_ON 0x01
		#define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF

		struct acpi_power_dependent_device {
		struct device *dev;
		struct list_head node;
		};

		struct acpi_power_resource {
		struct acpi_device device;
		struct list_head list_node;
		@@ -51,6 +56,7 @@ struct acpi_power_resource {
		unsigned int ref_count;
		bool wakeup_enabled;
		struct mutex resource_lock;
		struct list_head dependents;
		};

		struct acpi_power_resource_entry {
		@@ -232,8 +238,121 @@ static int acpi_power_get_list_state(struct list_head list, int state)
		return 0;
		}

		static int
		acpi_power_resource_add_dependent(struct acpi_power_resource *resource,
		struct device *dev)
		{
		struct acpi_power_dependent_device *dep;
		int ret = 0;

		mutex_lock(&resource->resource_lock);
		list_for_each_entry(dep, &resource->dependents, node) {
		/* Only add it once */
		if (dep->dev == dev)
		goto unlock;
		}

		dep = kzalloc(sizeof(*dep), GFP_KERNEL);
		if (!dep) {
		ret = -ENOMEM;
		goto unlock;
		}

		dep->dev = dev;
		list_add_tail(&dep->node, &resource->dependents);
		dev_dbg(dev, "added power dependency to [%s]\n", resource->name);

		unlock:
		mutex_unlock(&resource->resource_lock);
		return ret;
		}

		static void
		acpi_power_resource_remove_dependent(struct acpi_power_resource *resource,
		struct device *dev)
		{
		struct acpi_power_dependent_device *dep;

		mutex_lock(&resource->resource_lock);
		list_for_each_entry(dep, &resource->dependents, node) {
		if (dep->dev == dev) {
		list_del(&dep->node);
		kfree(dep);
		dev_dbg(dev, "removed power dependency to [%s]\n",
		resource->name);
		break;
		}
		}
		mutex_unlock(&resource->resource_lock);
		}

		/**
		* acpi_device_power_add_dependent - Add dependent device of this ACPI device
		* @adev: ACPI device pointer
		* @dev: Dependent device
		*
		* If @adev has non-empty _PR0 the @dev is added as dependent device to all
		* power resources returned by it. This means that whenever these power
		* resources are turned _ON the dependent devices get runtime resumed. This
		* is needed for devices such as PCI to allow its driver to re-initialize
		* it after it went to D0uninitialized.
		*
		* If @adev does not have _PR0 this does nothing.
		*
		* Returns %0 in case of success and negative errno otherwise.
		*/
		int acpi_device_power_add_dependent(struct acpi_device *adev,
		struct device *dev)
		{
		struct acpi_power_resource_entry *entry;
		struct list_head *resources;
		int ret;

		if (!adev->flags.power_manageable)
		return 0;

		resources = &adev->power.states[ACPI_STATE_D0].resources;
		list_for_each_entry(entry, resources, node) {
		ret = acpi_power_resource_add_dependent(entry->resource, dev);
		if (ret)
		goto err;
		}

		return 0;

		err:
		list_for_each_entry(entry, resources, node)
		acpi_power_resource_remove_dependent(entry->resource, dev);

		return ret;
		}

		/**
		* acpi_device_power_remove_dependent - Remove dependent device
		* @adev: ACPI device pointer
		* @dev: Dependent device
		*
		* Does the opposite of acpi_device_power_add_dependent() and removes the
		* dependent device if it is found. Can be called to @adev that does not
		* have _PR0 as well.
		*/
		void acpi_device_power_remove_dependent(struct acpi_device *adev,
		struct device *dev)
		{
		struct acpi_power_resource_entry *entry;
		struct list_head *resources;

		if (!adev->flags.power_manageable)
		return;

		resources = &adev->power.states[ACPI_STATE_D0].resources;
		list_for_each_entry_reverse(entry, resources, node)
		acpi_power_resource_remove_dependent(entry->resource, dev);
		}

		static int __acpi_power_on(struct acpi_power_resource *resource)
		{
		struct acpi_power_dependent_device *dep;
		acpi_status status = AE_OK;

		status = acpi_evaluate_object(resource->device.handle, "_ON", NULL, NULL);
		@@ -243,6 +362,21 @@ static int __acpi_power_on(struct acpi_power_resource *resource)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n",
		resource->name));

		/*
		* If there are other dependents on this power resource we need to
		* resume them now so that their drivers can re-initialize the
		* hardware properly after it went back to D0.
		*/
		if (list_empty(&resource->dependents) \|\|
		list_is_singular(&resource->dependents))
		return 0;

		list_for_each_entry(dep, &resource->dependents, node) {
		dev_dbg(dep->dev, "runtime resuming because [%s] turned on\n",
		resource->name);
		pm_request_resume(dep->dev);
		}

		return 0;
		}

		@@ -810,6 +944,7 @@ int acpi_add_power_resource(acpi_handle handle)
		ACPI_STA_DEFAULT);
		mutex_init(&resource->resource_lock);
		INIT_LIST_HEAD(&resource->list_node);
		INIT_LIST_HEAD(&resource->dependents);
		resource->name = device->pnp.bus_id;
		strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
		strcpy(acpi_device_class(device), ACPI_POWER_CLASS);

drivers/acpi/sleep.c

+7 −15

Original line number	Diff line number	Diff line
		@@ -77,7 +77,7 @@ static int acpi_sleep_prepare(u32 acpi_state)
		return 0;
		}

		static bool acpi_sleep_state_supported(u8 sleep_state)
		bool acpi_sleep_state_supported(u8 sleep_state)
		{
		acpi_status status;
		u8 type_a, type_b;
		@@ -452,14 +452,6 @@ static int acpi_pm_prepare(void)
		return error;
		}

		static int find_powerf_dev(struct device dev, void data)
		{
		struct acpi_device *device = to_acpi_device(dev);
		const char *hid = acpi_device_hid(device);

		return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
		}

		/**
		* acpi_pm_finish - Instruct the platform to leave a sleep state.
		*
		@@ -468,7 +460,7 @@ static int find_powerf_dev(struct device dev, void data)
		*/
		static void acpi_pm_finish(void)
		{
		struct device *pwr_btn_dev;
		struct acpi_device *pwr_btn_adev;
		u32 acpi_state = acpi_target_sleep_state;

		acpi_ec_unblock_transactions();
		@@ -499,11 +491,11 @@ static void acpi_pm_finish(void)
		return;

		pwr_btn_event_pending = false;
		pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
		find_powerf_dev);
		if (pwr_btn_dev) {
		pm_wakeup_event(pwr_btn_dev, 0);
		put_device(pwr_btn_dev);
		pwr_btn_adev = acpi_dev_get_first_match_dev(ACPI_BUTTON_HID_POWERF,
		NULL, -1);
		if (pwr_btn_adev) {
		pm_wakeup_event(&pwr_btn_adev->dev, 0);
		acpi_dev_put(pwr_btn_adev);
		}
		}

Admin message