drivers/mfd/cros_ec.c

   1 /*
   2  * ChromeOS EC multi-function device
   3  *
   4  * Copyright (C) 2012 Google, Inc
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * The ChromeOS EC multi function device is used to mux all the requests
  16  * to the EC device for its multiple features: keyboard controller,
  17  * battery charging and regulator control, firmware update.
  18  */
  19
  20 #include <linux/interrupt.h>
  21 #include <linux/slab.h>
  22 #include <linux/module.h>
  23 #include <linux/mfd/core.h>
  24 #include <linux/mfd/cros_ec.h>
  25 #include <linux/mfd/cros_ec_commands.h>
  26
  27 int cros_ec_prepare_tx(struct cros_ec_device *ec_dev,
  28                        struct cros_ec_msg *msg)
  29 {
  30         uint8_t *out;
  31         int csum, i;
  32
  33         BUG_ON(msg->out_len > EC_HOST_PARAM_SIZE);
  34         out = ec_dev->dout;
  35         out[0] = EC_CMD_VERSION0 + msg->version;
  36         out[1] = msg->cmd;
  37         out[2] = msg->out_len;
  38         csum = out[0] + out[1] + out[2];
  39         for (i = 0; i < msg->out_len; i++)
  40                 csum += out[EC_MSG_TX_HEADER_BYTES + i] = msg->out_buf[i];
  41         out[EC_MSG_TX_HEADER_BYTES + msg->out_len] = (uint8_t)(csum & 0xff);
  42
  43         return EC_MSG_TX_PROTO_BYTES + msg->out_len;
  44 }
  45 EXPORT_SYMBOL(cros_ec_prepare_tx);
  46
  47 static int cros_ec_command_sendrecv(struct cros_ec_device *ec_dev,
  48                 uint16_t cmd, void *out_buf, int out_len,
  49                 void *in_buf, int in_len)
  50 {
  51         struct cros_ec_msg msg;
  52
  53         msg.version = cmd >> 8;
  54         msg.cmd = cmd & 0xff;
  55         msg.out_buf = out_buf;
  56         msg.out_len = out_len;
  57         msg.in_buf = in_buf;
  58         msg.in_len = in_len;
  59
  60         return ec_dev->command_xfer(ec_dev, &msg);
  61 }
  62
  63 static int cros_ec_command_recv(struct cros_ec_device *ec_dev,
  64                 uint16_t cmd, void *buf, int buf_len)
  65 {
  66         return cros_ec_command_sendrecv(ec_dev, cmd, NULL, 0, buf, buf_len);
  67 }
  68
  69 static int cros_ec_command_send(struct cros_ec_device *ec_dev,
  70                 uint16_t cmd, void *buf, int buf_len)
  71 {
  72         return cros_ec_command_sendrecv(ec_dev, cmd, buf, buf_len, NULL, 0);
  73 }
  74
  75 static irqreturn_t ec_irq_thread(int irq, void *data)
  76 {
  77         struct cros_ec_device *ec_dev = data;
  78
  79         if (device_may_wakeup(ec_dev->dev))
  80                 pm_wakeup_event(ec_dev->dev, 0);
  81
  82         blocking_notifier_call_chain(&ec_dev->event_notifier, 1, ec_dev);
  83
  84         return IRQ_HANDLED;
  85 }
  86
  87 static struct mfd_cell cros_devs[] = {
  88         {
  89                 .name = "cros-ec-keyb",
  90                 .id = 1,
  91                 .of_compatible = "google,cros-ec-keyb",
  92         },
  93 };
  94
  95 int cros_ec_register(struct cros_ec_device *ec_dev)
  96 {
  97         struct device *dev = ec_dev->dev;
  98         int err = 0;
  99
 100         BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->event_notifier);
 101
 102         ec_dev->command_send = cros_ec_command_send;
 103         ec_dev->command_recv = cros_ec_command_recv;
 104         ec_dev->command_sendrecv = cros_ec_command_sendrecv;
 105
 106         if (ec_dev->din_size) {
 107                 ec_dev->din = kmalloc(ec_dev->din_size, GFP_KERNEL);
 108                 if (!ec_dev->din) {
 109                         err = -ENOMEM;
 110                         goto fail_din;
 111                 }
 112         }
 113         if (ec_dev->dout_size) {
 114                 ec_dev->dout = kmalloc(ec_dev->dout_size, GFP_KERNEL);
 115                 if (!ec_dev->dout) {
 116                         err = -ENOMEM;
 117                         goto fail_dout;
 118                 }
 119         }
 120
 121         if (!ec_dev->irq) {
 122                 dev_dbg(dev, "no valid IRQ: %d\n", ec_dev->irq);
 123                 goto fail_irq;
 124         }
 125
 126         err = request_threaded_irq(ec_dev->irq, NULL, ec_irq_thread,
 127                                    IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 128                                    "chromeos-ec", ec_dev);
 129         if (err) {
 130                 dev_err(dev, "request irq %d: error %d\n", ec_dev->irq, err);
 131                 goto fail_irq;
 132         }
 133
 134         err = mfd_add_devices(dev, 0, cros_devs,
 135                               ARRAY_SIZE(cros_devs),
 136                               NULL, ec_dev->irq, NULL);
 137         if (err) {
 138                 dev_err(dev, "failed to add mfd devices\n");
 139                 goto fail_mfd;
 140         }
 141
 142         dev_info(dev, "Chrome EC (%s)\n", ec_dev->name);
 143
 144         return 0;
 145
 146 fail_mfd:
 147         free_irq(ec_dev->irq, ec_dev);
 148 fail_irq:
 149         kfree(ec_dev->dout);
 150 fail_dout:
 151         kfree(ec_dev->din);
 152 fail_din:
 153         return err;
 154 }
 155 EXPORT_SYMBOL(cros_ec_register);
 156
 157 int cros_ec_remove(struct cros_ec_device *ec_dev)
 158 {
 159         mfd_remove_devices(ec_dev->dev);
 160         free_irq(ec_dev->irq, ec_dev);
 161         kfree(ec_dev->dout);
 162         kfree(ec_dev->din);
 163
 164         return 0;
 165 }
 166 EXPORT_SYMBOL(cros_ec_remove);
 167
 168 #ifdef CONFIG_PM_SLEEP
 169 int cros_ec_suspend(struct cros_ec_device *ec_dev)
 170 {
 171         struct device *dev = ec_dev->dev;
 172
 173         if (device_may_wakeup(dev))
 174                 ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
 175
 176         disable_irq(ec_dev->irq);
 177         ec_dev->was_wake_device = ec_dev->wake_enabled;
 178
 179         return 0;
 180 }
 181 EXPORT_SYMBOL(cros_ec_suspend);
 182
 183 int cros_ec_resume(struct cros_ec_device *ec_dev)
 184 {
 185         enable_irq(ec_dev->irq);
 186
 187         if (ec_dev->wake_enabled) {
 188                 disable_irq_wake(ec_dev->irq);
 189                 ec_dev->wake_enabled = 0;
 190         }
 191
 192         return 0;
 193 }
 194 EXPORT_SYMBOL(cros_ec_resume);
 195
 196 #endif