[PATCH v3 00/13] acpi: i2c: Use SharedAndWake and ExclusiveAndWake to enable wake irq

[PATCH v3 00/13] acpi: i2c: Use SharedAndWake and ExclusiveAndWake to enable wake irq

[Raul E Rangel]

Today, i2c drivers are making the assumption that their IRQs can also
be used as wake IRQs. This isn't always the case and it can lead to
spurious wakes. This has recently started to affect AMD Chromebooks.
With the introduction of
d62bd5ce12d7 ("pinctrl: amd: Implement irq_set_wake"), the AMD GPIO
controller gained the capability to set the wake bit on each GPIO. The
ACPI specification defines two ways to inform the system if a device is
wake capable:
1) The _PRW object defines the GPE that can be used to wake the system.
2) Setting ExclusiveAndWake or SharedAndWake in the _CRS GpioInt.

Currently only the first method is supported. The i2c drivers don't have
any indication that the IRQ is wake capable, so they guess. This causes
spurious interrupts, for example:
* We have an ACPI HID device that has `_PR0` and `_PR3`. It doesn't have
  `_PRW` or `ExclusiveAndWake` so that means the device can't wake the
  system.
* The IRQ line is active level low for this device and is pulled up by
  the power resource defined in `_PR0`/`_PR3`.
* The i2c driver will (incorrectly) arm the GPIO for wake by calling
  `enable_irq_wake` as part of its suspend hook.
* ACPI will power down the device since it doesn't have a wake GPE
  associated with it.
* When the device is powered down, the IRQ line will drop, and it will
  trigger a wake event.

See the following debug log:
[   42.335804] PM: Suspending system (s2idle)
[   42.340186] amd_gpio AMD0030:00: RX: Setting wake for pin 89 to enable
[   42.467736]     power-0416 __acpi_power_off      : Power resource [PR00] turned off
[   42.467739] device_pm-0280 device_set_power      : Device [H05D] transitioned to D3cold
[   42.475210] PM: pm_system_irq_wakeup: 11 triggered pinctrl_amd
[   42.535293] PM: Wakeup unrelated to ACPI SCI
[   42.535294] PM: resume from suspend-to-idle

In order to fix this, we need to take into account the wake capable bit
defined on the Interrupt/GpioInt. This is accomplished by:
* Migrating some of the i2c drivers over to using the PM subsystem to
  manage the wake IRQ.
* Expose the wake_capable bit from the ACPI Interrupt/GpioInt resource
  to the  i2c core.
* Use the wake_capable bit in the i2c core to call
  `dev_pm_set_wake_irq`. This reuses the existing device tree flow.
* Make the i2c drivers stop calling `dev_pm_set_wake_irq` since it's now
  handled by the i2c core.
* Make the ACPI device PM system aware of the wake_irq. This is
  necessary so the device doesn't incorrectly get powered down when a
  wake_irq is enabled.

I've tested this code with various combinations of having _PRW,
ExclusiveAndWake and power resources all defined or not defined, but it
would be great if others could test this out on their hardware.

I'm sure this will surface some devices where the IRQs were not
correctly marked as wake capable. Ideally the firmware can be fixed, but
if not we can work around this in the kernel by providing a board
specific `struct i2c_board_info` with the `I2C_CLIENT_WAKE` flag set.
See `chromeos_laptop.c` for an example of matching DMI properties and
setting the `I2C_CLIENT_WAKE` override.

Thanks,
Raul

Changes in v3:
- Kept `acpi_dev_gpio_irq_get_by` unchanged to avoid having to touch
  unrelated drivers.
- Converted wake_capable parameter to bool.
- Fixed bad indent
- Convert wake_capable to bool
- Only update wake_capable pointer once
- Move wake_capable local into local block

Changes in v2:
- Added elants_i2c to series
- Added raydium_ts_i2c to series
- Fixed call site in mlxbf_gige_probe
- Added ability to extract wake bit from Interrupt/IRQ resources
- Look at wake_cabple bit for IRQ/Interrupt resources
- I chose not to keep the legacy code around since systems without DT or ACPI should be rare.

Raul E Rangel (13):
  HID: i2c-hid: Use PM subsystem to manage wake irq
  Input: elan_i2c - Use PM subsystem to manage wake irq
  Input: elants_i2c - Use PM subsystem to manage wake irq
  Input: raydium_ts_i2c - Use PM subsystem to manage wake irq
  gpiolib: acpi: Add wake_capable variants of acpi_dev_gpio_irq_get
  ACPI: resources: Add wake_capable parameter to acpi_dev_irq_flags
  i2c: acpi: Use ACPI wake capability bit to set wake_irq
  ACPI: PM: Take wake IRQ into consideration when entering
    suspend-to-idle
  HID: i2c-hid: acpi: Stop setting wakeup_capable
  HID: i2c-hid: Don't set wake_capable and wake_irq
  Input: elan_i2c - Don't set wake_capable and wake_irq
  Input: elants_i2c - Don't set wake_capable and wake_irq
  Input: raydium_ts_i2c - Don't set wake_capable and wake_irq

 drivers/acpi/device_pm.c                   | 19 +++++++++++--
 drivers/acpi/irq.c                         | 11 ++++++--
 drivers/acpi/resource.c                    | 24 +++++++++++-----
 drivers/gpio/gpiolib-acpi.c                | 17 +++++++++--
 drivers/gpio/gpiolib-acpi.h                |  2 ++
 drivers/hid/i2c-hid/i2c-hid-acpi.c         |  5 ----
 drivers/hid/i2c-hid/i2c-hid-core.c         | 24 ++--------------
 drivers/i2c/i2c-core-acpi.c                | 33 ++++++++++++++++------
 drivers/i2c/i2c-core-base.c                |  8 +++++-
 drivers/i2c/i2c-core.h                     |  4 +--
 drivers/input/mouse/elan_i2c_core.c        | 15 +---------
 drivers/input/touchscreen/elants_i2c.c     | 13 ++-------
 drivers/input/touchscreen/raydium_i2c_ts.c |  7 +----
 drivers/pnp/pnpacpi/rsparser.c             |  9 ++++--
 include/linux/acpi.h                       | 25 ++++++++++++----
 include/linux/ioport.h                     |  3 +-
 16 files changed, 126 insertions(+), 93 deletions(-)

-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 01/13] HID: i2c-hid: Use PM subsystem to manage wake irq

[Raul E Rangel]

The I2C hid driver is currently manually managing the wake
IRQ. This change removes the explicit enable_irq_wake/disable_irq_wake
and instead relies on the PM subsystem. This is done by calling
dev_pm_set_wake_irq.

i2c_device_probe already calls dev_pm_set_wake_irq when using device
tree, and i2c_device_remove also already calls dev_pm_clear_wake_irq.
There could be some device tree systems that have incorrectly declared
`wake` capabilities, so this change will set the wake irq if one is
missing. This matches the previous behavior.

I tested this on an ACPI system that has a HID touchscreen and verified
the IRQ was armed for wake on suspend.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

Changes in v3:
- Fixed typo in if condition

Changes in v2:
- Set the wake_irq when not configured by the i2c-core. This is
  different than v1, where the wake_irq was only set for non DT systems.

 drivers/hid/i2c-hid/i2c-hid-core.c | 33 +++++++++++-------------------
 1 file changed, 12 insertions(+), 21 deletions(-)

diff --git a/drivers/hid/i2c-hid/i2c-hid-core.c b/drivers/hid/i2c-hid/i2c-hid-core.c
index baa169fadd6632..a2fa40dec04ea5 100644
--- a/drivers/hid/i2c-hid/i2c-hid-core.c
+++ b/drivers/hid/i2c-hid/i2c-hid-core.c
@@ -26,6 +26,7 @@
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/pm.h>
+#include <linux/pm_wakeirq.h>
 #include <linux/device.h>
 #include <linux/wait.h>
 #include <linux/err.h>
@@ -116,7 +117,6 @@ struct i2c_hid {
 
 	wait_queue_head_t	wait;		/* For waiting the interrupt */
 
-	bool			irq_wake_enabled;
 	struct mutex		reset_lock;
 
 	struct i2chid_ops	*ops;
@@ -1036,6 +1036,15 @@ int i2c_hid_core_probe(struct i2c_client *client, struct i2chid_ops *ops,
 	if (ret < 0)
 		goto err_powered;
 
+	/*
+	 * The wake IRQ should be declared via device tree instead of assuming
+	 * the IRQ can wake the system. This is here for legacy reasons and
+	 * will be removed once the i2c-core supports querying ACPI for wake
+	 * capabilities.
+	 */
+	if (!client->dev.power.wakeirq)
+		dev_pm_set_wake_irq(&client->dev, client->irq);
+
 	hid = hid_allocate_device();
 	if (IS_ERR(hid)) {
 		ret = PTR_ERR(hid);
@@ -1119,7 +1128,6 @@ static int i2c_hid_core_suspend(struct device *dev)
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	struct hid_device *hid = ihid->hid;
 	int ret;
-	int wake_status;
 
 	ret = hid_driver_suspend(hid, PMSG_SUSPEND);
 	if (ret < 0)
@@ -1130,16 +1138,8 @@ static int i2c_hid_core_suspend(struct device *dev)
 
 	disable_irq(client->irq);
 
-	if (device_may_wakeup(&client->dev)) {
-		wake_status = enable_irq_wake(client->irq);
-		if (!wake_status)
-			ihid->irq_wake_enabled = true;
-		else
-			hid_warn(hid, "Failed to enable irq wake: %d\n",
-				wake_status);
-	} else {
+	if (!device_may_wakeup(&client->dev))
 		i2c_hid_core_power_down(ihid);
-	}
 
 	return 0;
 }
@@ -1150,18 +1150,9 @@ static int i2c_hid_core_resume(struct device *dev)
 	struct i2c_client *client = to_i2c_client(dev);
 	struct i2c_hid *ihid = i2c_get_clientdata(client);
 	struct hid_device *hid = ihid->hid;
-	int wake_status;
 
-	if (!device_may_wakeup(&client->dev)) {
+	if (!device_may_wakeup(&client->dev))
 		i2c_hid_core_power_up(ihid);
-	} else if (ihid->irq_wake_enabled) {
-		wake_status = disable_irq_wake(client->irq);
-		if (!wake_status)
-			ihid->irq_wake_enabled = false;
-		else
-			hid_warn(hid, "Failed to disable irq wake: %d\n",
-				wake_status);
-	}
 
 	enable_irq(client->irq);
 
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 02/13] Input: elan_i2c - Use PM subsystem to manage wake irq

[Raul E Rangel]

The Elan I2C touchpad driver is currently manually managing the wake
IRQ. This change removes the explicit enable_irq_wake/disable_irq_wake
and instead relies on the PM subsystem. This is done by calling
dev_pm_set_wake_irq.

i2c_device_probe already calls dev_pm_set_wake_irq when using device
tree, and i2c_device_remove also already calls dev_pm_clear_wake_irq.
There could be some device tree systems that have incorrectly declared
`wake` capabilities, so this change will set the wake irq if one is
missing. This matches the previous behavior.

I tested this on an ACPI system where the touchpad doesn't have _PRW
defined. I verified I can still wake the system and that the wake source
was the touchpad IRQ GPIO.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v2)

Changes in v2:
- Set the wake_irq when not configured by the i2c-core. This is
  different than v1, where the wake_irq was only set for non DT systems.

 drivers/input/mouse/elan_i2c_core.c | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c
index e1758d5ffe4218..3947474e93d16a 100644
--- a/drivers/input/mouse/elan_i2c_core.c
+++ b/drivers/input/mouse/elan_i2c_core.c
@@ -33,6 +33,7 @@
 #include <linux/jiffies.h>
 #include <linux/completion.h>
 #include <linux/of.h>
+#include <linux/pm_wakeirq.h>
 #include <linux/property.h>
 #include <linux/regulator/consumer.h>
 #include <asm/unaligned.h>
@@ -86,8 +87,6 @@ struct elan_tp_data {
 	u16			fw_page_size;
 	u32			fw_signature_address;
 
-	bool			irq_wake;
-
 	u8			min_baseline;
 	u8			max_baseline;
 	bool			baseline_ready;
@@ -1340,6 +1339,15 @@ static int elan_probe(struct i2c_client *client,
 	if (!dev->of_node)
 		device_init_wakeup(dev, true);
 
+	/*
+	 * The wake IRQ should be declared via device tree instead of assuming
+	 * the IRQ can wake the system. This is here for legacy reasons and
+	 * will be removed once the i2c-core supports querying ACPI for wake
+	 * capabilities.
+	 */
+	if (!dev->power.wakeirq)
+		dev_pm_set_wake_irq(dev, client->irq);
+
 	return 0;
 }
 
@@ -1362,8 +1370,6 @@ static int __maybe_unused elan_suspend(struct device *dev)
 
 	if (device_may_wakeup(dev)) {
 		ret = elan_sleep(data);
-		/* Enable wake from IRQ */
-		data->irq_wake = (enable_irq_wake(client->irq) == 0);
 	} else {
 		ret = elan_set_power(data, false);
 		if (ret)
@@ -1394,9 +1400,6 @@ static int __maybe_unused elan_resume(struct device *dev)
 			dev_err(dev, "error %d enabling regulator\n", error);
 			goto err;
 		}
-	} else if (data->irq_wake) {
-		disable_irq_wake(client->irq);
-		data->irq_wake = false;
 	}
 
 	error = elan_set_power(data, true);
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 03/13] Input: elants_i2c - Use PM subsystem to manage wake irq

[Raul E Rangel]

The Elan I2C touchscreen driver is currently manually managing the wake
IRQ. This change removes the explicit enable_irq_wake/disable_irq_wake
and instead relies on the PM subsystem. This is done by calling
dev_pm_set_wake_irq.

i2c_device_probe already calls dev_pm_set_wake_irq when using device
tree, and i2c_device_remove also already calls dev_pm_clear_wake_irq.
There could be some device tree systems that have incorrectly declared
`wake` capabilities, so this change will set the wake irq if one is
missing. This matches the previous behavior.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v2)

Changes in v2:
- Added elants_i2c to series

 drivers/input/touchscreen/elants_i2c.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/drivers/input/touchscreen/elants_i2c.c b/drivers/input/touchscreen/elants_i2c.c
index a56f042adf9d82..80e16b533c452a 100644
--- a/drivers/input/touchscreen/elants_i2c.c
+++ b/drivers/input/touchscreen/elants_i2c.c
@@ -36,6 +36,7 @@
 #include <linux/input/touchscreen.h>
 #include <linux/acpi.h>
 #include <linux/of.h>
