drivers/remoteproc/remoteproc_sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Remote Processor Framework
   4  */
   5
   6 #include <linux/remoteproc.h>
   7 #include <linux/slab.h>
   8
   9 #include "remoteproc_internal.h"
  10
  11 #define to_rproc(d) container_of(d, struct rproc, dev)
  12
  13 /* Expose the loaded / running firmware name via sysfs */
  14 static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
  15                           char *buf)
  16 {
  17         struct rproc *rproc = to_rproc(dev);
  18
  19         return sprintf(buf, "%s\n", rproc->firmware);
  20 }
  21
  22 /* Change firmware name via sysfs */
  23 static ssize_t firmware_store(struct device *dev,
  24                               struct device_attribute *attr,
  25                               const char *buf, size_t count)
  26 {
  27         struct rproc *rproc = to_rproc(dev);
  28         char *p;
  29         int err, len = count;
  30
  31         err = mutex_lock_interruptible(&rproc->lock);
  32         if (err) {
  33                 dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, err);
  34                 return -EINVAL;
  35         }
  36
  37         if (rproc->state != RPROC_OFFLINE) {
  38                 dev_err(dev, "can't change firmware while running\n");
  39                 err = -EBUSY;
  40                 goto out;
  41         }
  42
  43         len = strcspn(buf, "\n");
  44         if (!len) {
  45                 dev_err(dev, "can't provide a NULL firmware\n");
  46                 err = -EINVAL;
  47                 goto out;
  48         }
  49
  50         p = kstrndup(buf, len, GFP_KERNEL);
  51         if (!p) {
  52                 err = -ENOMEM;
  53                 goto out;
  54         }
  55
  56         kfree(rproc->firmware);
  57         rproc->firmware = p;
  58 out:
  59         mutex_unlock(&rproc->lock);
  60
  61         return err ? err : count;
  62 }
  63 static DEVICE_ATTR_RW(firmware);
  64
  65 /*
  66  * A state-to-string lookup table, for exposing a human readable state
  67  * via sysfs. Always keep in sync with enum rproc_state
  68  */
  69 static const char * const rproc_state_string[] = {
  70         [RPROC_OFFLINE]         = "offline",
  71         [RPROC_SUSPENDED]       = "suspended",
  72         [RPROC_RUNNING]         = "running",
  73         [RPROC_CRASHED]         = "crashed",
  74         [RPROC_DELETED]         = "deleted",
  75         [RPROC_LAST]            = "invalid",
  76 };
  77
  78 /* Expose the state of the remote processor via sysfs */
  79 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
  80                           char *buf)
  81 {
  82         struct rproc *rproc = to_rproc(dev);
  83         unsigned int state;
  84
  85         state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
  86         return sprintf(buf, "%s\n", rproc_state_string[state]);
  87 }
  88
  89 /* Change remote processor state via sysfs */
  90 static ssize_t state_store(struct device *dev,
  91                               struct device_attribute *attr,
  92                               const char *buf, size_t count)
  93 {
  94         struct rproc *rproc = to_rproc(dev);
  95         int ret = 0;
  96
  97         if (sysfs_streq(buf, "start")) {
  98                 if (rproc->state == RPROC_RUNNING)
  99                         return -EBUSY;
 100
 101                 ret = rproc_boot(rproc);
 102                 if (ret)
 103                         dev_err(&rproc->dev, "Boot failed: %d\n", ret);
 104         } else if (sysfs_streq(buf, "stop")) {
 105                 if (rproc->state != RPROC_RUNNING)
 106                         return -EINVAL;
 107
 108                 rproc_shutdown(rproc);
 109         } else {
 110                 dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
 111                 ret = -EINVAL;
 112         }
 113         return ret ? ret : count;
 114 }
 115 static DEVICE_ATTR_RW(state);
 116
 117 /* Expose the name of the remote processor via sysfs */
 118 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
 119                          char *buf)
 120 {
 121         struct rproc *rproc = to_rproc(dev);
 122
 123         return sprintf(buf, "%s\n", rproc->name);
 124 }
 125 static DEVICE_ATTR_RO(name);
 126
 127 static struct attribute *rproc_attrs[] = {
 128         &dev_attr_firmware.attr,
 129         &dev_attr_state.attr,
 130         &dev_attr_name.attr,
 131         NULL
 132 };
 133
 134 static const struct attribute_group rproc_devgroup = {
 135         .attrs = rproc_attrs
 136 };
 137
 138 static const struct attribute_group *rproc_devgroups[] = {
 139         &rproc_devgroup,
 140         NULL
 141 };
 142
 143 struct class rproc_class = {
 144         .name           = "remoteproc",
 145         .dev_groups     = rproc_devgroups,
 146 };
 147
 148 int __init rproc_init_sysfs(void)
 149 {
 150         /* create remoteproc device class for sysfs */
 151         int err = class_register(&rproc_class);
 152
 153         if (err)
 154                 pr_err("remoteproc: unable to register class\n");
 155         return err;
 156 }
 157
 158 void __exit rproc_exit_sysfs(void)
 159 {
 160         class_unregister(&rproc_class);
 161 }