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