+#include <linux/pm_wakeirq.h>
 #include <linux/gpio/consumer.h>
 #include <linux/regulator/consumer.h>
 #include <linux/uuid.h>
@@ -180,7 +181,6 @@ struct elants_data {
 	u8 cmd_resp[HEADER_SIZE];
 	struct completion cmd_done;
 
-	bool wake_irq_enabled;
 	bool keep_power_in_suspend;
 
 	/* Must be last to be used for DMA operations */
@@ -1582,6 +1582,15 @@ static int elants_i2c_probe(struct i2c_client *client)
 	if (!client->dev.of_node)
 		device_init_wakeup(&client->dev, true);
 
+	/*
+	 * The wake IRQ should be declared via device tree instead of assuming
+	 * the IRQ can wake the system. This is here for legacy reasons and
+	 * will be removed once the i2c-core supports querying ACPI for wake
+	 * capabilities.
+	 */
+	if (!client->dev.power.wakeirq)
+		dev_pm_set_wake_irq(&client->dev, client->irq);
+
 	error = devm_device_add_group(&client->dev, &elants_attribute_group);
 	if (error) {
 		dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
@@ -1626,7 +1635,7 @@ static int __maybe_unused elants_i2c_suspend(struct device *dev)
 		 * The device will automatically enter idle mode
 		 * that has reduced power consumption.
 		 */
-		ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
+		return 0;
 	} else if (ts->keep_power_in_suspend) {
 		for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
 			error = elants_i2c_send(client, set_sleep_cmd,
@@ -1655,8 +1664,6 @@ static int __maybe_unused elants_i2c_resume(struct device *dev)
 	int error;
 
 	if (device_may_wakeup(dev)) {
-		if (ts->wake_irq_enabled)
-			disable_irq_wake(client->irq);
 		elants_i2c_sw_reset(client);
 	} else if (ts->keep_power_in_suspend) {
 		for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 04/13] Input: raydium_ts_i2c - Use PM subsystem to manage wake irq

[Raul E Rangel]

The raydium I2C touchscreen driver is currently manually managing the
wake IRQ. This change removes the explicit enable_irq_wake /
disable_irq_wake and instead relies on the PM subsystem. This is done by
calling dev_pm_set_wake_irq.

i2c_device_probe already calls dev_pm_set_wake_irq when using device
tree, and i2c_device_remove also already calls dev_pm_clear_wake_irq.
There could be some device tree systems that have incorrectly declared
`wake` capabilities, so this change will set the wake irq if one is
missing. This matches the previous behavior.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v2)

Changes in v2:
- Added raydium_ts_i2c to series

 drivers/input/touchscreen/raydium_i2c_ts.c | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/drivers/input/touchscreen/raydium_i2c_ts.c b/drivers/input/touchscreen/raydium_i2c_ts.c
index 3a4952935366f9..66c5b577b791d4 100644
--- a/drivers/input/touchscreen/raydium_i2c_ts.c
+++ b/drivers/input/touchscreen/raydium_i2c_ts.c
@@ -21,6 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/pm_wakeirq.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <asm/unaligned.h>
@@ -134,8 +135,6 @@ struct raydium_data {
 	u8 pkg_size;
 
 	enum raydium_boot_mode boot_mode;
-
-	bool wake_irq_enabled;
 };
 
 /*
@@ -1186,6 +1185,15 @@ static int raydium_i2c_probe(struct i2c_client *client,
 		return error;
 	}
 
+	/*
+	 * The wake IRQ should be declared via device tree instead of assuming
+	 * the IRQ can wake the system. This is here for legacy reasons and
+	 * will be removed once the i2c-core supports querying ACPI for wake
+	 * capabilities.
+	 */
+	if (!client->dev.power.wakeirq)
+		dev_pm_set_wake_irq(&client->dev, client->irq);
+
 	error = devm_device_add_group(&client->dev,
 				   &raydium_i2c_attribute_group);
 	if (error) {
@@ -1222,8 +1230,6 @@ static int __maybe_unused raydium_i2c_suspend(struct device *dev)
 
 	if (device_may_wakeup(dev)) {
 		raydium_enter_sleep(client);
-
-		ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
 	} else {
 		raydium_i2c_power_off(ts);
 	}
@@ -1237,8 +1243,6 @@ static int __maybe_unused raydium_i2c_resume(struct device *dev)
 	struct raydium_data *ts = i2c_get_clientdata(client);
 
 	if (device_may_wakeup(dev)) {
-		if (ts->wake_irq_enabled)
-			disable_irq_wake(client->irq);
 		raydium_i2c_sw_reset(client);
 	} else {
 		raydium_i2c_power_on(ts);
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 05/13] gpiolib: acpi: Add wake_capable variants of acpi_dev_gpio_irq_get

[Raul E Rangel]

The ACPI spec defines the SharedAndWake and ExclusiveAndWake share type
keywords. This is an indication that the GPIO IRQ can also be used as a
wake source. This change exposes the wake_capable bit so drivers can
correctly enable wake functionality instead of making an assumption.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

Changes in v3:
- Kept `acpi_dev_gpio_irq_get_by` unchanged to avoid having to touch
  unrelated drivers.
- Converted wake_capable parameter to bool.

Changes in v2:
- Fixed call site in mlxbf_gige_probe

 drivers/gpio/gpiolib-acpi.c | 17 ++++++++++++++---
 drivers/gpio/gpiolib-acpi.h |  2 ++
 include/linux/acpi.h        | 22 ++++++++++++++++++----
 3 files changed, 34 insertions(+), 7 deletions(-)

diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
index 9be1376f9a627f..c703f095993a2c 100644
--- a/drivers/gpio/gpiolib-acpi.c
+++ b/drivers/gpio/gpiolib-acpi.c
@@ -741,6 +741,8 @@ static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data)
 		lookup->info.pin_config = agpio->pin_config;
 		lookup->info.debounce = agpio->debounce_timeout;
 		lookup->info.gpioint = gpioint;
+		lookup->info.wake_capable = agpio->wake_capable ==
+					    ACPI_WAKE_CAPABLE;
 
 		/*
 		 * Polarity and triggering are only specified for GpioInt
@@ -987,10 +989,12 @@ struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
 }
 
 /**
- * acpi_dev_gpio_irq_get_by() - Find GpioInt and translate it to Linux IRQ number
+ * acpi_dev_gpio_irq_wake_get_by() - Find GpioInt and translate it to Linux IRQ
+ *                                   number
  * @adev: pointer to a ACPI device to get IRQ from
  * @name: optional name of GpioInt resource
  * @index: index of GpioInt resource (starting from %0)
+ * @wake_capable: Set to true if the IRQ is wake capable
  *
  * If the device has one or more GpioInt resources, this function can be
  * used to translate from the GPIO offset in the resource to the Linux IRQ
@@ -1002,9 +1006,13 @@ struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
  * The function takes optional @name parameter. If the resource has a property
  * name, then only those will be taken into account.
  *
+ * The GPIO is considered wake capable if the GpioInt resource specifies
+ * SharedAndWake or ExclusiveAndWake.
+ *
  * Return: Linux IRQ number (> %0) on success, negative errno on failure.
  */
-int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index)
+int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *name,
+				  int index, bool *wake_capable)
 {
 	int idx, i;
 	unsigned int irq_flags;
@@ -1061,13 +1069,16 @@ int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int ind
 				dev_dbg(&adev->dev, "IRQ %d already in use\n", irq);
 			}
 
+			if (wake_capable)
+				*wake_capable = info.wake_capable;
+
 			return irq;
 		}
 
 	}
 	return -ENOENT;
 }
-EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get_by);
+EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_wake_get_by);
 
 static acpi_status
 acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
diff --git a/drivers/gpio/gpiolib-acpi.h b/drivers/gpio/gpiolib-acpi.h
index e476558d947136..1ac6816839dbce 100644
--- a/drivers/gpio/gpiolib-acpi.h
+++ b/drivers/gpio/gpiolib-acpi.h
@@ -18,6 +18,7 @@ struct acpi_device;
  * @pin_config: pin bias as provided by ACPI
  * @polarity: interrupt polarity as provided by ACPI
  * @triggering: triggering type as provided by ACPI
+ * @wake_capable: wake capability as provided by ACPI
  * @debounce: debounce timeout as provided by ACPI
  * @quirks: Linux specific quirks as provided by struct acpi_gpio_mapping
  */
@@ -28,6 +29,7 @@ struct acpi_gpio_info {
 	int pin_config;
 	int polarity;
 	int triggering;
+	bool wake_capable;
 	unsigned int debounce;
 	unsigned int quirks;
 };
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 6f64b2f3dc5479..d3121cef6cc3bc 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -1202,7 +1202,8 @@ bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
 				struct acpi_resource_gpio **agpio);
 bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
 			       struct acpi_resource_gpio **agpio);
-int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index);
+int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *name,
+				  int index, bool *wake_capable);
 #else
 static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
 					      struct acpi_resource_gpio **agpio)
@@ -1214,16 +1215,29 @@ static inline bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
 {
 	return false;
 }
-static inline int acpi_dev_gpio_irq_get_by(struct acpi_device *adev,
-					   const char *name, int index)
+static inline int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev,
+						const char *name, int index,
+						bool *wake_capable)
 {
 	return -ENXIO;
 }
 #endif
 
+static inline int acpi_dev_gpio_irq_get_by(struct acpi_device *adev,
+					   const char *name, int index)
+{
+	return acpi_dev_gpio_irq_wake_get_by(adev, name, index, NULL);
+}
+
 static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
 {
-	return acpi_dev_gpio_irq_get_by(adev, NULL, index);
+	return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, NULL);
+}
+
+static inline int acpi_dev_gpio_irq_wake_get(struct acpi_device *adev,
+					     int index, bool *wake_capable)
+{
+	return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, wake_capable);
 }
 
 /* Device properties */
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 06/13] ACPI: resources: Add wake_capable parameter to acpi_dev_irq_flags

[Raul E Rangel]

ACPI IRQ/Interrupt resources contain a bit that describes if the
interrupt should wake the system. This change exposes that bit via
a new IORESOURCE_IRQ_WAKECAPABLE flag. Drivers should check this flag
before arming an IRQ to wake the system.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

Changes in v3:
- Fixed bad indent

Changes in v2:
- Added ability to extract wake bit from Interrupt/IRQ resources

 drivers/acpi/irq.c             | 11 ++++++++---
 drivers/acpi/resource.c        | 24 +++++++++++++++++-------
 drivers/pnp/pnpacpi/rsparser.c |  9 ++++++---
 include/linux/acpi.h           |  3 ++-
 include/linux/ioport.h         |  3 ++-
 5 files changed, 35 insertions(+), 15 deletions(-)

diff --git a/drivers/acpi/irq.c b/drivers/acpi/irq.c
index dabe45eba055d1..5483cf9a28e3a0 100644
--- a/drivers/acpi/irq.c
+++ b/drivers/acpi/irq.c
@@ -147,6 +147,7 @@ struct acpi_irq_parse_one_ctx {
  * @polarity: polarity attributes of hwirq
  * @polarity: polarity attributes of hwirq
  * @shareable: shareable attributes of hwirq
+ * @wake_capable: wake capable attribute of hwirq
  * @ctx: acpi_irq_parse_one_ctx updated by this function
  *
  * Description:
@@ -156,12 +157,14 @@ struct acpi_irq_parse_one_ctx {
 static inline void acpi_irq_parse_one_match(struct fwnode_handle *fwnode,
 					    u32 hwirq, u8 triggering,
 					    u8 polarity, u8 shareable,
+					    u8 wake_capable,
 					    struct acpi_irq_parse_one_ctx *ctx)
 {
 	if (!fwnode)
 		return;
 	ctx->rc = 0;
-	*ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable);
+	*ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable,
+					     wake_capable);
 	ctx->fwspec->fwnode = fwnode;
 	ctx->fwspec->param[0] = hwirq;
 	ctx->fwspec->param[1] = acpi_dev_get_irq_type(triggering, polarity);
@@ -204,7 +207,8 @@ static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,
 		fwnode = acpi_get_gsi_domain_id(irq->interrupts[ctx->index]);
 		acpi_irq_parse_one_match(fwnode, irq->interrupts[ctx->index],
 					 irq->triggering, irq->polarity,
-					 irq->shareable, ctx);
+					 irq->shareable, irq->wake_capable,
+					 ctx);
 		return AE_CTRL_TERMINATE;
 	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 		eirq = &ares->data.extended_irq;
@@ -218,7 +222,8 @@ static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,
 						      eirq->interrupts[ctx->index]);
 		acpi_irq_parse_one_match(fwnode, eirq->interrupts[ctx->index],
 					 eirq->triggering, eirq->polarity,
-					 eirq->shareable, ctx);
+					 eirq->shareable, eirq->wake_capable,
+					 ctx);
 		return AE_CTRL_TERMINATE;
 	}
 
diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
index 510cdec375c4d8..6a1c008a348902 100644
--- a/drivers/acpi/resource.c
+++ b/drivers/acpi/resource.c
@@ -336,8 +336,10 @@ EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space);
  * @triggering: Triggering type as provided by ACPI.
  * @polarity: Interrupt polarity as provided by ACPI.
  * @shareable: Whether or not the interrupt is shareable.
+ * @wake_capable: Wake capability as provided by ACPI.
  */
-unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable,
+				 u8 wake_capable)
 {
 	unsigned long flags;
 
@@ -351,6 +353,9 @@ unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
 	if (shareable == ACPI_SHARED)
 		flags |= IORESOURCE_IRQ_SHAREABLE;
 
+	if (wake_capable == ACPI_WAKE_CAPABLE)
+		flags |= IORESOURCE_IRQ_WAKECAPABLE;
+
 	return flags | IORESOURCE_IRQ;
 }
 EXPORT_SYMBOL_GPL(acpi_dev_irq_flags);
@@ -442,7 +447,7 @@ static bool acpi_dev_irq_override(u32 gsi, u8 triggering, u8 polarity,
 
 static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
 				     u8 triggering, u8 polarity, u8 shareable,
-				     bool check_override)
+				     u8 wake_capable, bool check_override)
 {
 	int irq, p, t;
 
@@ -475,7 +480,8 @@ static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
 		}
 	}
 
-	res->flags = acpi_dev_irq_flags(triggering, polarity, shareable);
+	res->flags = acpi_dev_irq_flags(triggering, polarity, shareable,
+					wake_capable);
 	irq = acpi_register_gsi(NULL, gsi, triggering, polarity);
 	if (irq >= 0) {
 		res->start = irq;
@@ -523,7 +529,8 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
 		}
 		acpi_dev_get_irqresource(res, irq->interrupts[index],
 					 irq->triggering, irq->polarity,
-					 irq->shareable, true);
+					 irq->shareable, irq->wake_capable,
+					 true);
 		break;
 	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 		ext_irq = &ares->data.extended_irq;
