linux-imx

/*

 * Generic driver for the OLPC Embedded Controller.

 *

 * Author: Andres Salomon <dilinger@queued.net>

 *

 * Copyright (C) 2011-2012 One Laptop per Child Foundation.

 *

 * Licensed under the GPL v2 or later.

 */

#include <linux/completion.h>

#include <linux/debugfs.h>

#include <linux/spinlock.h>

#include <linux/mutex.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/workqueue.h>

#include <linux/init.h>

#include <linux/list.h>

#include <linux/olpc-ec.h>

#include <asm/olpc.h>

​

struct ec_cmd_desc {

    u8 cmd;

    u8 *inbuf, *outbuf;

    size_t inlen, outlen;

​

    int err;

    struct completion finished;

    struct list_head node;

​

    void *priv;

};

​

struct olpc_ec_priv {

    struct olpc_ec_driver *drv;

    struct work_struct worker;

    struct mutex cmd_lock;

​

    /* Pending EC commands */

    struct list_head cmd_q;

    spinlock_t cmd_q_lock;

​

    struct dentry *dbgfs_dir;

​

    /*

     * 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 struct olpc_ec_driver *ec_driver;

static struct olpc_ec_priv *ec_priv;

static void *ec_cb_arg;

​

void olpc_ec_driver_register(struct olpc_ec_driver *drv, void *arg)

{

    ec_driver = drv;

    ec_cb_arg = arg;

}

EXPORT_SYMBOL_GPL(olpc_ec_driver_register);

​

static void olpc_ec_worker(struct work_struct *w)

{

    struct olpc_ec_priv *ec = container_of(w, struct olpc_ec_priv, worker);

    struct ec_cmd_desc *desc = NULL;

    unsigned long flags;

​

    /* Grab the first pending command from the queue */

    spin_lock_irqsave(&ec->cmd_q_lock, flags);

    if (!list_empty(&ec->cmd_q)) {

        desc = list_first_entry(&ec->cmd_q, struct ec_cmd_desc, node);

        list_del(&desc->node);

    }

    spin_unlock_irqrestore(&ec->cmd_q_lock, flags);

​

    /* Do we actually have anything to do? */

    if (!desc)

        return;

​

    /* Protect the EC hw with a mutex; only run one cmd at a time */

    mutex_lock(&ec->cmd_lock);

    desc->err = ec_driver->ec_cmd(desc->cmd, desc->inbuf, desc->inlen,

            desc->outbuf, desc->outlen, ec_cb_arg);

    mutex_unlock(&ec->cmd_lock);

​

    /* Finished, wake up olpc_ec_cmd() */