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