@@ -532,9 +539,12 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
 			return false;
 		}
 		if (is_gsi(ext_irq))
-			acpi_dev_get_irqresource(res, ext_irq->interrupts[index],
-					 ext_irq->triggering, ext_irq->polarity,
-					 ext_irq->shareable, false);
+			acpi_dev_get_irqresource(res,
+						 ext_irq->interrupts[index],
+						 ext_irq->triggering,
+						 ext_irq->polarity,
+						 ext_irq->shareable,
+						 ext_irq->wake_capable, false);
 		else
 			irqresource_disabled(res, 0);
 		break;
diff --git a/drivers/pnp/pnpacpi/rsparser.c b/drivers/pnp/pnpacpi/rsparser.c
index da78dc77aed32e..55b28fc0a94042 100644
--- a/drivers/pnp/pnpacpi/rsparser.c
+++ b/drivers/pnp/pnpacpi/rsparser.c
@@ -206,7 +206,8 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
 		if (i >= 0) {
 			flags = acpi_dev_irq_flags(gpio->triggering,
 						   gpio->polarity,
-						   gpio->shareable);
+						   gpio->shareable,
+						   gpio->wake_capable);
 		} else {
 			flags = IORESOURCE_DISABLED;
 		}
@@ -315,7 +316,8 @@ static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
 		if (p->interrupts[i])
 			__set_bit(p->interrupts[i], map.bits);
 
-	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
+	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable,
+				   p->wake_capable);
 	pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
@@ -339,7 +341,8 @@ static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
 		}
 	}
 
-	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
+	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable,
+				   p->wake_capable);
 	pnp_register_irq_resource(dev, option_flags, &map, flags);
 }
 
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index d3121cef6cc3bc..9f7947ee1b006f 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -495,7 +495,8 @@ bool acpi_dev_resource_address_space(struct acpi_resource *ares,
 				     struct resource_win *win);
 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
 					 struct resource_win *win);
-unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable,
+				 u8 wake_capable);
 unsigned int acpi_dev_get_irq_type(int triggering, int polarity);
 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
 				 struct resource *res);
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 616b683563a970..3baeea4d903bfd 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -79,7 +79,8 @@ struct resource {
 #define IORESOURCE_IRQ_HIGHLEVEL	(1<<2)
 #define IORESOURCE_IRQ_LOWLEVEL		(1<<3)
 #define IORESOURCE_IRQ_SHAREABLE	(1<<4)
-#define IORESOURCE_IRQ_OPTIONAL 	(1<<5)
+#define IORESOURCE_IRQ_OPTIONAL		(1<<5)
+#define IORESOURCE_IRQ_WAKECAPABLE	(1<<6)
 
 /* PnP DMA specific bits (IORESOURCE_BITS) */
 #define IORESOURCE_DMA_TYPE_MASK	(3<<0)
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 07/13] i2c: acpi: Use ACPI wake capability bit to set wake_irq

[Raul E Rangel]

Device tree already has a mechanism to pass the wake_irq. It does this
by looking for the wakeup-source property and setting the
I2C_CLIENT_WAKE flag. This CL adds the ACPI equivalent. It uses the
ACPI interrupt wake flag to determine if the interrupt can be used to
wake the system. Previously the i2c drivers had to make assumptions and
blindly enable the wake IRQ. This can cause spurious wake events. e.g.,
If there is a device with an Active Low interrupt and the device gets
powered off while suspending, the interrupt line will go low since it's
no longer powered and wakes the system. For this reason we should
respect the board designers wishes and honor the wake bit defined on the
interrupt.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

Changes in v3:
- Convert wake_capable to bool
- Only update wake_capable pointer once
- Move wake_capable local into local block

Changes in v2:
- Look at wake_cabple bit for IRQ/Interrupt resources

 drivers/i2c/i2c-core-acpi.c | 33 ++++++++++++++++++++++++---------
 drivers/i2c/i2c-core-base.c |  8 +++++++-
 drivers/i2c/i2c-core.h      |  4 ++--
 3 files changed, 33 insertions(+), 12 deletions(-)

diff --git a/drivers/i2c/i2c-core-acpi.c b/drivers/i2c/i2c-core-acpi.c
index c762a879c4cc6b..b3d68a9659ff4f 100644
--- a/drivers/i2c/i2c-core-acpi.c
+++ b/drivers/i2c/i2c-core-acpi.c
@@ -137,6 +137,11 @@ static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = {
 	{}
 };
 
+struct i2c_acpi_irq_context {
+	int irq;
+	bool wake_capable;
+};
+
 static int i2c_acpi_do_lookup(struct acpi_device *adev,
 			      struct i2c_acpi_lookup *lookup)
 {
@@ -170,11 +175,14 @@ static int i2c_acpi_do_lookup(struct acpi_device *adev,
 
 static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
 {
-	int *irq = data;
+	struct i2c_acpi_irq_context *irq_ctx = data;
 	struct resource r;
 
-	if (*irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r))
-		*irq = i2c_dev_irq_from_resources(&r, 1);
+	if (irq_ctx->irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r)) {
+		irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
+		irq_ctx->wake_capable =
+			!!(r.flags & IORESOURCE_IRQ_WAKECAPABLE);
+	}
 
 	return 1; /* No need to add resource to the list */
 }
@@ -182,31 +190,38 @@ static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
 /**
  * i2c_acpi_get_irq - get device IRQ number from ACPI
  * @client: Pointer to the I2C client device
+ * @wake_capable: Set to true if the IRQ is wake capable
  *
  * Find the IRQ number used by a specific client device.
  *
  * Return: The IRQ number or an error code.
  */
-int i2c_acpi_get_irq(struct i2c_client *client)
+int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
 {
 	struct acpi_device *adev = ACPI_COMPANION(&client->dev);
 	struct list_head resource_list;
-	int irq = -ENOENT;
+	struct i2c_acpi_irq_context irq_ctx = {
+		.irq = -ENOENT,
+	};
 	int ret;
 
 	INIT_LIST_HEAD(&resource_list);
 
 	ret = acpi_dev_get_resources(adev, &resource_list,
-				     i2c_acpi_add_resource, &irq);
+				     i2c_acpi_add_resource, &irq_ctx);
 	if (ret < 0)
 		return ret;
 
 	acpi_dev_free_resource_list(&resource_list);
 
-	if (irq == -ENOENT)
-		irq = acpi_dev_gpio_irq_get(adev, 0);
+	if (irq_ctx.irq == -ENOENT)
+		irq_ctx.irq = acpi_dev_gpio_irq_wake_get(adev, 0,
+							 &irq_ctx.wake_capable);
+
+	if (wake_capable)
+		*wake_capable = irq_ctx.wake_capable;
 
-	return irq;
+	return irq_ctx.irq;
 }
 
 static int i2c_acpi_get_info(struct acpi_device *adev,
diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c
index 91007558bcb260..c4debd46c6340f 100644
--- a/drivers/i2c/i2c-core-base.c
+++ b/drivers/i2c/i2c-core-base.c
@@ -487,8 +487,14 @@ static int i2c_device_probe(struct device *dev)
 			if (irq == -EINVAL || irq == -ENODATA)
 				irq = of_irq_get(dev->of_node, 0);
 		} else if (ACPI_COMPANION(dev)) {
-			irq = i2c_acpi_get_irq(client);
+			bool wake_capable;
+
+			irq = i2c_acpi_get_irq(client, &wake_capable);
+
+			if (irq > 0 && wake_capable)
+				client->flags |= I2C_CLIENT_WAKE;
 		}
+
 		if (irq == -EPROBE_DEFER) {
 			status = irq;
 			goto put_sync_adapter;
diff --git a/drivers/i2c/i2c-core.h b/drivers/i2c/i2c-core.h
index 87e2c914f1c57b..1247e6e6e97517 100644
--- a/drivers/i2c/i2c-core.h
+++ b/drivers/i2c/i2c-core.h
@@ -61,11 +61,11 @@ static inline int __i2c_check_suspended(struct i2c_adapter *adap)
 #ifdef CONFIG_ACPI
 void i2c_acpi_register_devices(struct i2c_adapter *adap);
 
-int i2c_acpi_get_irq(struct i2c_client *client);
+int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable);
 #else /* CONFIG_ACPI */
 static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
 
-static inline int i2c_acpi_get_irq(struct i2c_client *client)
+static inline int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
 {
 	return 0;
 }
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 08/13] ACPI: PM: Take wake IRQ into consideration when entering suspend-to-idle

[Raul E Rangel]

This change adds support for ACPI devices that use ExclusiveAndWake or
SharedAndWake in their _CRS GpioInt definition (instead of using _PRW),
and also provide power resources. Previously the ACPI subsystem had no
idea if the device had a wake capable interrupt armed. This resulted
in the ACPI device PM system placing the device into D3Cold, and thus
cutting power to the device. With this change we will now query the
_S0W method to figure out the appropriate wake capable D-state.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v1)

 drivers/acpi/device_pm.c | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c
index 9dce1245689ca2..6bc81f525d5160 100644
--- a/drivers/acpi/device_pm.c
+++ b/drivers/acpi/device_pm.c
@@ -681,8 +681,23 @@ static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
 		d_min = ret;
 		wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
 			&& adev->wakeup.sleep_state >= target_state;
-	} else {
-		wakeup = adev->wakeup.flags.valid;
+	} else if (acpi_device_can_wakeup(adev)) {
+		/* ACPI GPE from specified by _PRW. */
+		wakeup = true;
+	} else if (device_may_wakeup(dev) && dev->power.wakeirq) {
+		/*
+		 * The ACPI subsystem doesn't manage the wake bit for IRQs
+		 * defined with ExclusiveAndWake and SharedAndWake. Instead we
+		 * expect them to be managed via the PM subsystem. Drivers
+		 * should call dev_pm_set_wake_irq to register an IRQ as a wake
+		 * source.
+		 *
+		 * If a device has a wake IRQ attached we need to check the
+		 * _S0W method to get the correct wake D-state. Otherwise we
+		 * end up putting the device into D3Cold which will more than
+		 * likely disable wake functionality.
+		 */
+		wakeup = true;
 	}
 
 	/*
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 09/13] HID: i2c-hid: acpi: Stop setting wakeup_capable

[Raul E Rangel]

This is now handled by the i2c-core driver.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v1)

 drivers/hid/i2c-hid/i2c-hid-acpi.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/drivers/hid/i2c-hid/i2c-hid-acpi.c b/drivers/hid/i2c-hid/i2c-hid-acpi.c
index b96ae15e0ad917..375c77c3db74d9 100644
--- a/drivers/hid/i2c-hid/i2c-hid-acpi.c
+++ b/drivers/hid/i2c-hid/i2c-hid-acpi.c
@@ -105,11 +105,6 @@ static int i2c_hid_acpi_probe(struct i2c_client *client)
 
 	acpi_device_fix_up_power(adev);
 
-	if (acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0) {
-		device_set_wakeup_capable(dev, true);
-		device_set_wakeup_enable(dev, false);
-	}
-
 	return i2c_hid_core_probe(client, &ihid_acpi->ops,
 				  hid_descriptor_address, 0);
 }
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 10/13] HID: i2c-hid: Don't set wake_capable and wake_irq

[Raul E Rangel]

The i2c-core will now handle setting the wake_irq for DT and ACPI
systems.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v1)

 drivers/hid/i2c-hid/i2c-hid-core.c | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/drivers/hid/i2c-hid/i2c-hid-core.c b/drivers/hid/i2c-hid/i2c-hid-core.c
index a2fa40dec04ea5..65b7a95956866d 100644
--- a/drivers/hid/i2c-hid/i2c-hid-core.c
+++ b/drivers/hid/i2c-hid/i2c-hid-core.c
@@ -1036,15 +1036,6 @@ int i2c_hid_core_probe(struct i2c_client *client, struct i2chid_ops *ops,
 	if (ret < 0)
 		goto err_powered;
 
-	/*
-	 * The wake IRQ should be declared via device tree instead of assuming
-	 * the IRQ can wake the system. This is here for legacy reasons and
-	 * will be removed once the i2c-core supports querying ACPI for wake
-	 * capabilities.
-	 */
-	if (!client->dev.power.wakeirq)
-		dev_pm_set_wake_irq(&client->dev, client->irq);
-
 	hid = hid_allocate_device();
 	if (IS_ERR(hid)) {
 		ret = PTR_ERR(hid);
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 11/13] Input: elan_i2c - Don't set wake_capable and wake_irq

[Raul E Rangel]

The i2c-core will now handle setting the wake_irq and wake capability
for DT and ACPI systems.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v2)

Changes in v2:
- I chose not to keep the legacy code around since systems without DT or ACPI should be rare.

 drivers/input/mouse/elan_i2c_core.c | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c
index 3947474e93d16a..b25b94aba3e88e 100644
--- a/drivers/input/mouse/elan_i2c_core.c
+++ b/drivers/input/mouse/elan_i2c_core.c
@@ -1332,22 +1332,6 @@ static int elan_probe(struct i2c_client *client,
 		}
 	}
 
-	/*
-	 * Systems using device tree should set up wakeup via DTS,
-	 * the rest will configure device as wakeup source by default.
-	 */
-	if (!dev->of_node)
-		device_init_wakeup(dev, true);
-
-	/*
-	 * The wake IRQ should be declared via device tree instead of assuming
-	 * the IRQ can wake the system. This is here for legacy reasons and
-	 * will be removed once the i2c-core supports querying ACPI for wake
-	 * capabilities.
-	 */
-	if (!dev->power.wakeirq)
-		dev_pm_set_wake_irq(dev, client->irq);
-
 	return 0;
 }
 
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 12/13] Input: elants_i2c - Don't set wake_capable and wake_irq

[Raul E Rangel]

The i2c-core will now handle setting the wake_irq and wake capability
for DT and ACPI systems.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v1)

 drivers/input/touchscreen/elants_i2c.c | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/drivers/input/touchscreen/elants_i2c.c b/drivers/input/touchscreen/elants_i2c.c
index 80e16b533c452a..3500293bb1d8e1 100644
--- a/drivers/input/touchscreen/elants_i2c.c
+++ b/drivers/input/touchscreen/elants_i2c.c
@@ -1575,22 +1575,6 @@ static int elants_i2c_probe(struct i2c_client *client)
 		return error;
 	}
 
