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 static 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 */ 45 static 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 } 66 static 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 */ 73 static 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 */ 80 static 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 */ 104 static 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 } 128 static DEVICE_ATTR_RW(coredump); 129 130 /* Expose the loaded / running firmware name via sysfs */ 131 static 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 */ 152 static 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; 187 out: 188 mutex_unlock(&rproc->lock); 189 190 return err ? err : count; 191 } 192 static 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 */ 198 static 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 */ 209 static 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 */ 220 static 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 } 245 static DEVICE_ATTR_RW(state); 246 247 /* Expose the name of the remote processor via sysfs */ 248 static 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 } 255 static DEVICE_ATTR_RO(name); 256 257 static 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 266 static const struct attribute_group rproc_devgroup = { 267 .attrs = rproc_attrs 268 }; 269 270 static const struct attribute_group *rproc_devgroups[] = { 271 &rproc_devgroup, 272 NULL 273 }; 274 275 struct class rproc_class = { 276 .name = "remoteproc", 277 .dev_groups = rproc_devgroups, 278 }; 279 280 int __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 290 void __exit rproc_exit_sysfs(void) 291 { 292 class_unregister(&rproc_class); 293 } 294