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

Commit 805c5281 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branches 'acpi-pm', 'acpi-sleep' and 'acpi-button' 

* acpi-pm:
  ACPI / PM: Use ACPI_COMPANION() instead of ACPI_HANDLE()
  ACPI / PM: Always enable wakeup GPEs when enabling device wakeup
  ACPI / PM: Revork the handling of ACPI device wakeup notifications
  PM: Create PM workqueue if runtime PM is not configured too

* acpi-sleep:
  ACPI / sleep: Do not save NVS for new machines to accelerate S3

* acpi-button:
  ACPI / button: Do not propagate wakeup-from-suspend events
parents a60b2399 17653a3e 821d6f03 e71eeb2a

drivers/acpi/button.c

+21 −4
Original line number Diff line number Diff line
@@ -79,11 +79,13 @@ static int acpi_button_remove(struct acpi_device *device); 
static void acpi_button_notify(struct acpi_device *device, u32 event);



#ifdef CONFIG_PM_SLEEP

static int acpi_button_suspend(struct device *dev);

static int acpi_button_resume(struct device *dev);

#else

#define acpi_button_suspend NULL

#define acpi_button_resume NULL

#endif

static SIMPLE_DEV_PM_OPS(acpi_button_pm, NULL, acpi_button_resume);

static SIMPLE_DEV_PM_OPS(acpi_button_pm, acpi_button_suspend, acpi_button_resume);



static struct acpi_driver acpi_button_driver = {

	.name = "button",
@@ -102,6 +104,7 @@ struct acpi_button { 
	struct input_dev *input;

	char phys[32];			/* for input device */

	unsigned long pushed;

	bool suspended;

};



static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier);
@@ -293,15 +296,19 @@ static void acpi_button_notify(struct acpi_device *device, u32 event) 
		if (button->type == ACPI_BUTTON_TYPE_LID) {

			acpi_lid_send_state(device);

		} else {

			int keycode = test_bit(KEY_SLEEP, input->keybit) ?

						KEY_SLEEP : KEY_POWER;

			int keycode;



			pm_wakeup_event(&device->dev, 0);

			if (button->suspended)

				break;



			keycode = test_bit(KEY_SLEEP, input->keybit) ?

						KEY_SLEEP : KEY_POWER;

			input_report_key(input, keycode, 1);

			input_sync(input);

			input_report_key(input, keycode, 0);

			input_sync(input);



			pm_wakeup_event(&device->dev, 0);

			acpi_bus_generate_netlink_event(

					device->pnp.device_class,

					dev_name(&device->dev),
@@ -316,11 +323,21 @@ static void acpi_button_notify(struct acpi_device *device, u32 event) 
}



#ifdef CONFIG_PM_SLEEP

static int acpi_button_suspend(struct device *dev)

{

	struct acpi_device *device = to_acpi_device(dev);

	struct acpi_button *button = acpi_driver_data(device);



	button->suspended = true;

	return 0;

}



static int acpi_button_resume(struct device *dev)

{

	struct acpi_device *device = to_acpi_device(dev);

	struct acpi_button *button = acpi_driver_data(device);



	button->suspended = false;

	if (button->type == ACPI_BUTTON_TYPE_LID)

		return acpi_lid_send_state(device);

	return 0;

drivers/acpi/device_pm.c

+83 −65
Original line number Diff line number Diff line
@@ -367,29 +367,61 @@ EXPORT_SYMBOL(acpi_bus_power_manageable); 
#ifdef CONFIG_PM

static DEFINE_MUTEX(acpi_pm_notifier_lock);



static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)

{

	struct acpi_device *adev;



	if (val != ACPI_NOTIFY_DEVICE_WAKE)

		return;



	adev = acpi_bus_get_acpi_device(handle);

	if (!adev)

		return;



	mutex_lock(&acpi_pm_notifier_lock);



	if (adev->wakeup.flags.notifier_present) {

		__pm_wakeup_event(adev->wakeup.ws, 0);

		if (adev->wakeup.context.work.func)

			queue_pm_work(&adev->wakeup.context.work);

	}



	mutex_unlock(&acpi_pm_notifier_lock);



	acpi_bus_put_acpi_device(adev);

}



/**

 * acpi_add_pm_notifier - Register PM notifier for given ACPI device.

 * @adev: ACPI device to add the notifier for.

 * @context: Context information to pass to the notifier routine.

 * acpi_add_pm_notifier - Register PM notify handler for given ACPI device.

 * @adev: ACPI device to add the notify handler for.

 * @dev: Device to generate a wakeup event for while handling the notification.

 * @work_func: Work function to execute when handling the notification.

 *

 * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of

 * PM wakeup events.  For example, wakeup events may be generated for bridges

 * if one of the devices below the bridge is signaling wakeup, even if the

 * bridge itself doesn't have a wakeup GPE associated with it.

 */

acpi_status acpi_add_pm_notifier(struct acpi_device *adev,

				 acpi_notify_handler handler, void *context)

acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,

				 void (*work_func)(struct work_struct *work))

