mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 05:48:40 +00:00
![Archana Patni](/assets/img/avatar_default.png)
This patch installs an ACPI GPE handler for LID0 ACPI device to indicate ACPI core that this GPE should stay enabled for lid to work in suspend to idle path. Signed-off-by: Archana Patni <archana.patni@intel.com> Signed-off-by: Thierry Escande <thierry.escande@collabora.com> Signed-off-by: Lee Jones <lee.jones@linaro.org>
269 lines
6.5 KiB
C
269 lines
6.5 KiB
C
/*
|
|
* ChromeOS EC multi-function device
|
|
*
|
|
* Copyright (C) 2012 Google, Inc
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* The ChromeOS EC multi function device is used to mux all the requests
|
|
* to the EC device for its multiple features: keyboard controller,
|
|
* battery charging and regulator control, firmware update.
|
|
*/
|
|
|
|
#include <linux/of_platform.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mfd/core.h>
|
|
#include <linux/mfd/cros_ec.h>
|
|
#include <linux/suspend.h>
|
|
#include <asm/unaligned.h>
|
|
|
|
#define CROS_EC_DEV_EC_INDEX 0
|
|
#define CROS_EC_DEV_PD_INDEX 1
|
|
|
|
static struct cros_ec_platform ec_p = {
|
|
.ec_name = CROS_EC_DEV_NAME,
|
|
.cmd_offset = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_EC_INDEX),
|
|
};
|
|
|
|
static struct cros_ec_platform pd_p = {
|
|
.ec_name = CROS_EC_DEV_PD_NAME,
|
|
.cmd_offset = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX),
|
|
};
|
|
|
|
static const struct mfd_cell ec_cell = {
|
|
.name = "cros-ec-ctl",
|
|
.platform_data = &ec_p,
|
|
.pdata_size = sizeof(ec_p),
|
|
};
|
|
|
|
static const struct mfd_cell ec_pd_cell = {
|
|
.name = "cros-ec-ctl",
|
|
.platform_data = &pd_p,
|
|
.pdata_size = sizeof(pd_p),
|
|
};
|
|
|
|
static irqreturn_t ec_irq_thread(int irq, void *data)
|
|
{
|
|
struct cros_ec_device *ec_dev = data;
|
|
int ret;
|
|
|
|
if (device_may_wakeup(ec_dev->dev))
|
|
pm_wakeup_event(ec_dev->dev, 0);
|
|
|
|
ret = cros_ec_get_next_event(ec_dev);
|
|
if (ret > 0)
|
|
blocking_notifier_call_chain(&ec_dev->event_notifier,
|
|
0, ec_dev);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int cros_ec_sleep_event(struct cros_ec_device *ec_dev, u8 sleep_event)
|
|
{
|
|
struct {
|
|
struct cros_ec_command msg;
|
|
struct ec_params_host_sleep_event req;
|
|
} __packed buf;
|
|
|
|
memset(&buf, 0, sizeof(buf));
|
|
|
|
buf.req.sleep_event = sleep_event;
|
|
|
|
buf.msg.command = EC_CMD_HOST_SLEEP_EVENT;
|
|
buf.msg.version = 0;
|
|
buf.msg.outsize = sizeof(buf.req);
|
|
|
|
return cros_ec_cmd_xfer(ec_dev, &buf.msg);
|
|
}
|
|
|
|
int cros_ec_register(struct cros_ec_device *ec_dev)
|
|
{
|
|
struct device *dev = ec_dev->dev;
|
|
int err = 0;
|
|
|
|
BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->event_notifier);
|
|
|
|
ec_dev->max_request = sizeof(struct ec_params_hello);
|
|
ec_dev->max_response = sizeof(struct ec_response_get_protocol_info);
|
|
ec_dev->max_passthru = 0;
|
|
|
|
ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
|
|
if (!ec_dev->din)
|
|
return -ENOMEM;
|
|
|
|
ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
|
|
if (!ec_dev->dout)
|
|
return -ENOMEM;
|
|
|
|
mutex_init(&ec_dev->lock);
|
|
|
|
cros_ec_query_all(ec_dev);
|
|
|
|
if (ec_dev->irq) {
|
|
err = request_threaded_irq(ec_dev->irq, NULL, ec_irq_thread,
|
|
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
|
|
"chromeos-ec", ec_dev);
|
|
if (err) {
|
|
dev_err(dev, "Failed to request IRQ %d: %d",
|
|
ec_dev->irq, err);
|
|
return err;
|
|
}
|
|
}
|
|
|
|
err = mfd_add_devices(ec_dev->dev, PLATFORM_DEVID_AUTO, &ec_cell, 1,
|
|
NULL, ec_dev->irq, NULL);
|
|
if (err) {
|
|
dev_err(dev,
|
|
"Failed to register Embedded Controller subdevice %d\n",
|
|
err);
|
|
goto fail_mfd;
|
|
}
|
|
|
|
if (ec_dev->max_passthru) {
|
|
/*
|
|
* Register a PD device as well on top of this device.
|
|
* We make the following assumptions:
|
|
* - behind an EC, we have a pd
|
|
* - only one device added.
|
|
* - the EC is responsive at init time (it is not true for a
|
|
* sensor hub.
|
|
*/
|
|
err = mfd_add_devices(ec_dev->dev, PLATFORM_DEVID_AUTO,
|
|
&ec_pd_cell, 1, NULL, ec_dev->irq, NULL);
|
|
if (err) {
|
|
dev_err(dev,
|
|
"Failed to register Power Delivery subdevice %d\n",
|
|
err);
|
|
goto fail_mfd;
|
|
}
|
|
}
|
|
|
|
if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
|
|
err = of_platform_populate(dev->of_node, NULL, NULL, dev);
|
|
if (err) {
|
|
mfd_remove_devices(dev);
|
|
dev_err(dev, "Failed to register sub-devices\n");
|
|
goto fail_mfd;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Clear sleep event - this will fail harmlessly on platforms that
|
|
* don't implement the sleep event host command.
|
|
*/
|
|
err = cros_ec_sleep_event(ec_dev, 0);
|
|
if (err < 0)
|
|
dev_dbg(ec_dev->dev, "Error %d clearing sleep event to ec",
|
|
err);
|
|
|
|
dev_info(dev, "Chrome EC device registered\n");
|
|
|
|
cros_ec_acpi_install_gpe_handler(dev);
|
|
|
|
return 0;
|
|
|
|
fail_mfd:
|
|
if (ec_dev->irq)
|
|
free_irq(ec_dev->irq, ec_dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(cros_ec_register);
|
|
|
|
int cros_ec_remove(struct cros_ec_device *ec_dev)
|
|
{
|
|
mfd_remove_devices(ec_dev->dev);
|
|
|
|
cros_ec_acpi_remove_gpe_handler();
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(cros_ec_remove);
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
int cros_ec_suspend(struct cros_ec_device *ec_dev)
|
|
{
|
|
struct device *dev = ec_dev->dev;
|
|
int ret;
|
|
u8 sleep_event;
|
|
|
|
if (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) {
|
|
sleep_event = HOST_SLEEP_EVENT_S3_SUSPEND;
|
|
} else {
|
|
sleep_event = HOST_SLEEP_EVENT_S0IX_SUSPEND;
|
|
|
|
/* Clearing the GPE status for any pending event */
|
|
cros_ec_acpi_clear_gpe();
|
|
}
|
|
|
|
ret = cros_ec_sleep_event(ec_dev, sleep_event);
|
|
if (ret < 0)
|
|
dev_dbg(ec_dev->dev, "Error %d sending suspend event to ec",
|
|
ret);
|
|
|
|
if (device_may_wakeup(dev))
|
|
ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
|
|
|
|
disable_irq(ec_dev->irq);
|
|
ec_dev->was_wake_device = ec_dev->wake_enabled;
|
|
ec_dev->suspended = true;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(cros_ec_suspend);
|
|
|
|
static void cros_ec_drain_events(struct cros_ec_device *ec_dev)
|
|
{
|
|
while (cros_ec_get_next_event(ec_dev) > 0)
|
|
blocking_notifier_call_chain(&ec_dev->event_notifier,
|
|
1, ec_dev);
|
|
}
|
|
|
|
int cros_ec_resume(struct cros_ec_device *ec_dev)
|
|
{
|
|
int ret;
|
|
u8 sleep_event;
|
|
|
|
ec_dev->suspended = false;
|
|
enable_irq(ec_dev->irq);
|
|
|
|
sleep_event = (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) ?
|
|
HOST_SLEEP_EVENT_S3_RESUME :
|
|
HOST_SLEEP_EVENT_S0IX_RESUME;
|
|
|
|
ret = cros_ec_sleep_event(ec_dev, sleep_event);
|
|
if (ret < 0)
|
|
dev_dbg(ec_dev->dev, "Error %d sending resume event to ec",
|
|
ret);
|
|
|
|
/*
|
|
* In some cases, we need to distinguish between events that occur
|
|
* during suspend if the EC is not a wake source. For example,
|
|
* keypresses during suspend should be discarded if it does not wake
|
|
* the system.
|
|
*
|
|
* If the EC is not a wake source, drain the event queue and mark them
|
|
* as "queued during suspend".
|
|
*/
|
|
if (ec_dev->wake_enabled) {
|
|
disable_irq_wake(ec_dev->irq);
|
|
ec_dev->wake_enabled = 0;
|
|
} else {
|
|
cros_ec_drain_events(ec_dev);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(cros_ec_resume);
|
|
|
|
#endif
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("ChromeOS EC core driver");
|