-	/*
-	 * Systems using device tree should set up wakeup via DTS,
-	 * the rest will configure device as wakeup source by default.
-	 */
-	if (!client->dev.of_node)
-		device_init_wakeup(&client->dev, true);
-
-	/*
-	 * The wake IRQ should be declared via device tree instead of assuming
-	 * the IRQ can wake the system. This is here for legacy reasons and
-	 * will be removed once the i2c-core supports querying ACPI for wake
-	 * capabilities.
-	 */
-	if (!client->dev.power.wakeirq)
-		dev_pm_set_wake_irq(&client->dev, client->irq);
-
 	error = devm_device_add_group(&client->dev, &elants_attribute_group);
 	if (error) {
 		dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
-- 
2.37.3.968.ga6b4b080e4-goog

[PATCH v3 13/13] Input: raydium_ts_i2c - Don't set wake_capable and wake_irq

[Raul E Rangel]

The i2c-core will now handle setting the wake_irq and wake capability
for DT and ACPI systems.

Signed-off-by: Raul E Rangel <rrangel@chromium.org>
---

(no changes since v1)

 drivers/input/touchscreen/raydium_i2c_ts.c | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/drivers/input/touchscreen/raydium_i2c_ts.c b/drivers/input/touchscreen/raydium_i2c_ts.c
index 66c5b577b791d4..88d187dc5d325f 100644
--- a/drivers/input/touchscreen/raydium_i2c_ts.c
+++ b/drivers/input/touchscreen/raydium_i2c_ts.c
@@ -1185,15 +1185,6 @@ static int raydium_i2c_probe(struct i2c_client *client,
 		return error;
 	}
 
-	/*
-	 * The wake IRQ should be declared via device tree instead of assuming
-	 * the IRQ can wake the system. This is here for legacy reasons and
-	 * will be removed once the i2c-core supports querying ACPI for wake
-	 * capabilities.
-	 */
-	if (!client->dev.power.wakeirq)
-		dev_pm_set_wake_irq(&client->dev, client->irq);
-
 	error = devm_device_add_group(&client->dev,
 				   &raydium_i2c_attribute_group);
 	if (error) {
-- 
2.37.3.968.ga6b4b080e4-goog

Re: [PATCH v3 05/13] gpiolib: acpi: Add wake_capable variants of acpi_dev_gpio_irq_get

[Mika Westerberg]

On Wed, Sep 14, 2022 at 05:57:53PM -0600, Raul E Rangel wrote:
> The ACPI spec defines the SharedAndWake and ExclusiveAndWake share type
> keywords. This is an indication that the GPIO IRQ can also be used as a
> wake source. This change exposes the wake_capable bit so drivers can
> correctly enable wake functionality instead of making an assumption.
> 
> Signed-off-by: Raul E Rangel <rrangel@chromium.org>

Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>

Re: [PATCH v3 07/13] i2c: acpi: Use ACPI wake capability bit to set wake_irq

[Mika Westerberg]

On Wed, Sep 14, 2022 at 05:57:55PM -0600, Raul E Rangel wrote:
> Device tree already has a mechanism to pass the wake_irq. It does this
> by looking for the wakeup-source property and setting the
> I2C_CLIENT_WAKE flag. This CL adds the ACPI equivalent. It uses the
> ACPI interrupt wake flag to determine if the interrupt can be used to
> wake the system. Previously the i2c drivers had to make assumptions and
> blindly enable the wake IRQ. This can cause spurious wake events. e.g.,
> If there is a device with an Active Low interrupt and the device gets
> powered off while suspending, the interrupt line will go low since it's
> no longer powered and wakes the system. For this reason we should
> respect the board designers wishes and honor the wake bit defined on the
> interrupt.
> 
> Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> ---
> 
> Changes in v3:
> - Convert wake_capable to bool
> - Only update wake_capable pointer once
> - Move wake_capable local into local block
> 
> Changes in v2:
> - Look at wake_cabple bit for IRQ/Interrupt resources
> 
>  drivers/i2c/i2c-core-acpi.c | 33 ++++++++++++++++++++++++---------
>  drivers/i2c/i2c-core-base.c |  8 +++++++-
>  drivers/i2c/i2c-core.h      |  4 ++--
>  3 files changed, 33 insertions(+), 12 deletions(-)
> 
> diff --git a/drivers/i2c/i2c-core-acpi.c b/drivers/i2c/i2c-core-acpi.c
> index c762a879c4cc6b..b3d68a9659ff4f 100644
> --- a/drivers/i2c/i2c-core-acpi.c
> +++ b/drivers/i2c/i2c-core-acpi.c
> @@ -137,6 +137,11 @@ static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = {
>  	{}
>  };
>  
> +struct i2c_acpi_irq_context {
> +	int irq;
> +	bool wake_capable;
> +};
> +
>  static int i2c_acpi_do_lookup(struct acpi_device *adev,
>  			      struct i2c_acpi_lookup *lookup)
>  {
> @@ -170,11 +175,14 @@ static int i2c_acpi_do_lookup(struct acpi_device *adev,
>  
>  static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
>  {
> -	int *irq = data;
> +	struct i2c_acpi_irq_context *irq_ctx = data;
>  	struct resource r;
>  
> -	if (*irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r))
> -		*irq = i2c_dev_irq_from_resources(&r, 1);
> +	if (irq_ctx->irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r)) {
> +		irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
> +		irq_ctx->wake_capable =
> +			!!(r.flags & IORESOURCE_IRQ_WAKECAPABLE);

You don't need the !!() here. Just

		irq_ctx->wake_capable = r.flags & IORESOURCE_IRQ_WAKECAPABLE;

> +	}
>  
>  	return 1; /* No need to add resource to the list */
>  }
> @@ -182,31 +190,38 @@ static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
>  /**
>   * i2c_acpi_get_irq - get device IRQ number from ACPI
>   * @client: Pointer to the I2C client device
> + * @wake_capable: Set to true if the IRQ is wake capable
>   *
>   * Find the IRQ number used by a specific client device.
>   *
>   * Return: The IRQ number or an error code.
>   */
> -int i2c_acpi_get_irq(struct i2c_client *client)
> +int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
>  {
>  	struct acpi_device *adev = ACPI_COMPANION(&client->dev);
>  	struct list_head resource_list;
> -	int irq = -ENOENT;
> +	struct i2c_acpi_irq_context irq_ctx = {
> +		.irq = -ENOENT,
> +	};
>  	int ret;
>  
>  	INIT_LIST_HEAD(&resource_list);
>  
>  	ret = acpi_dev_get_resources(adev, &resource_list,
> -				     i2c_acpi_add_resource, &irq);
> +				     i2c_acpi_add_resource, &irq_ctx);
>  	if (ret < 0)
>  		return ret;
>  
>  	acpi_dev_free_resource_list(&resource_list);
>  
> -	if (irq == -ENOENT)
> -		irq = acpi_dev_gpio_irq_get(adev, 0);
> +	if (irq_ctx.irq == -ENOENT)
> +		irq_ctx.irq = acpi_dev_gpio_irq_wake_get(adev, 0,
> +							 &irq_ctx.wake_capable);
> +
> +	if (wake_capable)
> +		*wake_capable = irq_ctx.wake_capable;
>  
> -	return irq;
> +	return irq_ctx.irq;
>  }
>  
>  static int i2c_acpi_get_info(struct acpi_device *adev,
> diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c
> index 91007558bcb260..c4debd46c6340f 100644
> --- a/drivers/i2c/i2c-core-base.c
> +++ b/drivers/i2c/i2c-core-base.c
> @@ -487,8 +487,14 @@ static int i2c_device_probe(struct device *dev)
>  			if (irq == -EINVAL || irq == -ENODATA)
>  				irq = of_irq_get(dev->of_node, 0);
>  		} else if (ACPI_COMPANION(dev)) {
> -			irq = i2c_acpi_get_irq(client);
> +			bool wake_capable;
> +
> +			irq = i2c_acpi_get_irq(client, &wake_capable);
> +

Drop the empty line here.

> +			if (irq > 0 && wake_capable)
> +				client->flags |= I2C_CLIENT_WAKE;
>  		}
> +

Unrelated whitespace change.

With those fixed feel free to add,

Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>

Re: [PATCH v3 07/13] i2c: acpi: Use ACPI wake capability bit to set wake_irq

[Raul Rangel]

On Thu, Sep 15, 2022 at 4:46 AM Mika Westerberg
<mika.westerberg@linux.intel.com> wrote:
>
> On Wed, Sep 14, 2022 at 05:57:55PM -0600, Raul E Rangel wrote:
> > Device tree already has a mechanism to pass the wake_irq. It does this
> > by looking for the wakeup-source property and setting the
> > I2C_CLIENT_WAKE flag. This CL adds the ACPI equivalent. It uses the
> > ACPI interrupt wake flag to determine if the interrupt can be used to
> > wake the system. Previously the i2c drivers had to make assumptions and
> > blindly enable the wake IRQ. This can cause spurious wake events. e.g.,
> > If there is a device with an Active Low interrupt and the device gets
> > powered off while suspending, the interrupt line will go low since it's
> > no longer powered and wakes the system. For this reason we should
> > respect the board designers wishes and honor the wake bit defined on the
> > interrupt.
> >
> > Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> > ---
> >
> > Changes in v3:
> > - Convert wake_capable to bool
> > - Only update wake_capable pointer once
> > - Move wake_capable local into local block
> >
> > Changes in v2:
> > - Look at wake_cabple bit for IRQ/Interrupt resources
> >
> >  drivers/i2c/i2c-core-acpi.c | 33 ++++++++++++++++++++++++---------
> >  drivers/i2c/i2c-core-base.c |  8 +++++++-
> >  drivers/i2c/i2c-core.h      |  4 ++--
> >  3 files changed, 33 insertions(+), 12 deletions(-)
> >
> > diff --git a/drivers/i2c/i2c-core-acpi.c b/drivers/i2c/i2c-core-acpi.c
> > index c762a879c4cc6b..b3d68a9659ff4f 100644
> > --- a/drivers/i2c/i2c-core-acpi.c
> > +++ b/drivers/i2c/i2c-core-acpi.c
> > @@ -137,6 +137,11 @@ static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = {
> >       {}
> >  };
> >
> > +struct i2c_acpi_irq_context {
> > +     int irq;
> > +     bool wake_capable;
> > +};
> > +
> >  static int i2c_acpi_do_lookup(struct acpi_device *adev,
> >                             struct i2c_acpi_lookup *lookup)
> >  {
> > @@ -170,11 +175,14 @@ static int i2c_acpi_do_lookup(struct acpi_device *adev,
> >
> >  static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
> >  {
> > -     int *irq = data;
> > +     struct i2c_acpi_irq_context *irq_ctx = data;
> >       struct resource r;
> >

> > -     if (*irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r))
> > -             *irq = i2c_dev_irq_from_resources(&r, 1);
> > +     if (irq_ctx->irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r)) {
> > +             irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
> > +             irq_ctx->wake_capable =
> > +                     !!(r.flags & IORESOURCE_IRQ_WAKECAPABLE);
>
> You don't need the !!() here. Just
>
>                 irq_ctx->wake_capable = r.flags & IORESOURCE_IRQ_WAKECAPABLE;
>
You know, I learned something new today! I was concerned about this
setting `wake_capable` to something that wasn't 0 or 1, but apparently
this is handled by the compiler!

http://port70.net/~nsz/c/c11/n1570.html#6.3.1.2

> 6.3.1.2 Boolean type
> When any scalar value is converted to _Bool, the result is 0 if the value compares equal to 0; otherwise, the result is 1.

Whoah!

> > +     }
> >
> >       return 1; /* No need to add resource to the list */
> >  }
> > @@ -182,31 +190,38 @@ static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
> >  /**
> >   * i2c_acpi_get_irq - get device IRQ number from ACPI
> >   * @client: Pointer to the I2C client device
> > + * @wake_capable: Set to true if the IRQ is wake capable
> >   *
> >   * Find the IRQ number used by a specific client device.
> >   *
> >   * Return: The IRQ number or an error code.
> >   */
> > -int i2c_acpi_get_irq(struct i2c_client *client)
> > +int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
> >  {
> >       struct acpi_device *adev = ACPI_COMPANION(&client->dev);
> >       struct list_head resource_list;
> > -     int irq = -ENOENT;
> > +     struct i2c_acpi_irq_context irq_ctx = {
> > +             .irq = -ENOENT,
> > +     };
> >       int ret;
> >
> >       INIT_LIST_HEAD(&resource_list);
> >
> >       ret = acpi_dev_get_resources(adev, &resource_list,
> > -                                  i2c_acpi_add_resource, &irq);
> > +                                  i2c_acpi_add_resource, &irq_ctx);
> >       if (ret < 0)
> >               return ret;
> >
> >       acpi_dev_free_resource_list(&resource_list);
> >
> > -     if (irq == -ENOENT)
> > -             irq = acpi_dev_gpio_irq_get(adev, 0);
> > +     if (irq_ctx.irq == -ENOENT)
> > +             irq_ctx.irq = acpi_dev_gpio_irq_wake_get(adev, 0,
> > +                                                      &irq_ctx.wake_capable);
> > +
> > +     if (wake_capable)
> > +             *wake_capable = irq_ctx.wake_capable;
> >
> > -     return irq;
> > +     return irq_ctx.irq;
> >  }
> >
> >  static int i2c_acpi_get_info(struct acpi_device *adev,
> > diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c
> > index 91007558bcb260..c4debd46c6340f 100644
> > --- a/drivers/i2c/i2c-core-base.c
> > +++ b/drivers/i2c/i2c-core-base.c
> > @@ -487,8 +487,14 @@ static int i2c_device_probe(struct device *dev)
> >                       if (irq == -EINVAL || irq == -ENODATA)
> >                               irq = of_irq_get(dev->of_node, 0);
> >               } else if (ACPI_COMPANION(dev)) {
> > -                     irq = i2c_acpi_get_irq(client);
> > +                     bool wake_capable;
> > +
> > +                     irq = i2c_acpi_get_irq(client, &wake_capable);
> > +
>
> Drop the empty line here.
Done

>
> > +                     if (irq > 0 && wake_capable)
> > +                             client->flags |= I2C_CLIENT_WAKE;
> >               }
> > +
>
> Unrelated whitespace change.
Done

>
> With those fixed feel free to add,
>
> Reviewed-by: Mika Westerberg <mika.westerberg@linux.intel.com>

Added, thanks!

Re: [PATCH v3 05/13] gpiolib: acpi: Add wake_capable variants of acpi_dev_gpio_irq_get

[Andy Shevchenko]

On Wed, Sep 14, 2022 at 05:57:53PM -0600, Raul E Rangel wrote:
> The ACPI spec defines the SharedAndWake and ExclusiveAndWake share type
> keywords. This is an indication that the GPIO IRQ can also be used as a
> wake source. This change exposes the wake_capable bit so drivers can
> correctly enable wake functionality instead of making an assumption.

