drivers/platform/chrome/cros_ec_vbc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 // Expose the vboot context nvram to userspace
   3 //
   4 // Copyright (C) 2012 Google, Inc.
   5 // Copyright (C) 2015 Collabora Ltd.
   6
   7 #include <linux/of.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/module.h>
  10 #include <linux/platform_data/cros_ec_commands.h>
  11 #include <linux/platform_data/cros_ec_proto.h>
  12 #include <linux/slab.h>
  13
  14 #define DRV_NAME "cros-ec-vbc"
  15
  16 static ssize_t vboot_context_read(struct file *filp, struct kobject *kobj,
  17                                   struct bin_attribute *att, char *buf,
  18                                   loff_t pos, size_t count)
  19 {
  20         struct device *dev = kobj_to_dev(kobj);
  21         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
  22         struct cros_ec_device *ecdev = ec->ec_dev;
  23         struct cros_ec_command *msg;
  24         /*
  25          * This should be a pointer to the same type as op field in
  26          * struct ec_params_vbnvcontext.
  27          */
  28         uint32_t *params_op;
  29         int err;
  30         const size_t para_sz = sizeof(*params_op);
  31         const size_t resp_sz = sizeof(struct ec_response_vbnvcontext);
  32         const size_t payload = max(para_sz, resp_sz);
  33
  34         msg = kmalloc(sizeof(*msg) + payload, GFP_KERNEL);
  35         if (!msg)
  36                 return -ENOMEM;
  37
  38         /* NB: we only kmalloc()ated enough space for the op field */
  39         params_op = (uint32_t *)msg->data;
  40         *params_op = EC_VBNV_CONTEXT_OP_READ;
  41
  42         msg->version = EC_VER_VBNV_CONTEXT;
  43         msg->command = EC_CMD_VBNV_CONTEXT;
  44         msg->outsize = para_sz;
  45         msg->insize = resp_sz;
  46
  47         err = cros_ec_cmd_xfer_status(ecdev, msg);
  48         if (err < 0) {
  49                 dev_err(dev, "Error sending read request: %d\n", err);
  50                 kfree(msg);
  51                 return err;
  52         }
  53
  54         memcpy(buf, msg->data, resp_sz);
  55
  56         kfree(msg);
  57         return resp_sz;
  58 }
  59
  60 static ssize_t vboot_context_write(struct file *filp, struct kobject *kobj,
  61                                    struct bin_attribute *attr, char *buf,
  62                                    loff_t pos, size_t count)
  63 {
  64         struct device *dev = kobj_to_dev(kobj);
  65         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
  66         struct cros_ec_device *ecdev = ec->ec_dev;
  67         struct ec_params_vbnvcontext *params;
  68         struct cros_ec_command *msg;
  69         int err;
  70         const size_t para_sz = sizeof(*params);
  71         const size_t data_sz = sizeof(params->block);
  72
  73         /* Only write full values */
  74         if (count != data_sz)
  75                 return -EINVAL;
  76
  77         msg = kmalloc(sizeof(*msg) + para_sz, GFP_KERNEL);
  78         if (!msg)
  79                 return -ENOMEM;
  80
  81         params = (struct ec_params_vbnvcontext *)msg->data;
  82         params->op = EC_VBNV_CONTEXT_OP_WRITE;
  83         memcpy(params->block, buf, data_sz);
  84
  85         msg->version = EC_VER_VBNV_CONTEXT;
  86         msg->command = EC_CMD_VBNV_CONTEXT;
  87         msg->outsize = para_sz;
  88         msg->insize = 0;
  89
  90         err = cros_ec_cmd_xfer_status(ecdev, msg);
  91         if (err < 0) {
  92                 dev_err(dev, "Error sending write request: %d\n", err);
  93                 kfree(msg);
  94                 return err;
  95         }
  96
  97         kfree(msg);
  98         return data_sz;
  99 }
 100
 101 static BIN_ATTR_RW(vboot_context, 16);
 102
 103 static struct bin_attribute *cros_ec_vbc_bin_attrs[] = {
 104         &bin_attr_vboot_context,
 105         NULL
 106 };
 107
 108 static const struct attribute_group cros_ec_vbc_attr_group = {
 109         .name = "vbc",
 110         .bin_attrs = cros_ec_vbc_bin_attrs,
 111 };
 112
 113 static int cros_ec_vbc_probe(struct platform_device *pd)
 114 {
 115         struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent);
 116         struct device *dev = &pd->dev;
 117         int ret;
 118
 119         ret = sysfs_create_group(&ec_dev->class_dev.kobj,
 120                                  &cros_ec_vbc_attr_group);
 121         if (ret < 0)
 122                 dev_err(dev, "failed to create %s attributes. err=%d\n",
 123                         cros_ec_vbc_attr_group.name, ret);
 124
 125         return ret;
 126 }
 127
 128 static void cros_ec_vbc_remove(struct platform_device *pd)
 129 {
 130         struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent);
 131
 132         sysfs_remove_group(&ec_dev->class_dev.kobj,
 133                            &cros_ec_vbc_attr_group);
 134 }
 135
 136 static struct platform_driver cros_ec_vbc_driver = {
 137         .driver = {
 138                 .name = DRV_NAME,
 139         },
 140         .probe = cros_ec_vbc_probe,
 141         .remove_new = cros_ec_vbc_remove,
 142 };
 143
 144 module_platform_driver(cros_ec_vbc_driver);
 145
 146 MODULE_LICENSE("GPL");
 147 MODULE_DESCRIPTION("Expose the vboot context nvram to userspace");
 148 MODULE_ALIAS("platform:" DRV_NAME);