276 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Remote Processor Framework4 */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 13static 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 the23 * 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 automatically28 * recovered whenever it crashes. Moreover, if the remote29 * processor crashes while recovery is disabled, it will30 * be automatically recovered too as soon as recovery is enabled.31 *32 * disabled: When disabled, a remote processor will remain in a crashed33 * 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 the37 * remote processor is in a crashed state, without changing38 * or checking the recovery state (enabled/disabled).39 * This is useful during debugging sessions, when one expects40 * additional crashes to happen after enabling recovery. In this41 * case, enabling recovery will make it hard to debug subsequent42 * crashes, so it's recommended to keep recovery disabled, and43 * instead use the "recover" command as needed.44 */45static 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}66static DEVICE_ATTR_RW(recovery);67 68/*69 * A coredump-configuration-to-string lookup table, for exposing a70 * human readable configuration via sysfs. Always keep in sync with71 * enum rproc_coredump_mechanism72 */73static 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 */80static 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 the90 * 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 proceed95 * without collecting any dump.96 *97 * default: When the remoteproc crashes the entire coredump will be98 * copied to a separate buffer and exposed to userspace.99 *100 * inline: The coredump will not be copied to a separate buffer and the101 * recovery process will have to wait until data is read by102 * userspace. But this avoid usage of extra memory.103 */104static 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}128static DEVICE_ATTR_RW(coredump);129 130/* Expose the loaded / running firmware name via sysfs */131static 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 external139 * entity we have no idea of what image it is running. As such140 * 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 */149static 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}160static DEVICE_ATTR_RW(firmware);161 162/*163 * A state-to-string lookup table, for exposing a human readable state164 * via sysfs. Always keep in sync with enum rproc_state165 */166static 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 */178static 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 */189static 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}210static DEVICE_ATTR_RW(state);211 212/* Expose the name of the remote processor via sysfs */213static 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}220static DEVICE_ATTR_RO(name);221 222static 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 238static 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 NULL245};246 247static const struct attribute_group rproc_devgroup = {248 .attrs = rproc_attrs,249 .is_visible = rproc_is_visible,250};251 252static const struct attribute_group *rproc_devgroups[] = {253 &rproc_devgroup,254 NULL255};256 257const struct class rproc_class = {258 .name = "remoteproc",259 .dev_groups = rproc_devgroups,260};261 262int __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 272void __exit rproc_exit_sysfs(void)273{274 class_unregister(&rproc_class);275}276