With two nit-picks below
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>

> Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> ---
> 
> Changes in v3:
> - Kept `acpi_dev_gpio_irq_get_by` unchanged to avoid having to touch
>   unrelated drivers.
> - Converted wake_capable parameter to bool.
> 
> Changes in v2:
> - Fixed call site in mlxbf_gige_probe
> 
>  drivers/gpio/gpiolib-acpi.c | 17 ++++++++++++++---
>  drivers/gpio/gpiolib-acpi.h |  2 ++
>  include/linux/acpi.h        | 22 ++++++++++++++++++----
>  3 files changed, 34 insertions(+), 7 deletions(-)
> 
> diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
> index 9be1376f9a627f..c703f095993a2c 100644
> --- a/drivers/gpio/gpiolib-acpi.c
> +++ b/drivers/gpio/gpiolib-acpi.c
> @@ -741,6 +741,8 @@ static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data)
>  		lookup->info.pin_config = agpio->pin_config;
>  		lookup->info.debounce = agpio->debounce_timeout;
>  		lookup->info.gpioint = gpioint;
> +		lookup->info.wake_capable = agpio->wake_capable ==
> +					    ACPI_WAKE_CAPABLE;

Can be still on one line.

>  		/*
>  		 * Polarity and triggering are only specified for GpioInt
> @@ -987,10 +989,12 @@ struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
>  }
>  
>  /**
> - * acpi_dev_gpio_irq_get_by() - Find GpioInt and translate it to Linux IRQ number
> + * acpi_dev_gpio_irq_wake_get_by() - Find GpioInt and translate it to Linux IRQ
> + *                                   number
>   * @adev: pointer to a ACPI device to get IRQ from
>   * @name: optional name of GpioInt resource
>   * @index: index of GpioInt resource (starting from %0)
> + * @wake_capable: Set to true if the IRQ is wake capable
>   *
>   * If the device has one or more GpioInt resources, this function can be
>   * used to translate from the GPIO offset in the resource to the Linux IRQ
> @@ -1002,9 +1006,13 @@ struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
>   * The function takes optional @name parameter. If the resource has a property
>   * name, then only those will be taken into account.
>   *
> + * The GPIO is considered wake capable if the GpioInt resource specifies
> + * SharedAndWake or ExclusiveAndWake.
> + *
>   * Return: Linux IRQ number (> %0) on success, negative errno on failure.
>   */
> -int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index)
> +int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *name,
> +				  int index, bool *wake_capable)
>  {
>  	int idx, i;
>  	unsigned int irq_flags;
> @@ -1061,13 +1069,16 @@ int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int ind
>  				dev_dbg(&adev->dev, "IRQ %d already in use\n", irq);
>  			}
>  
> +			if (wake_capable)
> +				*wake_capable = info.wake_capable;
> +
>  			return irq;
>  		}
>  
>  	}
>  	return -ENOENT;
>  }
> -EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get_by);
> +EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_wake_get_by);
>  
>  static acpi_status
>  acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
> diff --git a/drivers/gpio/gpiolib-acpi.h b/drivers/gpio/gpiolib-acpi.h
> index e476558d947136..1ac6816839dbce 100644
> --- a/drivers/gpio/gpiolib-acpi.h
> +++ b/drivers/gpio/gpiolib-acpi.h
> @@ -18,6 +18,7 @@ struct acpi_device;
>   * @pin_config: pin bias as provided by ACPI
>   * @polarity: interrupt polarity as provided by ACPI
>   * @triggering: triggering type as provided by ACPI
> + * @wake_capable: wake capability as provided by ACPI
>   * @debounce: debounce timeout as provided by ACPI
>   * @quirks: Linux specific quirks as provided by struct acpi_gpio_mapping
>   */
> @@ -28,6 +29,7 @@ struct acpi_gpio_info {
>  	int pin_config;
>  	int polarity;
>  	int triggering;
> +	bool wake_capable;
>  	unsigned int debounce;
>  	unsigned int quirks;
>  };
> diff --git a/include/linux/acpi.h b/include/linux/acpi.h
> index 6f64b2f3dc5479..d3121cef6cc3bc 100644
> --- a/include/linux/acpi.h
> +++ b/include/linux/acpi.h
> @@ -1202,7 +1202,8 @@ bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
>  				struct acpi_resource_gpio **agpio);
>  bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
>  			       struct acpi_resource_gpio **agpio);
> -int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index);
> +int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *name,
> +				  int index, bool *wake_capable);
>  #else
>  static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
>  					      struct acpi_resource_gpio **agpio)
> @@ -1214,16 +1215,29 @@ static inline bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
>  {
>  	return false;
>  }
> -static inline int acpi_dev_gpio_irq_get_by(struct acpi_device *adev,
> -					   const char *name, int index)
> +static inline int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev,
> +						const char *name, int index,
> +						bool *wake_capable)
>  {
>  	return -ENXIO;
>  }
>  #endif
>  
> +static inline int acpi_dev_gpio_irq_get_by(struct acpi_device *adev,
> +					   const char *name, int index)
> +{
> +	return acpi_dev_gpio_irq_wake_get_by(adev, name, index, NULL);
> +}
> +
>  static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
>  {
> -	return acpi_dev_gpio_irq_get_by(adev, NULL, index);
> +	return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, NULL);
> +}

> +static inline int acpi_dev_gpio_irq_wake_get(struct acpi_device *adev,
> +					     int index, bool *wake_capable)
> +{
> +	return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, wake_capable);
>  }

I would put this first in the group of these three helpers, so irq_get_by and
irq_get will be the last (from more parameters to less parameters).

>  /* Device properties */
> -- 
> 2.37.3.968.ga6b4b080e4-goog
> 

-- 
With Best Regards,
Andy Shevchenko

Re: [PATCH v3 06/13] ACPI: resources: Add wake_capable parameter to acpi_dev_irq_flags

[Andy Shevchenko]

On Wed, Sep 14, 2022 at 05:57:54PM -0600, Raul E Rangel wrote:
> ACPI IRQ/Interrupt resources contain a bit that describes if the
> interrupt should wake the system. This change exposes that bit via
> a new IORESOURCE_IRQ_WAKECAPABLE flag. Drivers should check this flag
> before arming an IRQ to wake the system.

From code perspective it's straightforward, so
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
(take a look into nit-picks, though)

From the functional perspective AFAIU it's appreciated, but I'm not
a guru in this domain to tell.

> Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> ---
> 
> Changes in v3:
> - Fixed bad indent
> 
> Changes in v2:
> - Added ability to extract wake bit from Interrupt/IRQ resources
> 
>  drivers/acpi/irq.c             | 11 ++++++++---
>  drivers/acpi/resource.c        | 24 +++++++++++++++++-------
>  drivers/pnp/pnpacpi/rsparser.c |  9 ++++++---
>  include/linux/acpi.h           |  3 ++-
>  include/linux/ioport.h         |  3 ++-
>  5 files changed, 35 insertions(+), 15 deletions(-)
> 
> diff --git a/drivers/acpi/irq.c b/drivers/acpi/irq.c
> index dabe45eba055d1..5483cf9a28e3a0 100644
> --- a/drivers/acpi/irq.c
> +++ b/drivers/acpi/irq.c
> @@ -147,6 +147,7 @@ struct acpi_irq_parse_one_ctx {
>   * @polarity: polarity attributes of hwirq
>   * @polarity: polarity attributes of hwirq
>   * @shareable: shareable attributes of hwirq
> + * @wake_capable: wake capable attribute of hwirq
>   * @ctx: acpi_irq_parse_one_ctx updated by this function
>   *
>   * Description:
> @@ -156,12 +157,14 @@ struct acpi_irq_parse_one_ctx {
>  static inline void acpi_irq_parse_one_match(struct fwnode_handle *fwnode,
>  					    u32 hwirq, u8 triggering,
>  					    u8 polarity, u8 shareable,
> +					    u8 wake_capable,
>  					    struct acpi_irq_parse_one_ctx *ctx)
>  {
>  	if (!fwnode)
>  		return;
>  	ctx->rc = 0;
> -	*ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable);
> +	*ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable,
> +					     wake_capable);

Can be on one line.

>  	ctx->fwspec->fwnode = fwnode;
>  	ctx->fwspec->param[0] = hwirq;
>  	ctx->fwspec->param[1] = acpi_dev_get_irq_type(triggering, polarity);
> @@ -204,7 +207,8 @@ static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,
>  		fwnode = acpi_get_gsi_domain_id(irq->interrupts[ctx->index]);
>  		acpi_irq_parse_one_match(fwnode, irq->interrupts[ctx->index],
>  					 irq->triggering, irq->polarity,
> -					 irq->shareable, ctx);
> +					 irq->shareable, irq->wake_capable,
> +					 ctx);

Ditto.

>  		return AE_CTRL_TERMINATE;
>  	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
>  		eirq = &ares->data.extended_irq;
> @@ -218,7 +222,8 @@ static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,
>  						      eirq->interrupts[ctx->index]);
>  		acpi_irq_parse_one_match(fwnode, eirq->interrupts[ctx->index],
>  					 eirq->triggering, eirq->polarity,
> -					 eirq->shareable, ctx);
> +					 eirq->shareable, eirq->wake_capable,
> +					 ctx);

Ditto.

>  		return AE_CTRL_TERMINATE;
>  	}
>  
> diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
> index 510cdec375c4d8..6a1c008a348902 100644
> --- a/drivers/acpi/resource.c
> +++ b/drivers/acpi/resource.c
> @@ -336,8 +336,10 @@ EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space);
>   * @triggering: Triggering type as provided by ACPI.
>   * @polarity: Interrupt polarity as provided by ACPI.
>   * @shareable: Whether or not the interrupt is shareable.
> + * @wake_capable: Wake capability as provided by ACPI.
>   */
> -unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
> +unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable,
> +				 u8 wake_capable)

Ditto.

>  {
>  	unsigned long flags;
>  
> @@ -351,6 +353,9 @@ unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
>  	if (shareable == ACPI_SHARED)
>  		flags |= IORESOURCE_IRQ_SHAREABLE;
>  
> +	if (wake_capable == ACPI_WAKE_CAPABLE)
> +		flags |= IORESOURCE_IRQ_WAKECAPABLE;
> +
>  	return flags | IORESOURCE_IRQ;
>  }
>  EXPORT_SYMBOL_GPL(acpi_dev_irq_flags);
> @@ -442,7 +447,7 @@ static bool acpi_dev_irq_override(u32 gsi, u8 triggering, u8 polarity,
>  
>  static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
>  				     u8 triggering, u8 polarity, u8 shareable,
> -				     bool check_override)
> +				     u8 wake_capable, bool check_override)
>  {
>  	int irq, p, t;
>  
> @@ -475,7 +480,8 @@ static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
>  		}
>  	}
>  
> -	res->flags = acpi_dev_irq_flags(triggering, polarity, shareable);
> +	res->flags = acpi_dev_irq_flags(triggering, polarity, shareable,
> +					wake_capable);

Ditto.

>  	irq = acpi_register_gsi(NULL, gsi, triggering, polarity);
>  	if (irq >= 0) {
>  		res->start = irq;
> @@ -523,7 +529,8 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
>  		}
>  		acpi_dev_get_irqresource(res, irq->interrupts[index],
>  					 irq->triggering, irq->polarity,
> -					 irq->shareable, true);
> +					 irq->shareable, irq->wake_capable,
> +					 true);
>  		break;
>  	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
>  		ext_irq = &ares->data.extended_irq;
> @@ -532,9 +539,12 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
>  			return false;
>  		}
>  		if (is_gsi(ext_irq))
> -			acpi_dev_get_irqresource(res, ext_irq->interrupts[index],
> -					 ext_irq->triggering, ext_irq->polarity,
> -					 ext_irq->shareable, false);
> +			acpi_dev_get_irqresource(res,
> +						 ext_irq->interrupts[index],
> +						 ext_irq->triggering,
> +						 ext_irq->polarity,
> +						 ext_irq->shareable,
> +						 ext_irq->wake_capable, false);

Maybe false on the next line to split FW parameters from pure software ones?

>  		else
>  			irqresource_disabled(res, 0);
>  		break;
> diff --git a/drivers/pnp/pnpacpi/rsparser.c b/drivers/pnp/pnpacpi/rsparser.c
> index da78dc77aed32e..55b28fc0a94042 100644
> --- a/drivers/pnp/pnpacpi/rsparser.c
> +++ b/drivers/pnp/pnpacpi/rsparser.c
> @@ -206,7 +206,8 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
>  		if (i >= 0) {
>  			flags = acpi_dev_irq_flags(gpio->triggering,
>  						   gpio->polarity,
> -						   gpio->shareable);
> +						   gpio->shareable,
> +						   gpio->wake_capable);
>  		} else {
>  			flags = IORESOURCE_DISABLED;
>  		}
> @@ -315,7 +316,8 @@ static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
>  		if (p->interrupts[i])
>  			__set_bit(p->interrupts[i], map.bits);
>  
> -	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
> +	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable,
> +				   p->wake_capable);
>  	pnp_register_irq_resource(dev, option_flags, &map, flags);
>  }
>  
> @@ -339,7 +341,8 @@ static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
>  		}
>  	}
>  
> -	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
> +	flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable,
> +				   p->wake_capable);

One line?

>  	pnp_register_irq_resource(dev, option_flags, &map, flags);
>  }
>  
> diff --git a/include/linux/acpi.h b/include/linux/acpi.h
> index d3121cef6cc3bc..9f7947ee1b006f 100644
> --- a/include/linux/acpi.h
> +++ b/include/linux/acpi.h
> @@ -495,7 +495,8 @@ bool acpi_dev_resource_address_space(struct acpi_resource *ares,
>  				     struct resource_win *win);
>  bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
>  					 struct resource_win *win);
> -unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
> +unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable,
> +				 u8 wake_capable);

One line?