{

	acpi_status status = AE_ALREADY_EXISTS;



	if (!dev && !work_func)

		return AE_BAD_PARAMETER;



	mutex_lock(&acpi_pm_notifier_lock);



	if (adev->wakeup.flags.notifier_present)

		goto out;



	status = acpi_install_notify_handler(adev->handle,

					     ACPI_SYSTEM_NOTIFY,

					     handler, context);

	adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev));

	adev->wakeup.context.dev = dev;

	if (work_func)

		INIT_WORK(&adev->wakeup.context.work, work_func);



	status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,

					     acpi_pm_notify_handler, NULL);

	if (ACPI_FAILURE(status))

		goto out;
@@ -404,8 +436,7 @@ acpi_status acpi_add_pm_notifier(struct acpi_device *adev, 
 * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.

 * @adev: ACPI device to remove the notifier from.

 */

acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,

				    acpi_notify_handler handler)

acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)

{

	acpi_status status = AE_BAD_PARAMETER;
@@ -416,10 +447,17 @@ acpi_status acpi_remove_pm_notifier(struct acpi_device *adev, 


	status = acpi_remove_notify_handler(adev->handle,

					    ACPI_SYSTEM_NOTIFY,

					    handler);

					    acpi_pm_notify_handler);

	if (ACPI_FAILURE(status))

		goto out;



	if (adev->wakeup.context.work.func) {

		cancel_work_sync(&adev->wakeup.context.work);

		adev->wakeup.context.work.func = NULL;

	}

	adev->wakeup.context.dev = NULL;

	wakeup_source_unregister(adev->wakeup.ws);



	adev->wakeup.flags.notifier_present = false;



 out:
@@ -558,7 +596,6 @@ static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev, 
 */

int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)

{

	acpi_handle handle = ACPI_HANDLE(dev);

	struct acpi_device *adev;

	int ret, d_min, d_max;
@@ -573,8 +610,9 @@ int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in) 
			d_max_in = ACPI_STATE_D3_HOT;

	}



	if (!handle || acpi_bus_get_device(handle, &adev)) {

		dev_dbg(dev, "ACPI handle without context in %s!\n", __func__);

	adev = ACPI_COMPANION(dev);

	if (!adev) {

		dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);

		return -ENODEV;

	}
@@ -600,26 +638,25 @@ int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in) 
}

EXPORT_SYMBOL(acpi_pm_device_sleep_state);



#ifdef CONFIG_PM_RUNTIME

/**

 * acpi_wakeup_device - Wakeup notification handler for ACPI devices.

 * @handle: ACPI handle of the device the notification is for.

 * @event: Type of the signaled event.

 * @context: Device corresponding to @handle.

 * acpi_pm_notify_work_func - ACPI devices wakeup notification work function.

 * @work: Work item to handle.

 */

static void acpi_wakeup_device(acpi_handle handle, u32 event, void *context)

static void acpi_pm_notify_work_func(struct work_struct *work)

