1 // SPDX-License-Identifier: GPL-2.0-only
3 * Remote Processor Framework
6 #include <linux/remoteproc.h>
7 #include <linux/slab.h>
9 #include "remoteproc_internal.h"
11 #define to_rproc(d) container_of(d, struct rproc, dev)
13 static ssize_t recovery_show(struct device *dev,
14 struct device_attribute *attr, char *buf)
16 struct rproc *rproc = to_rproc(dev);
18 return sysfs_emit(buf, "%s", rproc->recovery_disabled ? "disabled\n" : "enabled\n");
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".
25 * The 'recovery' sysfs entry supports these commands:
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.
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.
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.
45 static ssize_t recovery_store(struct device *dev,
46 struct device_attribute *attr,
47 const char *buf, size_t count)
49 struct rproc *rproc = to_rproc(dev);
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);
66 static DEVICE_ATTR_RW(recovery);
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
73 static const char * const rproc_coredump_str[] = {
74 [RPROC_COREDUMP_DISABLED] = "disabled",
75 [RPROC_COREDUMP_ENABLED] = "enabled",
76 [RPROC_COREDUMP_INLINE] = "inline",
79 /* Expose the current coredump configuration via debugfs */
80 static ssize_t coredump_show(struct device *dev,
81 struct device_attribute *attr, char *buf)
83 struct rproc *rproc = to_rproc(dev);
85 return sysfs_emit(buf, "%s\n", rproc_coredump_str[rproc->dump_conf]);
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".
92 * The 'coredump' sysfs entry supports these commands:
94 * disabled: This is the default coredump mechanism. Recovery will proceed
95 * without collecting any dump.
97 * default: When the remoteproc crashes the entire coredump will be
98 * copied to a separate buffer and exposed to userspace.
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.
104 static ssize_t coredump_store(struct device *dev,
105 struct device_attribute *attr,
106 const char *buf, size_t count)
108 struct rproc *rproc = to_rproc(dev);
110 if (rproc->state == RPROC_CRASHED) {
111 dev_err(&rproc->dev, "can't change coredump configuration\n");
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;
122 dev_err(&rproc->dev, "Invalid coredump configuration\n");
128 static DEVICE_ATTR_RW(coredump);
130 /* Expose the loaded / running firmware name via sysfs */
131 static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
134 struct rproc *rproc = to_rproc(dev);
135 const char *firmware = rproc->firmware;
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.
142 if (rproc->state == RPROC_ATTACHED)
143 firmware = "unknown";
145 return sprintf(buf, "%s\n", firmware);
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)
153 struct rproc *rproc = to_rproc(dev);
156 err = rproc_set_firmware(rproc, buf);
158 return err ? err : count;
160 static DEVICE_ATTR_RW(firmware);
163 * A state-to-string lookup table, for exposing a human readable state
164 * via sysfs. Always keep in sync with enum rproc_state
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",
177 /* Expose the state of the remote processor via sysfs */
178 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
181 struct rproc *rproc = to_rproc(dev);
184 state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
185 return sprintf(buf, "%s\n", rproc_state_string[state]);
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)
193 struct rproc *rproc = to_rproc(dev);
196 if (sysfs_streq(buf, "start")) {
197 if (rproc->state == RPROC_RUNNING ||
198 rproc->state == RPROC_ATTACHED)
201 ret = rproc_boot(rproc);
203 dev_err(&rproc->dev, "Boot failed: %d\n", ret);
204 } else if (sysfs_streq(buf, "stop")) {
205 if (rproc->state != RPROC_RUNNING &&
206 rproc->state != RPROC_ATTACHED)
209 rproc_shutdown(rproc);
210 } else if (sysfs_streq(buf, "detach")) {
211 if (rproc->state != RPROC_ATTACHED)
214 ret = rproc_detach(rproc);
216 dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
219 return ret ? ret : count;
221 static DEVICE_ATTR_RW(state);
223 /* Expose the name of the remote processor via sysfs */
224 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
227 struct rproc *rproc = to_rproc(dev);
229 return sprintf(buf, "%s\n", rproc->name);
231 static DEVICE_ATTR_RO(name);
233 static struct attribute *rproc_attrs[] = {
234 &dev_attr_coredump.attr,
235 &dev_attr_recovery.attr,
236 &dev_attr_firmware.attr,
237 &dev_attr_state.attr,
242 static const struct attribute_group rproc_devgroup = {
246 static const struct attribute_group *rproc_devgroups[] = {
251 struct class rproc_class = {
252 .name = "remoteproc",
253 .dev_groups = rproc_devgroups,
256 int __init rproc_init_sysfs(void)
258 /* create remoteproc device class for sysfs */
259 int err = class_register(&rproc_class);
262 pr_err("remoteproc: unable to register class\n");
266 void __exit rproc_exit_sysfs(void)
268 class_unregister(&rproc_class);