>  unsigned int acpi_dev_get_irq_type(int triggering, int polarity);
>  bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
>  				 struct resource *res);
> diff --git a/include/linux/ioport.h b/include/linux/ioport.h
> index 616b683563a970..3baeea4d903bfd 100644
> --- a/include/linux/ioport.h
> +++ b/include/linux/ioport.h
> @@ -79,7 +79,8 @@ struct resource {
>  #define IORESOURCE_IRQ_HIGHLEVEL	(1<<2)
>  #define IORESOURCE_IRQ_LOWLEVEL		(1<<3)
>  #define IORESOURCE_IRQ_SHAREABLE	(1<<4)
> -#define IORESOURCE_IRQ_OPTIONAL 	(1<<5)
> +#define IORESOURCE_IRQ_OPTIONAL		(1<<5)
> +#define IORESOURCE_IRQ_WAKECAPABLE	(1<<6)
>  
>  /* PnP DMA specific bits (IORESOURCE_BITS) */
>  #define IORESOURCE_DMA_TYPE_MASK	(3<<0)
> -- 
> 2.37.3.968.ga6b4b080e4-goog
> 

-- 
With Best Regards,
Andy Shevchenko

Re: [PATCH v3 07/13] i2c: acpi: Use ACPI wake capability bit to set wake_irq

[Andy Shevchenko]

On Wed, Sep 14, 2022 at 05:57:55PM -0600, Raul E Rangel wrote:
> Device tree already has a mechanism to pass the wake_irq. It does this
> by looking for the wakeup-source property and setting the
> I2C_CLIENT_WAKE flag. This CL adds the ACPI equivalent. It uses the
> ACPI interrupt wake flag to determine if the interrupt can be used to
> wake the system. Previously the i2c drivers had to make assumptions and
> blindly enable the wake IRQ. This can cause spurious wake events. e.g.,
> If there is a device with an Active Low interrupt and the device gets
> powered off while suspending, the interrupt line will go low since it's
> no longer powered and wakes the system. For this reason we should
> respect the board designers wishes and honor the wake bit defined on the
> interrupt.

Okay, let's go with this variant, but I'm afraid that in time we may come up
to the proposed (generic structure for ACPI IRQ parameters which can be used
in a few places).

Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>

> Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> ---
> 
> Changes in v3:
> - Convert wake_capable to bool
> - Only update wake_capable pointer once
> - Move wake_capable local into local block
> 
> Changes in v2:
> - Look at wake_cabple bit for IRQ/Interrupt resources
> 
>  drivers/i2c/i2c-core-acpi.c | 33 ++++++++++++++++++++++++---------
>  drivers/i2c/i2c-core-base.c |  8 +++++++-
>  drivers/i2c/i2c-core.h      |  4 ++--
>  3 files changed, 33 insertions(+), 12 deletions(-)
> 
> diff --git a/drivers/i2c/i2c-core-acpi.c b/drivers/i2c/i2c-core-acpi.c
> index c762a879c4cc6b..b3d68a9659ff4f 100644
> --- a/drivers/i2c/i2c-core-acpi.c
> +++ b/drivers/i2c/i2c-core-acpi.c
> @@ -137,6 +137,11 @@ static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = {
>  	{}
>  };
>  
> +struct i2c_acpi_irq_context {
> +	int irq;
> +	bool wake_capable;
> +};
> +
>  static int i2c_acpi_do_lookup(struct acpi_device *adev,
>  			      struct i2c_acpi_lookup *lookup)
>  {
> @@ -170,11 +175,14 @@ static int i2c_acpi_do_lookup(struct acpi_device *adev,
>  
>  static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
>  {
> -	int *irq = data;
> +	struct i2c_acpi_irq_context *irq_ctx = data;
>  	struct resource r;
>  
> -	if (*irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r))
> -		*irq = i2c_dev_irq_from_resources(&r, 1);
> +	if (irq_ctx->irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r)) {
> +		irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
> +		irq_ctx->wake_capable =
> +			!!(r.flags & IORESOURCE_IRQ_WAKECAPABLE);
> +	}

Maybe

	if (irq_ctx->irq > 0)
		return 1;

	if (!acpi_dev_resource_interrupt(ares, 0, &r))
		return 1;

	irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
	irq_ctx->wake_capable = !!(r.flags & IORESOURCE_IRQ_WAKECAPABLE);

?

>  	return 1; /* No need to add resource to the list */
>  }

Also not sure why the callback is not called i2c_acpi_add_irq_resource().
But it probably can be done in a separate change.

> @@ -182,31 +190,38 @@ static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
>  /**
>   * i2c_acpi_get_irq - get device IRQ number from ACPI
>   * @client: Pointer to the I2C client device
> + * @wake_capable: Set to true if the IRQ is wake capable
>   *
>   * Find the IRQ number used by a specific client device.
>   *
>   * Return: The IRQ number or an error code.
>   */
> -int i2c_acpi_get_irq(struct i2c_client *client)
> +int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
>  {
>  	struct acpi_device *adev = ACPI_COMPANION(&client->dev);
>  	struct list_head resource_list;
> -	int irq = -ENOENT;
> +	struct i2c_acpi_irq_context irq_ctx = {
> +		.irq = -ENOENT,
> +	};
>  	int ret;
>  
>  	INIT_LIST_HEAD(&resource_list);
>  
>  	ret = acpi_dev_get_resources(adev, &resource_list,
> -				     i2c_acpi_add_resource, &irq);
> +				     i2c_acpi_add_resource, &irq_ctx);
>  	if (ret < 0)
>  		return ret;
>  
>  	acpi_dev_free_resource_list(&resource_list);
>  
> -	if (irq == -ENOENT)
> -		irq = acpi_dev_gpio_irq_get(adev, 0);
> +	if (irq_ctx.irq == -ENOENT)
> +		irq_ctx.irq = acpi_dev_gpio_irq_wake_get(adev, 0,
> +							 &irq_ctx.wake_capable);
> +
> +	if (wake_capable)
> +		*wake_capable = irq_ctx.wake_capable;
>  
> -	return irq;
> +	return irq_ctx.irq;
>  }
>  
>  static int i2c_acpi_get_info(struct acpi_device *adev,
> diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c
> index 91007558bcb260..c4debd46c6340f 100644
> --- a/drivers/i2c/i2c-core-base.c
> +++ b/drivers/i2c/i2c-core-base.c
> @@ -487,8 +487,14 @@ static int i2c_device_probe(struct device *dev)
>  			if (irq == -EINVAL || irq == -ENODATA)
>  				irq = of_irq_get(dev->of_node, 0);
>  		} else if (ACPI_COMPANION(dev)) {
> -			irq = i2c_acpi_get_irq(client);
> +			bool wake_capable;
> +
> +			irq = i2c_acpi_get_irq(client, &wake_capable);

> +

Unneeded blank line.

> +			if (irq > 0 && wake_capable)
> +				client->flags |= I2C_CLIENT_WAKE;
>  		}

> +

Ditto. (This even looks like a stray change)

>  		if (irq == -EPROBE_DEFER) {
>  			status = irq;
>  			goto put_sync_adapter;
> diff --git a/drivers/i2c/i2c-core.h b/drivers/i2c/i2c-core.h
> index 87e2c914f1c57b..1247e6e6e97517 100644
> --- a/drivers/i2c/i2c-core.h
> +++ b/drivers/i2c/i2c-core.h
> @@ -61,11 +61,11 @@ static inline int __i2c_check_suspended(struct i2c_adapter *adap)
>  #ifdef CONFIG_ACPI
>  void i2c_acpi_register_devices(struct i2c_adapter *adap);
>  
> -int i2c_acpi_get_irq(struct i2c_client *client);
> +int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable);
>  #else /* CONFIG_ACPI */
>  static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
>  
> -static inline int i2c_acpi_get_irq(struct i2c_client *client)
> +static inline int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
>  {
>  	return 0;
>  }
> -- 
> 2.37.3.968.ga6b4b080e4-goog
> 

-- 
With Best Regards,
Andy Shevchenko

Re: [PATCH v3 05/13] gpiolib: acpi: Add wake_capable variants of acpi_dev_gpio_irq_get

[Raul Rangel]

On Mon, Sep 19, 2022 at 3:54 AM Andy Shevchenko
<andriy.shevchenko@linux.intel.com> wrote:
>
> On Wed, Sep 14, 2022 at 05:57:53PM -0600, Raul E Rangel wrote:
> > The ACPI spec defines the SharedAndWake and ExclusiveAndWake share type
> > keywords. This is an indication that the GPIO IRQ can also be used as a
> > wake source. This change exposes the wake_capable bit so drivers can
> > correctly enable wake functionality instead of making an assumption.
>
> With two nit-picks below
> Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
>
> > Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> > ---
> >
> > Changes in v3:
> > - Kept `acpi_dev_gpio_irq_get_by` unchanged to avoid having to touch
> >   unrelated drivers.
> > - Converted wake_capable parameter to bool.
> >
> > Changes in v2:
> > - Fixed call site in mlxbf_gige_probe
> >
> >  drivers/gpio/gpiolib-acpi.c | 17 ++++++++++++++---
> >  drivers/gpio/gpiolib-acpi.h |  2 ++
> >  include/linux/acpi.h        | 22 ++++++++++++++++++----
> >  3 files changed, 34 insertions(+), 7 deletions(-)
> >

> > diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
> > index 9be1376f9a627f..c703f095993a2c 100644
> > --- a/drivers/gpio/gpiolib-acpi.c
> > +++ b/drivers/gpio/gpiolib-acpi.c
> > @@ -741,6 +741,8 @@ static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data)
> >               lookup->info.pin_config = agpio->pin_config;
> >               lookup->info.debounce = agpio->debounce_timeout;
> >               lookup->info.gpioint = gpioint;
> > +             lookup->info.wake_capable = agpio->wake_capable ==
> > +                                         ACPI_WAKE_CAPABLE;
>
> Can be still on one line.
>

I used clang-format to format the code. Apparently that still uses the
80 char limit. I've gone ahead and manually changed it.

> >               /*
> >                * Polarity and triggering are only specified for GpioInt
> > @@ -987,10 +989,12 @@ struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
> >  }
> >
> >  /**
> > - * acpi_dev_gpio_irq_get_by() - Find GpioInt and translate it to Linux IRQ number
> > + * acpi_dev_gpio_irq_wake_get_by() - Find GpioInt and translate it to Linux IRQ
> > + *                                   number
> >   * @adev: pointer to a ACPI device to get IRQ from
> >   * @name: optional name of GpioInt resource
> >   * @index: index of GpioInt resource (starting from %0)
> > + * @wake_capable: Set to true if the IRQ is wake capable
> >   *
> >   * If the device has one or more GpioInt resources, this function can be
> >   * used to translate from the GPIO offset in the resource to the Linux IRQ
> > @@ -1002,9 +1006,13 @@ struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
> >   * The function takes optional @name parameter. If the resource has a property
> >   * name, then only those will be taken into account.
> >   *
> > + * The GPIO is considered wake capable if the GpioInt resource specifies
> > + * SharedAndWake or ExclusiveAndWake.
> > + *
> >   * Return: Linux IRQ number (> %0) on success, negative errno on failure.
> >   */
> > -int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index)
> > +int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *name,
> > +                               int index, bool *wake_capable)
> >  {
> >       int idx, i;
> >       unsigned int irq_flags;
> > @@ -1061,13 +1069,16 @@ int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int ind
> >                               dev_dbg(&adev->dev, "IRQ %d already in use\n", irq);
> >                       }
> >
> > +                     if (wake_capable)
> > +                             *wake_capable = info.wake_capable;
> > +
> >                       return irq;
> >               }
> >
> >       }
> >       return -ENOENT;
> >  }
> > -EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get_by);
> > +EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_wake_get_by);
> >
> >  static acpi_status
> >  acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
> > diff --git a/drivers/gpio/gpiolib-acpi.h b/drivers/gpio/gpiolib-acpi.h
> > index e476558d947136..1ac6816839dbce 100644
> > --- a/drivers/gpio/gpiolib-acpi.h
> > +++ b/drivers/gpio/gpiolib-acpi.h
> > @@ -18,6 +18,7 @@ struct acpi_device;
> >   * @pin_config: pin bias as provided by ACPI
> >   * @polarity: interrupt polarity as provided by ACPI
> >   * @triggering: triggering type as provided by ACPI
> > + * @wake_capable: wake capability as provided by ACPI
> >   * @debounce: debounce timeout as provided by ACPI
> >   * @quirks: Linux specific quirks as provided by struct acpi_gpio_mapping
> >   */
> > @@ -28,6 +29,7 @@ struct acpi_gpio_info {
> >       int pin_config;
> >       int polarity;
> >       int triggering;
> > +     bool wake_capable;
> >       unsigned int debounce;
> >       unsigned int quirks;
> >  };
> > diff --git a/include/linux/acpi.h b/include/linux/acpi.h
> > index 6f64b2f3dc5479..d3121cef6cc3bc 100644
> > --- a/include/linux/acpi.h
> > +++ b/include/linux/acpi.h
> > @@ -1202,7 +1202,8 @@ bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
> >                               struct acpi_resource_gpio **agpio);
> >  bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
> >                              struct acpi_resource_gpio **agpio);
> > -int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index);
> > +int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *name,
> > +                               int index, bool *wake_capable);
> >  #else
> >  static inline bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
> >                                             struct acpi_resource_gpio **agpio)
> > @@ -1214,16 +1215,29 @@ static inline bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
> >  {
> >       return false;
> >  }
> > -static inline int acpi_dev_gpio_irq_get_by(struct acpi_device *adev,
> > -                                        const char *name, int index)
> > +static inline int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev,
> > +                                             const char *name, int index,
> > +                                             bool *wake_capable)
> >  {
> >       return -ENXIO;
> >  }
> >  #endif
> >
> > +static inline int acpi_dev_gpio_irq_get_by(struct acpi_device *adev,
> > +                                        const char *name, int index)
> > +{
> > +     return acpi_dev_gpio_irq_wake_get_by(adev, name, index, NULL);
> > +}
> > +
> >  static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
> >  {
> > -     return acpi_dev_gpio_irq_get_by(adev, NULL, index);
> > +     return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, NULL);
> > +}
>

> > +static inline int acpi_dev_gpio_irq_wake_get(struct acpi_device *adev,
> > +                                          int index, bool *wake_capable)
> > +{
> > +     return acpi_dev_gpio_irq_wake_get_by(adev, NULL, index, wake_capable);
> >  }
>
> I would put this first in the group of these three helpers, so irq_get_by and
> irq_get will be the last (from more parameters to less parameters).
>

Done

> >  /* Device properties */
> > --
> > 2.37.3.968.ga6b4b080e4-goog
> >
>
> --
> With Best Regards,
> Andy Shevchenko
>
>

Thanks for the review!

Re: [PATCH v3 06/13] ACPI: resources: Add wake_capable parameter to acpi_dev_irq_flags

[Raul Rangel]

On Mon, Sep 19, 2022 at 3:54 AM Andy Shevchenko
<andriy.shevchenko@linux.intel.com> wrote:
>
> On Wed, Sep 14, 2022 at 05:57:54PM -0600, Raul E Rangel wrote:
> > ACPI IRQ/Interrupt resources contain a bit that describes if the
> > interrupt should wake the system. This change exposes that bit via
> > a new IORESOURCE_IRQ_WAKECAPABLE flag. Drivers should check this flag
> > before arming an IRQ to wake the system.
>

