drivers/platform/chrome/cros_ec_sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 // Expose the ChromeOS EC through sysfs
   3 //
   4 // Copyright (C) 2014 Google, Inc.
   5
   6 #include <linux/ctype.h>
   7 #include <linux/delay.h>
   8 #include <linux/device.h>
   9 #include <linux/fs.h>
  10 #include <linux/kobject.h>
  11 #include <linux/mod_devicetable.h>
  12 #include <linux/module.h>
  13 #include <linux/platform_data/cros_ec_commands.h>
  14 #include <linux/platform_data/cros_ec_proto.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/printk.h>
  17 #include <linux/slab.h>
  18 #include <linux/stat.h>
  19 #include <linux/types.h>
  20 #include <linux/uaccess.h>
  21
  22 #define DRV_NAME "cros-ec-sysfs"
  23
  24 /* Accessor functions */
  25
  26 static ssize_t reboot_show(struct device *dev,
  27                            struct device_attribute *attr, char *buf)
  28 {
  29         int count = 0;
  30
  31         count += sysfs_emit_at(buf, count,
  32                                "ro|rw|cancel|cold|disable-jump|hibernate|cold-ap-off");
  33         count += sysfs_emit_at(buf, count, " [at-shutdown]\n");
  34         return count;
  35 }
  36
  37 static ssize_t reboot_store(struct device *dev,
  38                             struct device_attribute *attr,
  39                             const char *buf, size_t count)
  40 {
  41         static const struct {
  42                 const char * const str;
  43                 uint8_t cmd;
  44                 uint8_t flags;
  45         } words[] = {
  46                 {"cancel",       EC_REBOOT_CANCEL, 0},
  47                 {"ro",           EC_REBOOT_JUMP_RO, 0},
  48                 {"rw",           EC_REBOOT_JUMP_RW, 0},
  49                 {"cold-ap-off",  EC_REBOOT_COLD_AP_OFF, 0},
  50                 {"cold",         EC_REBOOT_COLD, 0},
  51                 {"disable-jump", EC_REBOOT_DISABLE_JUMP, 0},
  52                 {"hibernate",    EC_REBOOT_HIBERNATE, 0},
  53                 {"at-shutdown",  -1, EC_REBOOT_FLAG_ON_AP_SHUTDOWN},
  54         };
  55         struct cros_ec_command *msg;
  56         struct ec_params_reboot_ec *param;
  57         int got_cmd = 0, offset = 0;
  58         int i;
  59         int ret;
  60         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
  61
  62         msg = kmalloc(sizeof(*msg) + sizeof(*param), GFP_KERNEL);
  63         if (!msg)
  64                 return -ENOMEM;
  65
  66         param = (struct ec_params_reboot_ec *)msg->data;
  67
  68         param->flags = 0;
  69         while (1) {
  70                 /* Find word to start scanning */
  71                 while (buf[offset] && isspace(buf[offset]))
  72                         offset++;
  73                 if (!buf[offset])
  74                         break;
  75
  76                 for (i = 0; i < ARRAY_SIZE(words); i++) {
  77                         if (!strncasecmp(words[i].str, buf+offset,
  78                                          strlen(words[i].str))) {
  79                                 if (words[i].flags) {
  80                                         param->flags |= words[i].flags;
  81                                 } else {
  82                                         param->cmd = words[i].cmd;
  83                                         got_cmd = 1;
  84                                 }
  85                                 break;
  86                         }
  87                 }
  88
  89                 /* On to the next word, if any */
  90                 while (buf[offset] && !isspace(buf[offset]))
  91                         offset++;
  92         }
  93
  94         if (!got_cmd) {
  95                 count = -EINVAL;
  96                 goto exit;
  97         }
  98
  99         msg->version = 0;
 100         msg->command = EC_CMD_REBOOT_EC + ec->cmd_offset;
 101         msg->outsize = sizeof(*param);
 102         msg->insize = 0;
 103         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 104         if (ret < 0)
 105                 count = ret;
 106 exit:
 107         kfree(msg);
 108         return count;
 109 }
 110
 111 static ssize_t version_show(struct device *dev,
 112                             struct device_attribute *attr, char *buf)
 113 {
 114         static const char * const image_names[] = {"unknown", "RO", "RW"};
 115         struct ec_response_get_version *r_ver;
 116         struct ec_response_get_chip_info *r_chip;
 117         struct ec_response_board_version *r_board;
 118         struct cros_ec_command *msg;
 119         int ret;
 120         int count = 0;
 121         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
 122
 123         msg = kmalloc(sizeof(*msg) + EC_HOST_PARAM_SIZE, GFP_KERNEL);
 124         if (!msg)
 125                 return -ENOMEM;
 126
 127         /* Get versions. RW may change. */
 128         msg->version = 0;
 129         msg->command = EC_CMD_GET_VERSION + ec->cmd_offset;
 130         msg->insize = sizeof(*r_ver);
 131         msg->outsize = 0;
 132         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 133         if (ret < 0) {
 134                 count = ret;
 135                 goto exit;
 136         }
 137         r_ver = (struct ec_response_get_version *)msg->data;
 138         /* Strings should be null-terminated, but let's be sure. */
 139         r_ver->version_string_ro[sizeof(r_ver->version_string_ro) - 1] = '\0';
 140         r_ver->version_string_rw[sizeof(r_ver->version_string_rw) - 1] = '\0';
 141         count += sysfs_emit_at(buf, count, "RO version:    %s\n", r_ver->version_string_ro);
 142         count += sysfs_emit_at(buf, count, "RW version:    %s\n", r_ver->version_string_rw);
 143         count += sysfs_emit_at(buf, count, "Firmware copy: %s\n",
 144                            (r_ver->current_image < ARRAY_SIZE(image_names) ?
 145                             image_names[r_ver->current_image] : "?"));
 146
 147         /* Get build info. */
 148         msg->command = EC_CMD_GET_BUILD_INFO + ec->cmd_offset;
 149         msg->insize = EC_HOST_PARAM_SIZE;
 150         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 151         if (ret < 0) {
 152                 count += sysfs_emit_at(buf, count,
 153                                    "Build info:    XFER / EC ERROR %d / %d\n",
 154                                    ret, msg->result);
 155         } else {
 156                 msg->data[EC_HOST_PARAM_SIZE - 1] = '\0';
 157                 count += sysfs_emit_at(buf, count, "Build info:    %s\n", msg->data);
 158         }
 159
 160         /* Get chip info. */
 161         msg->command = EC_CMD_GET_CHIP_INFO + ec->cmd_offset;
 162         msg->insize = sizeof(*r_chip);
 163         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 164         if (ret < 0) {
 165                 count += sysfs_emit_at(buf, count,
 166                                    "Chip info:     XFER / EC ERROR %d / %d\n",
 167                                    ret, msg->result);
 168         } else {
 169                 r_chip = (struct ec_response_get_chip_info *)msg->data;
 170
 171                 r_chip->vendor[sizeof(r_chip->vendor) - 1] = '\0';
 172                 r_chip->name[sizeof(r_chip->name) - 1] = '\0';
 173                 r_chip->revision[sizeof(r_chip->revision) - 1] = '\0';
 174                 count += sysfs_emit_at(buf, count, "Chip vendor:   %s\n", r_chip->vendor);
 175                 count += sysfs_emit_at(buf, count, "Chip name:     %s\n", r_chip->name);
 176                 count += sysfs_emit_at(buf, count, "Chip revision: %s\n", r_chip->revision);
 177         }
 178
 179         /* Get board version */
 180         msg->command = EC_CMD_GET_BOARD_VERSION + ec->cmd_offset;
 181         msg->insize = sizeof(*r_board);
 182         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 183         if (ret < 0) {
 184                 count += sysfs_emit_at(buf, count,
 185                                    "Board version: XFER / EC ERROR %d / %d\n",
 186                                    ret, msg->result);
 187         } else {
 188                 r_board = (struct ec_response_board_version *)msg->data;
 189
 190                 count += sysfs_emit_at(buf, count,
 191                                    "Board version: %d\n",
 192                                    r_board->board_version);
 193         }
 194
 195 exit:
 196         kfree(msg);
 197         return count;
 198 }
 199
 200 static ssize_t flashinfo_show(struct device *dev,
 201                               struct device_attribute *attr, char *buf)
 202 {
 203         struct ec_response_flash_info *resp;
 204         struct cros_ec_command *msg;
 205         int ret;
 206         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
 207
 208         msg = kmalloc(sizeof(*msg) + sizeof(*resp), GFP_KERNEL);
 209         if (!msg)
 210                 return -ENOMEM;
 211
 212         /* The flash info shouldn't ever change, but ask each time anyway. */
 213         msg->version = 0;
 214         msg->command = EC_CMD_FLASH_INFO + ec->cmd_offset;
 215         msg->insize = sizeof(*resp);
 216         msg->outsize = 0;
 217         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 218         if (ret < 0)
 219                 goto exit;
 220
 221         resp = (struct ec_response_flash_info *)msg->data;
 222
 223         ret = sysfs_emit(buf,
 224                         "FlashSize %d\nWriteSize %d\n"
 225                         "EraseSize %d\nProtectSize %d\n",
 226                         resp->flash_size, resp->write_block_size,
 227                         resp->erase_block_size, resp->protect_block_size);
 228 exit:
 229         kfree(msg);
 230         return ret;
 231 }
 232
 233 /* Keyboard wake angle control */
 234 static ssize_t kb_wake_angle_show(struct device *dev,
 235                                   struct device_attribute *attr, char *buf)
 236 {
 237         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
 238         struct ec_response_motion_sense *resp;
 239         struct ec_params_motion_sense *param;
 240         struct cros_ec_command *msg;
 241         int ret;
 242
 243         msg = kmalloc(sizeof(*msg) + EC_HOST_PARAM_SIZE, GFP_KERNEL);
 244         if (!msg)
 245                 return -ENOMEM;
 246
 247         param = (struct ec_params_motion_sense *)msg->data;
 248         msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset;
 249         msg->version = 2;
 250         param->cmd = MOTIONSENSE_CMD_KB_WAKE_ANGLE;
 251         param->kb_wake_angle.data = EC_MOTION_SENSE_NO_VALUE;
 252         msg->outsize = sizeof(*param);
 253         msg->insize = sizeof(*resp);
 254
 255         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 256         if (ret < 0)
 257                 goto exit;
 258
 259         resp = (struct ec_response_motion_sense *)msg->data;
 260         ret = sysfs_emit(buf, "%d\n", resp->kb_wake_angle.ret);
 261 exit:
 262         kfree(msg);
 263         return ret;
 264 }
 265
 266 static ssize_t kb_wake_angle_store(struct device *dev,
 267                                    struct device_attribute *attr,
 268                                    const char *buf, size_t count)
 269 {
 270         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
 271         struct ec_params_motion_sense *param;
 272         struct cros_ec_command *msg;
 273         u16 angle;
 274         int ret;
 275
 276         ret = kstrtou16(buf, 0, &angle);
 277         if (ret)
 278                 return ret;
 279
 280         msg = kmalloc(sizeof(*msg) + EC_HOST_PARAM_SIZE, GFP_KERNEL);
 281         if (!msg)
 282                 return -ENOMEM;
 283
 284         param = (struct ec_params_motion_sense *)msg->data;
 285         msg->command = EC_CMD_MOTION_SENSE_CMD + ec->cmd_offset;
 286         msg->version = 2;
 287         param->cmd = MOTIONSENSE_CMD_KB_WAKE_ANGLE;
 288         param->kb_wake_angle.data = angle;
 289         msg->outsize = sizeof(*param);
 290         msg->insize = sizeof(struct ec_response_motion_sense);
 291
 292         ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
 293         kfree(msg);
 294         if (ret < 0)
 295                 return ret;
 296         return count;
 297 }
 298
 299 /* Module initialization */
 300
 301 static DEVICE_ATTR_RW(reboot);
 302 static DEVICE_ATTR_RO(version);
 303 static DEVICE_ATTR_RO(flashinfo);
 304 static DEVICE_ATTR_RW(kb_wake_angle);
 305
 306 static struct attribute *__ec_attrs[] = {
 307         &dev_attr_kb_wake_angle.attr,
 308         &dev_attr_reboot.attr,
 309         &dev_attr_version.attr,
 310         &dev_attr_flashinfo.attr,
 311         NULL,
 312 };
 313
 314 static umode_t cros_ec_ctrl_visible(struct kobject *kobj,
 315                                     struct attribute *a, int n)
 316 {
 317         struct device *dev = kobj_to_dev(kobj);
 318         struct cros_ec_dev *ec = to_cros_ec_dev(dev);
 319
 320         if (a == &dev_attr_kb_wake_angle.attr && !ec->has_kb_wake_angle)
 321                 return 0;
 322
 323         return a->mode;
 324 }
 325
 326 static const struct attribute_group cros_ec_attr_group = {
 327         .attrs = __ec_attrs,
 328         .is_visible = cros_ec_ctrl_visible,
 329 };
 330
 331 static int cros_ec_sysfs_probe(struct platform_device *pd)
 332 {
 333         struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent);
 334         struct device *dev = &pd->dev;
 335         int ret;
 336
 337         ret = sysfs_create_group(&ec_dev->class_dev.kobj, &cros_ec_attr_group);
 338         if (ret < 0)
 339                 dev_err(dev, "failed to create attributes. err=%d\n", ret);
 340
 341         return ret;
 342 }
 343
 344 static void cros_ec_sysfs_remove(struct platform_device *pd)
 345 {
 346         struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent);
 347
 348         sysfs_remove_group(&ec_dev->class_dev.kobj, &cros_ec_attr_group);
 349 }
 350
 351 static const struct platform_device_id cros_ec_sysfs_id[] = {
 352         { DRV_NAME, 0 },
 353         {}
 354 };
 355 MODULE_DEVICE_TABLE(platform, cros_ec_sysfs_id);
 356
 357 static struct platform_driver cros_ec_sysfs_driver = {
 358         .driver = {
 359                 .name = DRV_NAME,
 360         },
 361         .probe = cros_ec_sysfs_probe,
 362         .remove_new = cros_ec_sysfs_remove,
 363         .id_table = cros_ec_sysfs_id,
 364 };
 365
 366 module_platform_driver(cros_ec_sysfs_driver);
 367
 368 MODULE_LICENSE("GPL");
 369 MODULE_DESCRIPTION("Expose the ChromeOS EC through sysfs");