drivers/platform/chrome/cros_ec_chardev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Miscellaneous character driver for ChromeOS Embedded Controller
   4  *
   5  * Copyright 2014 Google, Inc.
   6  * Copyright 2019 Google LLC
   7  *
   8  * This file is a rework and part of the code is ported from
   9  * drivers/mfd/cros_ec_dev.c that was originally written by
  10  * Bill Richardson.
  11  */
  12
  13 #include <linux/init.h>
  14 #include <linux/device.h>
  15 #include <linux/fs.h>
  16 #include <linux/mfd/cros_ec.h>
  17 #include <linux/mfd/cros_ec_commands.h>
  18 #include <linux/miscdevice.h>
  19 #include <linux/module.h>
  20 #include <linux/platform_data/cros_ec_chardev.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/slab.h>
  23 #include <linux/types.h>
  24 #include <linux/uaccess.h>
  25
  26 #define DRV_NAME                "cros-ec-chardev"
  27
  28 struct chardev_data {
  29         struct cros_ec_dev *ec_dev;
  30         struct miscdevice misc;
  31 };
  32
  33 static int ec_get_version(struct cros_ec_dev *ec, char *str, int maxlen)
  34 {
  35         static const char * const current_image_name[] = {
  36                 "unknown", "read-only", "read-write", "invalid",
  37         };
  38         struct ec_response_get_version *resp;
  39         struct cros_ec_command *msg;
  40         int ret;
  41
  42         msg = kzalloc(sizeof(*msg) + sizeof(*resp), GFP_KERNEL);
  43         if (!msg)
  44                 return -ENOMEM;
  45
  46         msg->command = EC_CMD_GET_VERSION + ec->cmd_offset;
  47         msg->insize = sizeof(*resp);
  48
  49         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
  50         if (ret < 0) {
  51                 snprintf(str, maxlen,
  52                          "Unknown EC version, returned error: %d\n",
  53                          msg->result);
  54                 goto exit;
  55         }
  56
  57         resp = (struct ec_response_get_version *)msg->data;
  58         if (resp->current_image >= ARRAY_SIZE(current_image_name))
  59                 resp->current_image = 3; /* invalid */
  60
  61         snprintf(str, maxlen, "%s\n%s\n%s\n%s\n", CROS_EC_DEV_VERSION,
  62                  resp->version_string_ro, resp->version_string_rw,
  63                  current_image_name[resp->current_image]);
  64
  65         ret = 0;
  66 exit:
  67         kfree(msg);
  68         return ret;
  69 }
  70
  71 /*
  72  * Device file ops
  73  */
  74 static int cros_ec_chardev_open(struct inode *inode, struct file *filp)
  75 {
  76         struct miscdevice *mdev = filp->private_data;
  77         struct cros_ec_dev *ec_dev = dev_get_drvdata(mdev->parent);
  78
  79         filp->private_data = ec_dev;
  80         nonseekable_open(inode, filp);
  81
  82         return 0;
  83 }
  84
  85 static ssize_t cros_ec_chardev_read(struct file *filp, char __user *buffer,
  86                                      size_t length, loff_t *offset)
  87 {
  88         char msg[sizeof(struct ec_response_get_version) +
  89                  sizeof(CROS_EC_DEV_VERSION)];
  90         struct cros_ec_dev *ec = filp->private_data;
  91         size_t count;
  92         int ret;
  93
  94         if (*offset != 0)
  95                 return 0;
  96
  97         ret = ec_get_version(ec, msg, sizeof(msg));
  98         if (ret)
  99                 return ret;
 100
 101         count = min(length, strlen(msg));
 102
 103         if (copy_to_user(buffer, msg, count))
 104                 return -EFAULT;
 105
 106         *offset = count;
 107         return count;
 108 }
 109
 110 /*
 111  * Ioctls
 112  */
 113 static long cros_ec_chardev_ioctl_xcmd(struct cros_ec_dev *ec, void __user *arg)
 114 {
 115         struct cros_ec_command *s_cmd;
 116         struct cros_ec_command u_cmd;
 117         long ret;
 118
 119         if (copy_from_user(&u_cmd, arg, sizeof(u_cmd)))
 120                 return -EFAULT;
 121
 122         if (u_cmd.outsize > EC_MAX_MSG_BYTES ||
 123             u_cmd.insize > EC_MAX_MSG_BYTES)
 124                 return -EINVAL;
 125
 126         s_cmd = kmalloc(sizeof(*s_cmd) + max(u_cmd.outsize, u_cmd.insize),
 127                         GFP_KERNEL);
 128         if (!s_cmd)
 129                 return -ENOMEM;
 130
 131         if (copy_from_user(s_cmd, arg, sizeof(*s_cmd) + u_cmd.outsize)) {
 132                 ret = -EFAULT;
 133                 goto exit;
 134         }
 135
 136         if (u_cmd.outsize != s_cmd->outsize ||
 137             u_cmd.insize != s_cmd->insize) {
 138                 ret = -EINVAL;
 139                 goto exit;
 140         }
 141
 142         s_cmd->command += ec->cmd_offset;
 143         ret = cros_ec_cmd_xfer(ec->ec_dev, s_cmd);
 144         /* Only copy data to userland if data was received. */
 145         if (ret < 0)
 146                 goto exit;
 147
 148         if (copy_to_user(arg, s_cmd, sizeof(*s_cmd) + s_cmd->insize))
 149                 ret = -EFAULT;
 150 exit:
 151         kfree(s_cmd);
 152         return ret;
 153 }
 154
 155 static long cros_ec_chardev_ioctl_readmem(struct cros_ec_dev *ec,
 156                                            void __user *arg)
 157 {
 158         struct cros_ec_device *ec_dev = ec->ec_dev;
 159         struct cros_ec_readmem s_mem = { };
 160         long num;
 161
 162         /* Not every platform supports direct reads */
 163         if (!ec_dev->cmd_readmem)
 164                 return -ENOTTY;
 165
 166         if (copy_from_user(&s_mem, arg, sizeof(s_mem)))
 167                 return -EFAULT;
 168
 169         num = ec_dev->cmd_readmem(ec_dev, s_mem.offset, s_mem.bytes,
 170                                   s_mem.buffer);
 171         if (num <= 0)
 172                 return num;
 173
 174         if (copy_to_user((void __user *)arg, &s_mem, sizeof(s_mem)))
 175                 return -EFAULT;
 176
 177         return num;
 178 }
 179
 180 static long cros_ec_chardev_ioctl(struct file *filp, unsigned int cmd,
 181                                    unsigned long arg)
 182 {
 183         struct cros_ec_dev *ec = filp->private_data;
 184
 185         if (_IOC_TYPE(cmd) != CROS_EC_DEV_IOC)
 186                 return -ENOTTY;
 187
 188         switch (cmd) {
 189         case CROS_EC_DEV_IOCXCMD:
 190                 return cros_ec_chardev_ioctl_xcmd(ec, (void __user *)arg);
 191         case CROS_EC_DEV_IOCRDMEM:
 192                 return cros_ec_chardev_ioctl_readmem(ec, (void __user *)arg);
 193         }
 194
 195         return -ENOTTY;
 196 }
 197
 198 static const struct file_operations chardev_fops = {
 199         .open           = cros_ec_chardev_open,
 200         .read           = cros_ec_chardev_read,
 201         .unlocked_ioctl = cros_ec_chardev_ioctl,
 202 #ifdef CONFIG_COMPAT
 203         .compat_ioctl   = cros_ec_chardev_ioctl,
 204 #endif
 205 };
 206
 207 static int cros_ec_chardev_probe(struct platform_device *pdev)
 208 {
 209         struct cros_ec_dev *ec_dev = dev_get_drvdata(pdev->dev.parent);
 210         struct cros_ec_platform *ec_platform = dev_get_platdata(ec_dev->dev);
 211         struct chardev_data *data;
 212
 213         /* Create a char device: we want to create it anew */
 214         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 215         if (!data)
 216                 return -ENOMEM;
 217
 218         data->ec_dev = ec_dev;
 219         data->misc.minor = MISC_DYNAMIC_MINOR;
 220         data->misc.fops = &chardev_fops;
 221         data->misc.name = ec_platform->ec_name;
 222         data->misc.parent = pdev->dev.parent;
 223
 224         dev_set_drvdata(&pdev->dev, data);
 225
 226         return misc_register(&data->misc);
 227 }
 228
 229 static int cros_ec_chardev_remove(struct platform_device *pdev)
 230 {
 231         struct chardev_data *data = dev_get_drvdata(&pdev->dev);
 232
 233         misc_deregister(&data->misc);
 234
 235         return 0;
 236 }
 237
 238 static struct platform_driver cros_ec_chardev_driver = {
 239         .driver = {
 240                 .name = DRV_NAME,
 241         },
 242         .probe = cros_ec_chardev_probe,
 243         .remove = cros_ec_chardev_remove,
 244 };
 245
 246 module_platform_driver(cros_ec_chardev_driver);
 247
 248 MODULE_ALIAS("platform:" DRV_NAME);
 249 MODULE_AUTHOR("Enric Balletbo i Serra <enric.balletbo@collabora.com>");
 250 MODULE_DESCRIPTION("ChromeOS EC Miscellaneous Character Driver");
 251 MODULE_LICENSE("GPL");