{

	struct device *dev = context;

	struct device *dev;



	if (event == ACPI_NOTIFY_DEVICE_WAKE && dev) {

	dev = container_of(work, struct acpi_device_wakeup_context, work)->dev;

	if (dev) {

		pm_wakeup_event(dev, 0);

		pm_runtime_resume(dev);

	}

}



/**

 * __acpi_device_run_wake - Enable/disable runtime remote wakeup for device.

 * @adev: ACPI device to enable/disable the remote wakeup for.

 * acpi_device_wakeup - Enable/disable wakeup functionality for device.

 * @adev: ACPI device to enable/disable wakeup functionality for.

 * @target_state: State the system is transitioning into.

 * @enable: Whether to enable or disable the wakeup functionality.

 *

 * Enable/disable the GPE associated with @adev so that it can generate
@@ -629,7 +666,8 @@ static void acpi_wakeup_device(acpi_handle handle, u32 event, void *context) 
 * Callers must ensure that @adev is a valid ACPI device node before executing

 * this function.

 */

int __acpi_device_run_wake(struct acpi_device *adev, bool enable)

static int acpi_device_wakeup(struct acpi_device *adev, u32 target_state,

			      bool enable)

{

	struct acpi_device_wakeup *wakeup = &adev->wakeup;
@@ -637,7 +675,7 @@ int __acpi_device_run_wake(struct acpi_device *adev, bool enable) 
		acpi_status res;

		int error;



		error = acpi_enable_wakeup_device_power(adev, ACPI_STATE_S0);

		error = acpi_enable_wakeup_device_power(adev, target_state);

		if (error)

			return error;
@@ -653,6 +691,7 @@ int __acpi_device_run_wake(struct acpi_device *adev, bool enable) 
	return 0;

}



#ifdef CONFIG_PM_RUNTIME

/**

 * acpi_pm_device_run_wake - Enable/disable remote wakeup for given device.

 * @dev: Device to enable/disable the platform to wake up.
@@ -661,41 +700,22 @@ int __acpi_device_run_wake(struct acpi_device *adev, bool enable) 
int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)

{

	struct acpi_device *adev;

	acpi_handle handle;



	if (!device_run_wake(phys_dev))

		return -EINVAL;



	handle = ACPI_HANDLE(phys_dev);

	if (!handle || acpi_bus_get_device(handle, &adev)) {

		dev_dbg(phys_dev, "ACPI handle without context in %s!\n",

			__func__);

	adev = ACPI_COMPANION(phys_dev);

	if (!adev) {

		dev_dbg(phys_dev, "ACPI companion missing in %s!\n", __func__);

		return -ENODEV;

	}



	return __acpi_device_run_wake(adev, enable);

	return acpi_device_wakeup(adev, enable, ACPI_STATE_S0);

}

EXPORT_SYMBOL(acpi_pm_device_run_wake);

#else

static inline void acpi_wakeup_device(acpi_handle handle, u32 event,

				      void *context) {}

#endif /* CONFIG_PM_RUNTIME */



#ifdef CONFIG_PM_SLEEP

/**

 * __acpi_device_sleep_wake - Enable or disable device to wake up the system.

 * @dev: Device to enable/desible to wake up the system.

 * @target_state: System state the device is supposed to wake up from.

 * @enable: Whether to enable or disable @dev to wake up the system.

 */

int __acpi_device_sleep_wake(struct acpi_device *adev, u32 target_state,

			     bool enable)

{

	return enable ?

		acpi_enable_wakeup_device_power(adev, target_state) :

		acpi_disable_wakeup_device_power(adev);

}



/**

 * acpi_pm_device_sleep_wake - Enable or disable device to wake up the system.

 * @dev: Device to enable/desible to wake up the system from sleep states.
@@ -703,21 +723,19 @@ int __acpi_device_sleep_wake(struct acpi_device *adev, u32 target_state, 
 */

int acpi_pm_device_sleep_wake(struct device *dev, bool enable)

{

	acpi_handle handle;

	struct acpi_device *adev;

	int error;



	if (!device_can_wakeup(dev))

		return -EINVAL;



	handle = ACPI_HANDLE(dev);

	if (!handle || acpi_bus_get_device(handle, &adev)) {

		dev_dbg(dev, "ACPI handle without context in %s!\n", __func__);

	adev = ACPI_COMPANION(dev);

	if (!adev) {

		dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);

		return -ENODEV;

	}



	error = __acpi_device_sleep_wake(adev, acpi_target_system_state(),

					 enable);

	error = acpi_device_wakeup(adev, acpi_target_system_state(), enable);

	if (!error)

		dev_info(dev, "System wakeup %s by ACPI\n",

				enable ? "enabled" : "disabled");
@@ -775,13 +793,13 @@ int acpi_dev_runtime_suspend(struct device *dev) 


	remote_wakeup = dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) >

				PM_QOS_FLAGS_NONE;

	error = __acpi_device_run_wake(adev, remote_wakeup);

	error = acpi_device_wakeup(adev, ACPI_STATE_S0, remote_wakeup);

	if (remote_wakeup && error)

		return -EAGAIN;



	error = acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);

	if (error)

		__acpi_device_run_wake(adev, false);

		acpi_device_wakeup(adev, ACPI_STATE_S0, false);



	return error;

}
@@ -804,7 +822,7 @@ int acpi_dev_runtime_resume(struct device *dev) 
		return 0;



	error = acpi_dev_pm_full_power(adev);

	__acpi_device_run_wake(adev, false);

	acpi_device_wakeup(adev, ACPI_STATE_S0, false);

	return error;

}

