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
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 sprintf(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 */
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 a
70 * human readable configuration via sysfs. Always keep in sync with
71 * enum rproc_coredump_mechanism
72 */
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 sprintf(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 */
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 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	 * Here we rely on the autonomous flag because a remote processor
143	 * may have been attached to and currently in a running state.
144	 */
145	if (rproc->autonomous)
146		firmware = "unknown";
147
148	return sprintf(buf, "%s\n", firmware);
149}
150
151/* Change firmware name via sysfs */
152static ssize_t firmware_store(struct device *dev,
153			      struct device_attribute *attr,
154			      const char *buf, size_t count)
155{
156	struct rproc *rproc = to_rproc(dev);
157	char *p;
158	int err, len = count;
159
160	err = mutex_lock_interruptible(&rproc->lock);
161	if (err) {
162		dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, err);
163		return -EINVAL;
164	}
165
166	if (rproc->state != RPROC_OFFLINE) {
167		dev_err(dev, "can't change firmware while running\n");
168		err = -EBUSY;
169		goto out;
170	}
171
172	len = strcspn(buf, "\n");
173	if (!len) {
174		dev_err(dev, "can't provide a NULL firmware\n");
175		err = -EINVAL;
176		goto out;
177	}
178
179	p = kstrndup(buf, len, GFP_KERNEL);
180	if (!p) {
181		err = -ENOMEM;
182		goto out;
183	}
184
185	kfree(rproc->firmware);
186	rproc->firmware = p;
187out:
188	mutex_unlock(&rproc->lock);
189
190	return err ? err : count;
191}
192static DEVICE_ATTR_RW(firmware);
193
194/*
195 * A state-to-string lookup table, for exposing a human readable state
196 * via sysfs. Always keep in sync with enum rproc_state
197 */
198static const char * const rproc_state_string[] = {
199	[RPROC_OFFLINE]		= "offline",
200	[RPROC_SUSPENDED]	= "suspended",
201	[RPROC_RUNNING]		= "running",
202	[RPROC_CRASHED]		= "crashed",
203	[RPROC_DELETED]		= "deleted",
204	[RPROC_DETACHED]	= "detached",
205	[RPROC_LAST]		= "invalid",
206};
207
208/* Expose the state of the remote processor via sysfs */
209static ssize_t state_show(struct device *dev, struct device_attribute *attr,
210			  char *buf)
211{
212	struct rproc *rproc = to_rproc(dev);
213	unsigned int state;
214
215	state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
216	return sprintf(buf, "%s\n", rproc_state_string[state]);
217}
218
219/* Change remote processor state via sysfs */
220static ssize_t state_store(struct device *dev,
221			      struct device_attribute *attr,
222			      const char *buf, size_t count)
223{
224	struct rproc *rproc = to_rproc(dev);
225	int ret = 0;
226
227	if (sysfs_streq(buf, "start")) {
228		if (rproc->state == RPROC_RUNNING)
229			return -EBUSY;
230
231		ret = rproc_boot(rproc);
232		if (ret)
233			dev_err(&rproc->dev, "Boot failed: %d\n", ret);
234	} else if (sysfs_streq(buf, "stop")) {
235		if (rproc->state != RPROC_RUNNING)
236			return -EINVAL;
237
238		rproc_shutdown(rproc);
239	} else {
240		dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
241		ret = -EINVAL;
242	}
243	return ret ? ret : count;
244}
245static DEVICE_ATTR_RW(state);
246
247/* Expose the name of the remote processor via sysfs */
248static ssize_t name_show(struct device *dev, struct device_attribute *attr,
249			 char *buf)
250{
251	struct rproc *rproc = to_rproc(dev);
252
253	return sprintf(buf, "%s\n", rproc->name);
254}
255static DEVICE_ATTR_RO(name);
256
257static struct attribute *rproc_attrs[] = {
258	&dev_attr_coredump.attr,
259	&dev_attr_recovery.attr,
260	&dev_attr_firmware.attr,
261	&dev_attr_state.attr,
262	&dev_attr_name.attr,
263	NULL
264};
265
266static const struct attribute_group rproc_devgroup = {
267	.attrs = rproc_attrs
268};
269
270static const struct attribute_group *rproc_devgroups[] = {
271	&rproc_devgroup,
272	NULL
273};
274
275struct class rproc_class = {
276	.name		= "remoteproc",
277	.dev_groups	= rproc_devgroups,
278};
279
280int __init rproc_init_sysfs(void)
281{
282	/* create remoteproc device class for sysfs */
283	int err = class_register(&rproc_class);
284
285	if (err)
286		pr_err("remoteproc: unable to register class\n");
287	return err;
288}
289
290void __exit rproc_exit_sysfs(void)
291{
292	class_unregister(&rproc_class);
293}
294