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

Commit d278b7a2 authored by Andres Salomon's avatar Andres Salomon
Browse files

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: default avatarAndres Salomon <dilinger@queued.net>
Acked-by: default avatarPaul Fox <pgf@laptop.org>
Reviewed-by: default avatarThomas Gleixner <tglx@linutronix.de>
parent ac250415

drivers/platform/olpc/olpc-ec.c

+45 −1
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ 
#include <linux/spinlock.h>

#include <linux/mutex.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/workqueue.h>

#include <linux/module.h>

#include <linux/list.h>
@@ -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;

}