EXPORT_SYMBOL_GPL(acpi_dev_runtime_resume);
@@ -860,13 +878,13 @@ int acpi_dev_suspend_late(struct device *dev) 


	target_state = acpi_target_system_state();

	wakeup = device_may_wakeup(dev);

	error = __acpi_device_sleep_wake(adev, target_state, wakeup);

	error = acpi_device_wakeup(adev, target_state, wakeup);

	if (wakeup && error)

		return error;



	error = acpi_dev_pm_low_power(dev, adev, target_state);

	if (error)

		__acpi_device_sleep_wake(adev, ACPI_STATE_UNKNOWN, false);

		acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false);



	return error;

}
@@ -889,7 +907,7 @@ int acpi_dev_resume_early(struct device *dev) 
		return 0;



	error = acpi_dev_pm_full_power(adev);

	__acpi_device_sleep_wake(adev, ACPI_STATE_UNKNOWN, false);

	acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false);

	return error;

}

EXPORT_SYMBOL_GPL(acpi_dev_resume_early);
@@ -1048,11 +1066,11 @@ int acpi_dev_pm_attach(struct device *dev, bool power_on) 
	if (dev->pm_domain)

		return -EEXIST;



	acpi_add_pm_notifier(adev, acpi_wakeup_device, dev);

	acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);

	dev->pm_domain = &acpi_general_pm_domain;

	if (power_on) {

		acpi_dev_pm_full_power(adev);

		__acpi_device_run_wake(adev, false);

		acpi_device_wakeup(adev, ACPI_STATE_S0, false);

	}

	return 0;

}
@@ -1076,7 +1094,7 @@ void acpi_dev_pm_detach(struct device *dev, bool power_off) 


	if (adev && dev->pm_domain == &acpi_general_pm_domain) {

		dev->pm_domain = NULL;

		acpi_remove_pm_notifier(adev, acpi_wakeup_device);

		acpi_remove_pm_notifier(adev);

		if (power_off) {

			/*

			 * If the device's PM QoS resume latency limit or flags
@@ -1086,7 +1104,7 @@ void acpi_dev_pm_detach(struct device *dev, bool power_off) 
			 */

			dev_pm_qos_hide_latency_limit(dev);

			dev_pm_qos_hide_flags(dev);

			__acpi_device_run_wake(adev, false);

			acpi_device_wakeup(adev, ACPI_STATE_S0, false);

			acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);

		}

	}