> From code perspective it's straightforward, so
> Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
> (take a look into nit-picks, though)

I went ahead and re-ran clang-format with a 96 char limit, then I
manually applied the rest of the nits.
Thanks!

>
> From the functional perspective AFAIU it's appreciated, but I'm not
> a guru in this domain to tell.
>
> > Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> > ---
> >
> > Changes in v3:
> > - Fixed bad indent
> >
> > Changes in v2:
> > - Added ability to extract wake bit from Interrupt/IRQ resources
> >
> >  drivers/acpi/irq.c             | 11 ++++++++---
> >  drivers/acpi/resource.c        | 24 +++++++++++++++++-------
> >  drivers/pnp/pnpacpi/rsparser.c |  9 ++++++---
> >  include/linux/acpi.h           |  3 ++-
> >  include/linux/ioport.h         |  3 ++-
> >  5 files changed, 35 insertions(+), 15 deletions(-)
> >
> > diff --git a/drivers/acpi/irq.c b/drivers/acpi/irq.c
> > index dabe45eba055d1..5483cf9a28e3a0 100644
> > --- a/drivers/acpi/irq.c
> > +++ b/drivers/acpi/irq.c
> > @@ -147,6 +147,7 @@ struct acpi_irq_parse_one_ctx {
> >   * @polarity: polarity attributes of hwirq
> >   * @polarity: polarity attributes of hwirq
> >   * @shareable: shareable attributes of hwirq
> > + * @wake_capable: wake capable attribute of hwirq
> >   * @ctx: acpi_irq_parse_one_ctx updated by this function
> >   *
> >   * Description:
> > @@ -156,12 +157,14 @@ struct acpi_irq_parse_one_ctx {
> >  static inline void acpi_irq_parse_one_match(struct fwnode_handle *fwnode,
> >                                           u32 hwirq, u8 triggering,
> >                                           u8 polarity, u8 shareable,
> > +                                         u8 wake_capable,
> >                                           struct acpi_irq_parse_one_ctx *ctx)
> >  {
> >       if (!fwnode)
> >               return;
> >       ctx->rc = 0;
> > -     *ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable);
> > +     *ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable,
> > +                                          wake_capable);
>
> Can be on one line.
>
> >       ctx->fwspec->fwnode = fwnode;
> >       ctx->fwspec->param[0] = hwirq;
> >       ctx->fwspec->param[1] = acpi_dev_get_irq_type(triggering, polarity);
> > @@ -204,7 +207,8 @@ static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,
> >               fwnode = acpi_get_gsi_domain_id(irq->interrupts[ctx->index]);
> >               acpi_irq_parse_one_match(fwnode, irq->interrupts[ctx->index],
> >                                        irq->triggering, irq->polarity,
> > -                                      irq->shareable, ctx);
> > +                                      irq->shareable, irq->wake_capable,
> > +                                      ctx);
>
> Ditto.
>
> >               return AE_CTRL_TERMINATE;
> >       case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
> >               eirq = &ares->data.extended_irq;
> > @@ -218,7 +222,8 @@ static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,
> >                                                     eirq->interrupts[ctx->index]);
> >               acpi_irq_parse_one_match(fwnode, eirq->interrupts[ctx->index],
> >                                        eirq->triggering, eirq->polarity,
> > -                                      eirq->shareable, ctx);
> > +                                      eirq->shareable, eirq->wake_capable,
> > +                                      ctx);
>
> Ditto.
>
> >               return AE_CTRL_TERMINATE;
> >       }
> >
> > diff --git a/drivers/acpi/resource.c b/drivers/acpi/resource.c
> > index 510cdec375c4d8..6a1c008a348902 100644
> > --- a/drivers/acpi/resource.c
> > +++ b/drivers/acpi/resource.c
> > @@ -336,8 +336,10 @@ EXPORT_SYMBOL_GPL(acpi_dev_resource_ext_address_space);
> >   * @triggering: Triggering type as provided by ACPI.
> >   * @polarity: Interrupt polarity as provided by ACPI.
> >   * @shareable: Whether or not the interrupt is shareable.
> > + * @wake_capable: Wake capability as provided by ACPI.
> >   */
> > -unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
> > +unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable,
> > +                              u8 wake_capable)
>
> Ditto.
>
> >  {
> >       unsigned long flags;
> >
> > @@ -351,6 +353,9 @@ unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable)
> >       if (shareable == ACPI_SHARED)
> >               flags |= IORESOURCE_IRQ_SHAREABLE;
> >
> > +     if (wake_capable == ACPI_WAKE_CAPABLE)
> > +             flags |= IORESOURCE_IRQ_WAKECAPABLE;
> > +
> >       return flags | IORESOURCE_IRQ;
> >  }
> >  EXPORT_SYMBOL_GPL(acpi_dev_irq_flags);
> > @@ -442,7 +447,7 @@ static bool acpi_dev_irq_override(u32 gsi, u8 triggering, u8 polarity,
> >
> >  static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
> >                                    u8 triggering, u8 polarity, u8 shareable,
> > -                                  bool check_override)
> > +                                  u8 wake_capable, bool check_override)
> >  {
> >       int irq, p, t;
> >
> > @@ -475,7 +480,8 @@ static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
> >               }
> >       }
> >
> > -     res->flags = acpi_dev_irq_flags(triggering, polarity, shareable);
> > +     res->flags = acpi_dev_irq_flags(triggering, polarity, shareable,
> > +                                     wake_capable);
>
> Ditto.
>
> >       irq = acpi_register_gsi(NULL, gsi, triggering, polarity);
> >       if (irq >= 0) {
> >               res->start = irq;
> > @@ -523,7 +529,8 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
> >               }
> >               acpi_dev_get_irqresource(res, irq->interrupts[index],
> >                                        irq->triggering, irq->polarity,
> > -                                      irq->shareable, true);
> > +                                      irq->shareable, irq->wake_capable,
> > +                                      true);
> >               break;
> >       case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
> >               ext_irq = &ares->data.extended_irq;
> > @@ -532,9 +539,12 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
> >                       return false;
> >               }
> >               if (is_gsi(ext_irq))
> > -                     acpi_dev_get_irqresource(res, ext_irq->interrupts[index],
> > -                                      ext_irq->triggering, ext_irq->polarity,
> > -                                      ext_irq->shareable, false);
> > +                     acpi_dev_get_irqresource(res,
> > +                                              ext_irq->interrupts[index],
> > +                                              ext_irq->triggering,
> > +                                              ext_irq->polarity,
> > +                                              ext_irq->shareable,
> > +                                              ext_irq->wake_capable, false);
>
> Maybe false on the next line to split FW parameters from pure software ones?
>
> >               else
> >                       irqresource_disabled(res, 0);
> >               break;
> > diff --git a/drivers/pnp/pnpacpi/rsparser.c b/drivers/pnp/pnpacpi/rsparser.c
> > index da78dc77aed32e..55b28fc0a94042 100644
> > --- a/drivers/pnp/pnpacpi/rsparser.c
> > +++ b/drivers/pnp/pnpacpi/rsparser.c
> > @@ -206,7 +206,8 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
> >               if (i >= 0) {
> >                       flags = acpi_dev_irq_flags(gpio->triggering,
> >                                                  gpio->polarity,
> > -                                                gpio->shareable);
> > +                                                gpio->shareable,
> > +                                                gpio->wake_capable);
> >               } else {
> >                       flags = IORESOURCE_DISABLED;
> >               }
> > @@ -315,7 +316,8 @@ static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
> >               if (p->interrupts[i])
> >                       __set_bit(p->interrupts[i], map.bits);
> >
> > -     flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
> > +     flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable,
> > +                                p->wake_capable);
> >       pnp_register_irq_resource(dev, option_flags, &map, flags);
> >  }
> >
> > @@ -339,7 +341,8 @@ static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
> >               }
> >       }
> >
> > -     flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable);
> > +     flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable,
> > +                                p->wake_capable);
>
> One line?
>
> >       pnp_register_irq_resource(dev, option_flags, &map, flags);
> >  }
> >
> > diff --git a/include/linux/acpi.h b/include/linux/acpi.h
> > index d3121cef6cc3bc..9f7947ee1b006f 100644
> > --- a/include/linux/acpi.h
> > +++ b/include/linux/acpi.h
> > @@ -495,7 +495,8 @@ bool acpi_dev_resource_address_space(struct acpi_resource *ares,
> >                                    struct resource_win *win);
> >  bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
> >                                        struct resource_win *win);
> > -unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
> > +unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable,
> > +                              u8 wake_capable);
>
> One line?
>
> >  unsigned int acpi_dev_get_irq_type(int triggering, int polarity);
> >  bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
> >                                struct resource *res);
> > diff --git a/include/linux/ioport.h b/include/linux/ioport.h
> > index 616b683563a970..3baeea4d903bfd 100644
> > --- a/include/linux/ioport.h
> > +++ b/include/linux/ioport.h
> > @@ -79,7 +79,8 @@ struct resource {
> >  #define IORESOURCE_IRQ_HIGHLEVEL     (1<<2)
> >  #define IORESOURCE_IRQ_LOWLEVEL              (1<<3)
> >  #define IORESOURCE_IRQ_SHAREABLE     (1<<4)
> > -#define IORESOURCE_IRQ_OPTIONAL      (1<<5)
> > +#define IORESOURCE_IRQ_OPTIONAL              (1<<5)
> > +#define IORESOURCE_IRQ_WAKECAPABLE   (1<<6)
> >
> >  /* PnP DMA specific bits (IORESOURCE_BITS) */
> >  #define IORESOURCE_DMA_TYPE_MASK     (3<<0)
> > --
> > 2.37.3.968.ga6b4b080e4-goog
> >
>
> --
> With Best Regards,
> Andy Shevchenko
>
>

Re: [PATCH v3 07/13] i2c: acpi: Use ACPI wake capability bit to set wake_irq

[Raul Rangel]

On Mon, Sep 19, 2022 at 3:54 AM Andy Shevchenko
<andriy.shevchenko@linux.intel.com> wrote:
>
> On Wed, Sep 14, 2022 at 05:57:55PM -0600, Raul E Rangel wrote:
> > Device tree already has a mechanism to pass the wake_irq. It does this
> > by looking for the wakeup-source property and setting the
> > I2C_CLIENT_WAKE flag. This CL adds the ACPI equivalent. It uses the
> > ACPI interrupt wake flag to determine if the interrupt can be used to
> > wake the system. Previously the i2c drivers had to make assumptions and
> > blindly enable the wake IRQ. This can cause spurious wake events. e.g.,
> > If there is a device with an Active Low interrupt and the device gets
> > powered off while suspending, the interrupt line will go low since it's
> > no longer powered and wakes the system. For this reason we should
> > respect the board designers wishes and honor the wake bit defined on the
> > interrupt.
>
> Okay, let's go with this variant, but I'm afraid that in time we may come up
> to the proposed (generic structure for ACPI IRQ parameters which can be used
> in a few places).
>
> Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
>
> > Signed-off-by: Raul E Rangel <rrangel@chromium.org>
> > ---
> >
> > Changes in v3:
> > - Convert wake_capable to bool
> > - Only update wake_capable pointer once
> > - Move wake_capable local into local block
> >
> > Changes in v2:
> > - Look at wake_cabple bit for IRQ/Interrupt resources
> >
> >  drivers/i2c/i2c-core-acpi.c | 33 ++++++++++++++++++++++++---------
> >  drivers/i2c/i2c-core-base.c |  8 +++++++-
> >  drivers/i2c/i2c-core.h      |  4 ++--
> >  3 files changed, 33 insertions(+), 12 deletions(-)
> >
> > diff --git a/drivers/i2c/i2c-core-acpi.c b/drivers/i2c/i2c-core-acpi.c
> > index c762a879c4cc6b..b3d68a9659ff4f 100644
> > --- a/drivers/i2c/i2c-core-acpi.c
> > +++ b/drivers/i2c/i2c-core-acpi.c
> > @@ -137,6 +137,11 @@ static const struct acpi_device_id i2c_acpi_ignored_device_ids[] = {
> >       {}
> >  };
> >
> > +struct i2c_acpi_irq_context {
> > +     int irq;
> > +     bool wake_capable;
> > +};
> > +
> >  static int i2c_acpi_do_lookup(struct acpi_device *adev,
> >                             struct i2c_acpi_lookup *lookup)
> >  {
> > @@ -170,11 +175,14 @@ static int i2c_acpi_do_lookup(struct acpi_device *adev,
> >
> >  static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
> >  {
> > -     int *irq = data;
> > +     struct i2c_acpi_irq_context *irq_ctx = data;
> >       struct resource r;
> >
> > -     if (*irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r))
> > -             *irq = i2c_dev_irq_from_resources(&r, 1);
> > +     if (irq_ctx->irq <= 0 && acpi_dev_resource_interrupt(ares, 0, &r)) {
> > +             irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
> > +             irq_ctx->wake_capable =
> > +                     !!(r.flags & IORESOURCE_IRQ_WAKECAPABLE);
> > +     }

>
> Maybe
>
>         if (irq_ctx->irq > 0)
>                 return 1;
>
>         if (!acpi_dev_resource_interrupt(ares, 0, &r))
>                 return 1;
>
>         irq_ctx->irq = i2c_dev_irq_from_resources(&r, 1);
>         irq_ctx->wake_capable = !!(r.flags & IORESOURCE_IRQ_WAKECAPABLE);
>
> ?
>
> >       return 1; /* No need to add resource to the list */
> >  }
>

Done

> Also not sure why the callback is not called i2c_acpi_add_irq_resource().
> But it probably can be done in a separate change.
>

I had the same thought. I went ahead and added it into this change
since I already
refactored the logic like you suggested above.

> > @@ -182,31 +190,38 @@ static int i2c_acpi_add_resource(struct acpi_resource *ares, void *data)
> >  /**
> >   * i2c_acpi_get_irq - get device IRQ number from ACPI
> >   * @client: Pointer to the I2C client device
> > + * @wake_capable: Set to true if the IRQ is wake capable
> >   *
> >   * Find the IRQ number used by a specific client device.
> >   *
> >   * Return: The IRQ number or an error code.
> >   */
> > -int i2c_acpi_get_irq(struct i2c_client *client)
> > +int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
> >  {
> >       struct acpi_device *adev = ACPI_COMPANION(&client->dev);
> >       struct list_head resource_list;
> > -     int irq = -ENOENT;
> > +     struct i2c_acpi_irq_context irq_ctx = {
> > +             .irq = -ENOENT,
> > +     };
> >       int ret;
> >
> >       INIT_LIST_HEAD(&resource_list);
> >
> >       ret = acpi_dev_get_resources(adev, &resource_list,
> > -                                  i2c_acpi_add_resource, &irq);
> > +                                  i2c_acpi_add_resource, &irq_ctx);
> >       if (ret < 0)
> >               return ret;
> >
> >       acpi_dev_free_resource_list(&resource_list);
> >
> > -     if (irq == -ENOENT)
> > -             irq = acpi_dev_gpio_irq_get(adev, 0);
> > +     if (irq_ctx.irq == -ENOENT)
> > +             irq_ctx.irq = acpi_dev_gpio_irq_wake_get(adev, 0,
> > +                                                      &irq_ctx.wake_capable);
> > +
> > +     if (wake_capable)
> > +             *wake_capable = irq_ctx.wake_capable;
> >
> > -     return irq;
> > +     return irq_ctx.irq;
> >  }
> >
> >  static int i2c_acpi_get_info(struct acpi_device *adev,
> > diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c
> > index 91007558bcb260..c4debd46c6340f 100644
> > --- a/drivers/i2c/i2c-core-base.c
> > +++ b/drivers/i2c/i2c-core-base.c
> > @@ -487,8 +487,14 @@ static int i2c_device_probe(struct device *dev)
> >                       if (irq == -EINVAL || irq == -ENODATA)
> >                               irq = of_irq_get(dev->of_node, 0);
> >               } else if (ACPI_COMPANION(dev)) {
> > -                     irq = i2c_acpi_get_irq(client);
> > +                     bool wake_capable;
> > +
> > +                     irq = i2c_acpi_get_irq(client, &wake_capable);
>
> > +
>
> Unneeded blank line.
>
Done

> > +                     if (irq > 0 && wake_capable)
> > +                             client->flags |= I2C_CLIENT_WAKE;
> >               }
>
> > +
>
> Ditto. (This even looks like a stray change)
>
Done
> >               if (irq == -EPROBE_DEFER) {
> >                       status = irq;
> >                       goto put_sync_adapter;
> > diff --git a/drivers/i2c/i2c-core.h b/drivers/i2c/i2c-core.h
> > index 87e2c914f1c57b..1247e6e6e97517 100644
> > --- a/drivers/i2c/i2c-core.h
> > +++ b/drivers/i2c/i2c-core.h
> > @@ -61,11 +61,11 @@ static inline int __i2c_check_suspended(struct i2c_adapter *adap)
> >  #ifdef CONFIG_ACPI
> >  void i2c_acpi_register_devices(struct i2c_adapter *adap);
> >
> > -int i2c_acpi_get_irq(struct i2c_client *client);
> > +int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable);
> >  #else /* CONFIG_ACPI */
> >  static inline void i2c_acpi_register_devices(struct i2c_adapter *adap) { }
> >
> > -static inline int i2c_acpi_get_irq(struct i2c_client *client)
> > +static inline int i2c_acpi_get_irq(struct i2c_client *client, bool *wake_capable)
> >  {
> >       return 0;
> >  }
> > --
> > 2.37.3.968.ga6b4b080e4-goog
> >
>
> --
> With Best Regards,
> Andy Shevchenko
>
>

I'll send out a V4 series in a few minutes with all the latest changes.
Thanks!

Re: [PATCH v3 05/13] gpiolib: acpi: Add wake_capable variants of acpi_dev_gpio_irq_get

[kernel test robot]

[-- Attachment #1: Type: text/plain, Size: 9662 bytes --]

BCC: lkp(a)intel.com
CC: kbuild-all(a)lists.01.org
In-Reply-To: <20220914155914.v3.5.I4ff95ba7e884a486d7814ee888bf864be2ebdef4@changeid>
References: <20220914155914.v3.5.I4ff95ba7e884a486d7814ee888bf864be2ebdef4(a)changeid>
TO: Raul E Rangel <rrangel@chromium.org>
TO: linux-acpi(a)vger.kernel.org
TO: linux-input(a)vger.kernel.org
CC: jingle.wu(a)emc.com.tw
CC: rafael(a)kernel.org
CC: andriy.shevchenko(a)linux.intel.com
CC: mario.limonciello(a)amd.com
CC: hdegoede(a)redhat.com
CC: linus.walleij(a)linaro.org
CC: timvp(a)google.com
CC: dmitry.torokhov(a)gmail.com
CC: Raul E Rangel <rrangel@chromium.org>
CC: Bartosz Golaszewski <brgl@bgdev.pl>
CC: Len Brown <lenb@kernel.org>
CC: Mika Westerberg <mika.westerberg@linux.intel.com>
CC: linux-gpio(a)vger.kernel.org
CC: linux-kernel(a)vger.kernel.org

Hi Raul,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on dtor-input/next]
[also build test WARNING on rafael-pm/linux-next linus/master v6.0-rc5 next-20220915]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Raul-E-Rangel/acpi-i2c-Use-SharedAndWake-and-ExclusiveAndWake-to-enable-wake-irq/20220915-080234
base:   https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next
:::::: branch date: 21 hours ago
:::::: commit date: 21 hours ago
config: i386-randconfig-m021 (https://download.01.org/0day-ci/archive/20220916/202209160502.nU0timC5-lkp(a)intel.com/config)
compiler: gcc-11 (Debian 11.3.0-5) 11.3.0

If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <lkp@intel.com>
Reported-by: Dan Carpenter <dan.carpenter@oracle.com>

smatch warnings:
drivers/gpio/gpiolib-acpi.c:1038 acpi_dev_gpio_irq_wake_get_by() warn: passing a valid pointer to 'PTR_ERR'

vim +/PTR_ERR +1038 drivers/gpio/gpiolib-acpi.c

664e3e5ac64c8a Mika Westerberg   2014-01-08   990  
c884fbd452147e Mika Westerberg   2015-05-06   991  /**
454efb6237ff29 Raul E Rangel     2022-09-14   992   * acpi_dev_gpio_irq_wake_get_by() - Find GpioInt and translate it to Linux IRQ
454efb6237ff29 Raul E Rangel     2022-09-14   993   *                                   number
c884fbd452147e Mika Westerberg   2015-05-06   994   * @adev: pointer to a ACPI device to get IRQ from
809390219fb9c2 Andy Shevchenko   2021-02-25   995   * @name: optional name of GpioInt resource
c884fbd452147e Mika Westerberg   2015-05-06   996   * @index: index of GpioInt resource (starting from %0)
454efb6237ff29 Raul E Rangel     2022-09-14   997   * @wake_capable: Set to true if the IRQ is wake capable
c884fbd452147e Mika Westerberg   2015-05-06   998   *
c884fbd452147e Mika Westerberg   2015-05-06   999   * If the device has one or more GpioInt resources, this function can be
c884fbd452147e Mika Westerberg   2015-05-06  1000   * used to translate from the GPIO offset in the resource to the Linux IRQ
c884fbd452147e Mika Westerberg   2015-05-06  1001   * number.
c884fbd452147e Mika Westerberg   2015-05-06  1002   *
a31f5c3a68520e Andy Shevchenko   2017-05-23  1003   * The function is idempotent, though each time it runs it will configure GPIO
a31f5c3a68520e Andy Shevchenko   2017-05-23  1004   * pin direction according to the flags in GpioInt resource.
a31f5c3a68520e Andy Shevchenko   2017-05-23  1005   *
809390219fb9c2 Andy Shevchenko   2021-02-25  1006   * The function takes optional @name parameter. If the resource has a property
809390219fb9c2 Andy Shevchenko   2021-02-25  1007   * name, then only those will be taken into account.
809390219fb9c2 Andy Shevchenko   2021-02-25  1008   *
454efb6237ff29 Raul E Rangel     2022-09-14  1009   * The GPIO is considered wake capable if the GpioInt resource specifies
454efb6237ff29 Raul E Rangel     2022-09-14  1010   * SharedAndWake or ExclusiveAndWake.
454efb6237ff29 Raul E Rangel     2022-09-14  1011   *
c884fbd452147e Mika Westerberg   2015-05-06  1012   * Return: Linux IRQ number (> %0) on success, negative errno on failure.
c884fbd452147e Mika Westerberg   2015-05-06  1013   */
454efb6237ff29 Raul E Rangel     2022-09-14  1014  int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *name,
454efb6237ff29 Raul E Rangel     2022-09-14  1015  				  int index, bool *wake_capable)
c884fbd452147e Mika Westerberg   2015-05-06  1016  {
c884fbd452147e Mika Westerberg   2015-05-06  1017  	int idx, i;
52044723cd27ae Christophe Ricard 2015-12-23  1018  	unsigned int irq_flags;
a31f5c3a68520e Andy Shevchenko   2017-05-23  1019  	int ret;
c884fbd452147e Mika Westerberg   2015-05-06  1020  
c884fbd452147e Mika Westerberg   2015-05-06  1021  	for (i = 0, idx = 0; idx <= index; i++) {
c884fbd452147e Mika Westerberg   2015-05-06  1022  		struct acpi_gpio_info info;
c884fbd452147e Mika Westerberg   2015-05-06  1023  		struct gpio_desc *desc;
c884fbd452147e Mika Westerberg   2015-05-06  1024  
809390219fb9c2 Andy Shevchenko   2021-02-25  1025  		desc = acpi_get_gpiod_by_index(adev, name, i, &info);
6798d7271cb44b Hans de Goede     2017-03-13  1026  
6798d7271cb44b Hans de Goede     2017-03-13  1027  		/* Ignore -EPROBE_DEFER, it only matters if idx matches */
6798d7271cb44b Hans de Goede     2017-03-13  1028  		if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER)
6798d7271cb44b Hans de Goede     2017-03-13  1029  			return PTR_ERR(desc);
6798d7271cb44b Hans de Goede     2017-03-13  1030  
52044723cd27ae Christophe Ricard 2015-12-23  1031  		if (info.gpioint && idx++ == index) {
2d6c06f5a4094a Andy Shevchenko   2019-04-10  1032  			unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
e7b731327aeac9 Andy Shevchenko   2020-11-09  1033  			enum gpiod_flags dflags = GPIOD_ASIS;
a31f5c3a68520e Andy Shevchenko   2017-05-23  1034  			char label[32];
6798d7271cb44b Hans de Goede     2017-03-13  1035  			int irq;
52044723cd27ae Christophe Ricard 2015-12-23  1036  
6798d7271cb44b Hans de Goede     2017-03-13  1037  			if (IS_ERR(desc))
6798d7271cb44b Hans de Goede     2017-03-13 @1038  				return PTR_ERR(desc);
52044723cd27ae Christophe Ricard 2015-12-23  1039  
6798d7271cb44b Hans de Goede     2017-03-13  1040  			irq = gpiod_to_irq(desc);
52044723cd27ae Christophe Ricard 2015-12-23  1041  			if (irq < 0)
52044723cd27ae Christophe Ricard 2015-12-23  1042  				return irq;
52044723cd27ae Christophe Ricard 2015-12-23  1043  
e7b731327aeac9 Andy Shevchenko   2020-11-09  1044  			acpi_gpio_update_gpiod_flags(&dflags, &info);
e7b731327aeac9 Andy Shevchenko   2020-11-09  1045  			acpi_gpio_update_gpiod_lookup_flags(&lflags, &info);
e7b731327aeac9 Andy Shevchenko   2020-11-09  1046  
a31f5c3a68520e Andy Shevchenko   2017-05-23  1047  			snprintf(label, sizeof(label), "GpioInt() %d", index);
e7b731327aeac9 Andy Shevchenko   2020-11-09  1048  			ret = gpiod_configure_flags(desc, label, lflags, dflags);
a31f5c3a68520e Andy Shevchenko   2017-05-23  1049  			if (ret < 0)
a31f5c3a68520e Andy Shevchenko   2017-05-23  1050  				return ret;
a31f5c3a68520e Andy Shevchenko   2017-05-23  1051  
660c619b9d7ccd Andy Shevchenko   2022-03-07  1052  			/* ACPI uses hundredths of milliseconds units */
660c619b9d7ccd Andy Shevchenko   2022-03-07  1053  			ret = gpio_set_debounce_timeout(desc, info.debounce * 10);
8dcb7a15a585b6 Andy Shevchenko   2020-11-09  1054  			if (ret)
8dcb7a15a585b6 Andy Shevchenko   2020-11-09  1055  				return ret;
8dcb7a15a585b6 Andy Shevchenko   2020-11-09  1056  
52044723cd27ae Christophe Ricard 2015-12-23  1057  			irq_flags = acpi_dev_get_irq_type(info.triggering,
52044723cd27ae Christophe Ricard 2015-12-23  1058  							  info.polarity);
52044723cd27ae Christophe Ricard 2015-12-23  1059  
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1060  			/*
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1061  			 * If the IRQ is not already in use then set type
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1062  			 * if specified and different than the current one.
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1063  			 */
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1064  			if (can_request_irq(irq, irq_flags)) {
52044723cd27ae Christophe Ricard 2015-12-23  1065  				if (irq_flags != IRQ_TYPE_NONE &&
52044723cd27ae Christophe Ricard 2015-12-23  1066  				    irq_flags != irq_get_trigger_type(irq))
52044723cd27ae Christophe Ricard 2015-12-23  1067  					irq_set_irq_type(irq, irq_flags);
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1068  			} else {
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1069  				dev_dbg(&adev->dev, "IRQ %d already in use\n", irq);
bdfd6ab8fdccd8 Hans de Goede     2021-11-25  1070  			}
52044723cd27ae Christophe Ricard 2015-12-23  1071  
454efb6237ff29 Raul E Rangel     2022-09-14  1072  			if (wake_capable)
454efb6237ff29 Raul E Rangel     2022-09-14  1073  				*wake_capable = info.wake_capable;
454efb6237ff29 Raul E Rangel     2022-09-14  1074  
52044723cd27ae Christophe Ricard 2015-12-23  1075  			return irq;
52044723cd27ae Christophe Ricard 2015-12-23  1076  		}
52044723cd27ae Christophe Ricard 2015-12-23  1077  
c884fbd452147e Mika Westerberg   2015-05-06  1078  	}
6798d7271cb44b Hans de Goede     2017-03-13  1079  	return -ENOENT;
c884fbd452147e Mika Westerberg   2015-05-06  1080  }
454efb6237ff29 Raul E Rangel     2022-09-14  1081  EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_wake_get_by);
c884fbd452147e Mika Westerberg   2015-05-06  1082  

-- 
0-DAY CI Kernel Test Service
https://01.org/lkp