From: Andres Salomon Date: Fri, 13 Jul 2012 22:54:25 +0000 (-0700) Subject: Platform: OLPC: add a suspended flag to the EC driver X-Git-Url: https://git.stricted.de/?a=commitdiff_plain;h=d278b7a2f90f91f908b19b50cfa59e10632b5afc;p=GitHub%2FLineageOS%2FG12%2Fandroid_kernel_amlogic_linux-4.9.git Platform: OLPC: add a suspended flag to the EC driver A problem we've noticed on XO-1.75 is when we suspend in the middle of an EC command. Don't allow that. In the process, create a private object for the generic EC driver to use; we have a framework for passing around a struct, use that rather than a proliferation of global variables. Signed-off-by: Andres Salomon Acked-by: Paul Fox Reviewed-by: Thomas Gleixner --- diff --git a/drivers/platform/olpc/olpc-ec.c b/drivers/platform/olpc/olpc-ec.c index d00523c65191..cfba41fb04de 100644 --- a/drivers/platform/olpc/olpc-ec.c +++ b/drivers/platform/olpc/olpc-ec.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -27,6 +28,21 @@ struct ec_cmd_desc { void *priv; }; +struct olpc_ec_priv { + struct olpc_ec_driver *drv; + + /* + * Running an EC command while suspending means we don't always finish + * the command before the machine suspends. This means that the EC + * is expecting the command protocol to finish, but we after a period + * of time (while the OS is asleep) the EC times out and restarts its + * idle loop. Meanwhile, the OS wakes up, thinks it's still in the + * middle of the command protocol, starts throwing random things at + * the EC... and everyone's uphappy. + */ + bool suspended; +}; + static void olpc_ec_worker(struct work_struct *w); static DECLARE_WORK(ec_worker, olpc_ec_worker); @@ -34,6 +50,7 @@ static LIST_HEAD(ec_cmd_q); static DEFINE_SPINLOCK(ec_cmd_q_lock); static struct olpc_ec_driver *ec_driver; +static struct olpc_ec_priv *ec_priv; static void *ec_cb_arg; static DEFINE_MUTEX(ec_cb_lock); @@ -93,6 +110,7 @@ static void queue_ec_descriptor(struct ec_cmd_desc *desc) int olpc_ec_cmd(u8 cmd, u8 *inbuf, size_t inlen, u8 *outbuf, size_t outlen) { + struct olpc_ec_priv *ec = ec_priv; struct ec_cmd_desc desc; /* XXX: this will be removed in later patches */ @@ -104,6 +122,13 @@ int olpc_ec_cmd(u8 cmd, u8 *inbuf, size_t inlen, u8 *outbuf, size_t outlen) if (WARN_ON(!ec_driver || !ec_driver->ec_cmd)) return -ENODEV; + if (!ec) + return -ENOMEM; + + /* Suspending in the middle of a command hoses things really badly */ + if (WARN_ON(ec->suspended)) + return -EBUSY; + might_sleep(); desc.cmd = cmd; @@ -126,11 +151,19 @@ EXPORT_SYMBOL_GPL(olpc_ec_cmd); static int olpc_ec_probe(struct platform_device *pdev) { + struct olpc_ec_priv *ec; int err; if (!ec_driver) return -ENODEV; + ec = kzalloc(sizeof(*ec), GFP_KERNEL); + if (!ec) + return -ENOMEM; + ec->drv = ec_driver; + ec_priv = ec; + platform_set_drvdata(pdev, ec); + err = ec_driver->probe ? ec_driver->probe(pdev) : 0; return err; @@ -139,12 +172,23 @@ static int olpc_ec_probe(struct platform_device *pdev) static int olpc_ec_suspend(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); - return ec_driver->suspend ? ec_driver->suspend(pdev) : 0; + struct olpc_ec_priv *ec = platform_get_drvdata(pdev); + int err = 0; + + if (ec_driver->suspend) + err = ec_driver->suspend(pdev); + if (!err) + ec->suspended = true; + + return err; } static int olpc_ec_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); + struct olpc_ec_priv *ec = platform_get_drvdata(pdev); + + ec->suspended = false; return ec_driver->resume ? ec_driver->resume(pdev) : 0; }