drivers/acpi/pci_root.c

+1 −1
Original line number Diff line number Diff line
@@ -593,7 +593,7 @@ static int acpi_pci_root_add(struct acpi_device *device, 
	if (no_aspm)

		pcie_no_aspm();



	pci_acpi_add_bus_pm_notifier(device, root->bus);

	pci_acpi_add_bus_pm_notifier(device);

	if (device->wakeup.flags.run_wake)

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

drivers/acpi/sleep.c

+5 −0
Original line number Diff line number Diff line
@@ -322,6 +322,11 @@ static struct dmi_system_id acpisleep_dmi_table[] __initdata = { 


static void acpi_sleep_dmi_check(void)

{

	int year;



	if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year >= 2012)

		acpi_nvs_nosave_s3();



	dmi_check_system(acpisleep_dmi_table);

}

drivers/pci/pci-acpi.c

+20 −40
Original line number Diff line number Diff line
@@ -18,31 +18,31 @@ 
#include "pci.h"



/**

 * pci_acpi_wake_bus - Wake-up notification handler for root buses.

 * @handle: ACPI handle of a device the notification is for.

 * @event: Type of the signaled event.

 * @context: PCI root bus to wake up devices on.

 * pci_acpi_wake_bus - Root bus wakeup notification fork function.

 * @work: Work item to handle.

 */

static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context)

static void pci_acpi_wake_bus(struct work_struct *work)

{

	struct pci_bus *pci_bus = context;

	struct acpi_device *adev;

	struct acpi_pci_root *root;



	if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus)

		pci_pme_wakeup_bus(pci_bus);

	adev = container_of(work, struct acpi_device, wakeup.context.work);

	root = acpi_driver_data(adev);

	pci_pme_wakeup_bus(root->bus);

}



/**

 * pci_acpi_wake_dev - Wake-up notification handler for PCI devices.

 * pci_acpi_wake_dev - PCI device wakeup notification work function.

 * @handle: ACPI handle of a device the notification is for.

 * @event: Type of the signaled event.

 * @context: PCI device object to wake up.

 * @work: Work item to handle.

 */

static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)

static void pci_acpi_wake_dev(struct work_struct *work)

{

	struct pci_dev *pci_dev = context;

	struct acpi_device_wakeup_context *context;

	struct pci_dev *pci_dev;



	if (event != ACPI_NOTIFY_DEVICE_WAKE || !pci_dev)

		return;

	context = container_of(work, struct acpi_device_wakeup_context, work);

	pci_dev = to_pci_dev(context->dev);



	if (pci_dev->pme_poll)

		pci_dev->pme_poll = false;
@@ -65,23 +65,12 @@ static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context) 
}



/**

 * pci_acpi_add_bus_pm_notifier - Register PM notifier for given PCI bus.

 * @dev: ACPI device to add the notifier for.

 * @pci_bus: PCI bus to walk checking for PME status if an event is signaled.

 * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus.

 * @dev: PCI root bridge ACPI device.

 */

acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev,

					 struct pci_bus *pci_bus)

acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev)

{

	return acpi_add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus);

}



/**

 * pci_acpi_remove_bus_pm_notifier - Unregister PCI bus PM notifier.

 * @dev: ACPI device to remove the notifier from.

 */

acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev)

{

	return acpi_remove_pm_notifier(dev, pci_acpi_wake_bus);

	return acpi_add_pm_notifier(dev, NULL, pci_acpi_wake_bus);

}



/**
@@ -92,16 +81,7 @@ acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev) 
acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,

				     struct pci_dev *pci_dev)

{

	return acpi_add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev);

}



/**

 * pci_acpi_remove_pm_notifier - Unregister PCI device PM notifier.

 * @dev: ACPI device to remove the notifier from.

 */

acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev)

{

	return acpi_remove_pm_notifier(dev, pci_acpi_wake_dev);

	return acpi_add_pm_notifier(dev, &pci_dev->dev, pci_acpi_wake_dev);

}



phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle)