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 static ssize_t recovery_show(struct device *dev,
  14                              struct device_attribute *attr, char *buf)
  15 {
  16         struct rproc *rproc = to_rproc(dev);
  17
  18         return sysfs_emit(buf, "%s", rproc->recovery_disabled ? "disabled\n" : "enabled\n");
  19 }
  20
  21 /*
  22  * By writing to the 'recovery' sysfs entry, we control the behavior of the
  23  * recovery mechanism dynamically. The default value of this entry is "enabled".
  24  *
  25  * The 'recovery' sysfs entry supports these commands:
  26  *
  27  * enabled:     When enabled, the remote processor will be automatically
  28  *              recovered whenever it crashes. Moreover, if the remote
  29  *              processor crashes while recovery is disabled, it will
  30  *              be automatically recovered too as soon as recovery is enabled.
  31  *
  32  * disabled:    When disabled, a remote processor will remain in a crashed
  33  *              state if it crashes. This is useful for debugging purposes;
  34  *              without it, debugging a crash is substantially harder.
  35  *
  36  * recover:     This function will trigger an immediate recovery if the
  37  *              remote processor is in a crashed state, without changing
  38  *              or checking the recovery state (enabled/disabled).
  39  *              This is useful during debugging sessions, when one expects
  40  *              additional crashes to happen after enabling recovery. In this
  41  *              case, enabling recovery will make it hard to debug subsequent
  42  *              crashes, so it's recommended to keep recovery disabled, and
  43  *              instead use the "recover" command as needed.
  44  */
  45 static ssize_t recovery_store(struct device *dev,
  46                               struct device_attribute *attr,
  47                               const char *buf, size_t count)
  48 {
  49         struct rproc *rproc = to_rproc(dev);
  50
  51         if (sysfs_streq(buf, "enabled")) {
  52                 /* change the flag and begin the recovery process if needed */
  53                 rproc->recovery_disabled = false;
  54                 rproc_trigger_recovery(rproc);
  55         } else if (sysfs_streq(buf, "disabled")) {
  56                 rproc->recovery_disabled = true;
  57         } else if (sysfs_streq(buf, "recover")) {
  58                 /* begin the recovery process without changing the flag */
  59                 rproc_trigger_recovery(rproc);
  60         } else {
  61                 return -EINVAL;
  62         }
  63
  64         return count;
  65 }
  66 static DEVICE_ATTR_RW(recovery);
  67
  68 /*
  69  * A coredump-configuration-to-string lookup table, for exposing a
  70  * human readable configuration via sysfs. Always keep in sync with
  71  * enum rproc_coredump_mechanism
  72  */
  73 static const char * const rproc_coredump_str[] = {
  74         [RPROC_COREDUMP_DISABLED]       = "disabled",
  75         [RPROC_COREDUMP_ENABLED]        = "enabled",
  76         [RPROC_COREDUMP_INLINE]         = "inline",
  77 };
  78
  79 /* Expose the current coredump configuration via debugfs */
  80 static ssize_t coredump_show(struct device *dev,
  81                              struct device_attribute *attr, char *buf)
  82 {
  83         struct rproc *rproc = to_rproc(dev);
  84
  85         return sysfs_emit(buf, "%s\n", rproc_coredump_str[rproc->dump_conf]);
  86 }
  87
  88 /*
  89  * By writing to the 'coredump' sysfs entry, we control the behavior of the
  90  * coredump mechanism dynamically. The default value of this entry is "default".
  91  *
  92  * The 'coredump' sysfs entry supports these commands:
  93  *
  94  * disabled:    This is the default coredump mechanism. Recovery will proceed
  95  *              without collecting any dump.
  96  *
  97  * default:     When the remoteproc crashes the entire coredump will be
  98  *              copied to a separate buffer and exposed to userspace.
  99  *
 100  * inline:      The coredump will not be copied to a separate buffer and the
 101  *              recovery process will have to wait until data is read by
 102  *              userspace. But this avoid usage of extra memory.
 103  */
 104 static ssize_t coredump_store(struct device *dev,
 105                               struct device_attribute *attr,
 106                               const char *buf, size_t count)
 107 {
 108         struct rproc *rproc = to_rproc(dev);
 109
 110         if (rproc->state == RPROC_CRASHED) {
 111                 dev_err(&rproc->dev, "can't change coredump configuration\n");
 112                 return -EBUSY;
 113         }
 114
 115         if (sysfs_streq(buf, "disabled")) {
 116                 rproc->dump_conf = RPROC_COREDUMP_DISABLED;
 117         } else if (sysfs_streq(buf, "enabled")) {
 118                 rproc->dump_conf = RPROC_COREDUMP_ENABLED;
 119         } else if (sysfs_streq(buf, "inline")) {
 120                 rproc->dump_conf = RPROC_COREDUMP_INLINE;
 121         } else {
 122                 dev_err(&rproc->dev, "Invalid coredump configuration\n");
 123                 return -EINVAL;
 124         }
 125
 126         return count;
 127 }
 128 static DEVICE_ATTR_RW(coredump);
 129
 130 /* Expose the loaded / running firmware name via sysfs */
 131 static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
 132                           char *buf)
 133 {
 134         struct rproc *rproc = to_rproc(dev);
 135         const char *firmware = rproc->firmware;
 136
 137         /*
 138          * If the remote processor has been started by an external
 139          * entity we have no idea of what image it is running.  As such
 140          * simply display a generic string rather then rproc->firmware.
 141          */
 142         if (rproc->state == RPROC_ATTACHED)
 143                 firmware = "unknown";
 144
 145         return sprintf(buf, "%s\n", firmware);
 146 }
 147
 148 /* Change firmware name via sysfs */
 149 static ssize_t firmware_store(struct device *dev,
 150                               struct device_attribute *attr,
 151                               const char *buf, size_t count)
 152 {
 153         struct rproc *rproc = to_rproc(dev);
 154         int err;
 155
 156         err = rproc_set_firmware(rproc, buf);
 157
 158         return err ? err : count;
 159 }
 160 static DEVICE_ATTR_RW(firmware);
 161
 162 /*
 163  * A state-to-string lookup table, for exposing a human readable state
 164  * via sysfs. Always keep in sync with enum rproc_state
 165  */
 166 static const char * const rproc_state_string[] = {
 167         [RPROC_OFFLINE]         = "offline",
 168         [RPROC_SUSPENDED]       = "suspended",
 169         [RPROC_RUNNING]         = "running",
 170         [RPROC_CRASHED]         = "crashed",
 171         [RPROC_DELETED]         = "deleted",
 172         [RPROC_ATTACHED]        = "attached",
 173         [RPROC_DETACHED]        = "detached",
 174         [RPROC_LAST]            = "invalid",
 175 };
 176
 177 /* Expose the state of the remote processor via sysfs */
 178 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
 179                           char *buf)
 180 {
 181         struct rproc *rproc = to_rproc(dev);
 182         unsigned int state;
 183
 184         state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
 185         return sprintf(buf, "%s\n", rproc_state_string[state]);
 186 }
 187
 188 /* Change remote processor state via sysfs */
 189 static ssize_t state_store(struct device *dev,
 190                               struct device_attribute *attr,
 191                               const char *buf, size_t count)
 192 {
 193         struct rproc *rproc = to_rproc(dev);
 194         int ret = 0;
 195
 196         if (sysfs_streq(buf, "start")) {
 197                 ret = rproc_boot(rproc);
 198                 if (ret)
 199                         dev_err(&rproc->dev, "Boot failed: %d\n", ret);
 200         } else if (sysfs_streq(buf, "stop")) {
 201                 ret = rproc_shutdown(rproc);
 202         } else if (sysfs_streq(buf, "detach")) {
 203                 ret = rproc_detach(rproc);
 204         } else {
 205                 dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
 206                 ret = -EINVAL;
 207         }
 208         return ret ? ret : count;
 209 }
 210 static DEVICE_ATTR_RW(state);
 211
 212 /* Expose the name of the remote processor via sysfs */
 213 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
 214                          char *buf)
 215 {
 216         struct rproc *rproc = to_rproc(dev);
 217
 218         return sprintf(buf, "%s\n", rproc->name);
 219 }
 220 static DEVICE_ATTR_RO(name);
 221
 222 static umode_t rproc_is_visible(struct kobject *kobj, struct attribute *attr,
 223                                 int n)
 224 {
 225         struct device *dev = kobj_to_dev(kobj);
 226         struct rproc *rproc = to_rproc(dev);
 227         umode_t mode = attr->mode;
 228
 229         if (rproc->sysfs_read_only && (attr == &dev_attr_recovery.attr ||
 230                                        attr == &dev_attr_firmware.attr ||
 231                                        attr == &dev_attr_state.attr ||
 232                                        attr == &dev_attr_coredump.attr))
 233                 mode = 0444;
 234
 235         return mode;
 236 }
 237
 238 static struct attribute *rproc_attrs[] = {
 239         &dev_attr_coredump.attr,
 240         &dev_attr_recovery.attr,
 241         &dev_attr_firmware.attr,
 242         &dev_attr_state.attr,
 243         &dev_attr_name.attr,
 244         NULL
 245 };
 246
 247 static const struct attribute_group rproc_devgroup = {
 248         .attrs = rproc_attrs,
 249         .is_visible = rproc_is_visible,
 250 };
 251
 252 static const struct attribute_group *rproc_devgroups[] = {
 253         &rproc_devgroup,
 254         NULL
 255 };
 256
 257 const struct class rproc_class = {
 258         .name           = "remoteproc",
 259         .dev_groups     = rproc_devgroups,
 260 };
 261
 262 int __init rproc_init_sysfs(void)
 263 {
 264         /* create remoteproc device class for sysfs */
 265         int err = class_register(&rproc_class);
 266
 267         if (err)
 268                 pr_err("remoteproc: unable to register class\n");
 269         return err;
 270 }
 271
 272 void __exit rproc_exit_sysfs(void)
 273 {
 274         class_unregister(&rproc_class);
 275 }