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_command *msg)
  29 {
  30         uint8_t *out;
  31         int csum, i;
  32
  33         BUG_ON(msg->outsize > EC_PROTO2_MAX_PARAM_SIZE);
  34         out = ec_dev->dout;
  35         out[0] = EC_CMD_VERSION0 + msg->version;
  36         out[1] = msg->command;
  37         out[2] = msg->outsize;
  38         csum = out[0] + out[1] + out[2];
  39         for (i = 0; i < msg->outsize; i++)
  40                 csum += out[EC_MSG_TX_HEADER_BYTES + i] = msg->outdata[i];
  41         out[EC_MSG_TX_HEADER_BYTES + msg->outsize] = (uint8_t)(csum & 0xff);
  42
  43         return EC_MSG_TX_PROTO_BYTES + msg->outsize;
  44 }
  45 EXPORT_SYMBOL(cros_ec_prepare_tx);
  46
  47 int cros_ec_check_result(struct cros_ec_device *ec_dev,
  48                          struct cros_ec_command *msg)
  49 {
  50         switch (msg->result) {
  51         case EC_RES_SUCCESS:
  52                 return 0;
  53         case EC_RES_IN_PROGRESS:
  54                 dev_dbg(ec_dev->dev, "command 0x%02x in progress\n",
  55                         msg->command);
  56                 return -EAGAIN;
  57         default:
  58                 dev_dbg(ec_dev->dev, "command 0x%02x returned %d\n",
  59                         msg->command, msg->result);
  60                 return 0;
  61         }
  62 }
  63 EXPORT_SYMBOL(cros_ec_check_result);
  64
  65 int cros_ec_cmd_xfer(struct cros_ec_device *ec_dev,
  66                      struct cros_ec_command *msg)
  67 {
  68         return ec_dev->cmd_xfer(ec_dev, msg);
  69 }
  70 EXPORT_SYMBOL(cros_ec_cmd_xfer);
  71
  72 static const struct mfd_cell cros_devs[] = {
  73         {
  74                 .name = "cros-ec-keyb",
  75                 .id = 1,
  76                 .of_compatible = "google,cros-ec-keyb",
  77         },
  78         {
  79                 .name = "cros-ec-i2c-tunnel",
  80                 .id = 2,
  81                 .of_compatible = "google,cros-ec-i2c-tunnel",
  82         },
  83 };
  84
  85 int cros_ec_register(struct cros_ec_device *ec_dev)
  86 {
  87         struct device *dev = ec_dev->dev;
  88         int err = 0;
  89
  90         if (ec_dev->din_size) {
  91                 ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
  92                 if (!ec_dev->din)
  93                         return -ENOMEM;
  94         }
  95         if (ec_dev->dout_size) {
  96                 ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
  97                 if (!ec_dev->dout)
  98                         return -ENOMEM;
  99         }
 100
 101         err = mfd_add_devices(dev, 0, cros_devs,
 102                               ARRAY_SIZE(cros_devs),
 103                               NULL, ec_dev->irq, NULL);
 104         if (err) {
 105                 dev_err(dev, "failed to add mfd devices\n");
 106                 return err;
 107         }
 108
 109         dev_info(dev, "Chrome EC device registered\n");
 110
 111         return 0;
 112 }
 113 EXPORT_SYMBOL(cros_ec_register);
 114
 115 int cros_ec_remove(struct cros_ec_device *ec_dev)
 116 {
 117         mfd_remove_devices(ec_dev->dev);
 118
 119         return 0;
 120 }
 121 EXPORT_SYMBOL(cros_ec_remove);
 122
 123 #ifdef CONFIG_PM_SLEEP
 124 int cros_ec_suspend(struct cros_ec_device *ec_dev)
 125 {
 126         struct device *dev = ec_dev->dev;
 127
 128         if (device_may_wakeup(dev))
 129                 ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
 130
 131         disable_irq(ec_dev->irq);
 132         ec_dev->was_wake_device = ec_dev->wake_enabled;
 133
 134         return 0;
 135 }
 136 EXPORT_SYMBOL(cros_ec_suspend);
 137
 138 int cros_ec_resume(struct cros_ec_device *ec_dev)
 139 {
 140         enable_irq(ec_dev->irq);
 141
 142         if (ec_dev->wake_enabled) {
 143                 disable_irq_wake(ec_dev->irq);
 144                 ec_dev->wake_enabled = 0;
 145         }
 146
 147         return 0;
 148 }
 149 EXPORT_SYMBOL(cros_ec_resume);
 150
 151 #endif
 152
 153 MODULE_LICENSE("GPL");
 154 MODULE_DESCRIPTION("ChromeOS EC core driver");