text: // SPDX-License-Identifier: GPL-2.0-only
  /*
   * Remote Processor Framework
   */
  
  #include <linux/remoteproc.h>
  #include <linux/slab.h>
  
  #include "remoteproc_internal.h"
  
  #define to_rproc(d) container_of(d, struct rproc, dev)
  
  static ssize_t recovery_show(struct device *dev,
  			     struct device_attribute *attr, char *buf)
  {
  	struct rproc *rproc = to_rproc(dev);
  
  	return sprintf(buf, "%s", rproc->recovery_disabled ? "disabled\n" : "enabled\n");
  }
  
  /*
   * By writing to the 'recovery' sysfs entry, we control the behavior of the
   * recovery mechanism dynamically. The default value of this entry is "enabled".
   *
   * The 'recovery' sysfs entry supports these commands:
   *
   * enabled:	When enabled, the remote processor will be automatically
   *		recovered whenever it crashes. Moreover, if the remote
   *		processor crashes while recovery is disabled, it will
   *		be automatically recovered too as soon as recovery is enabled.
   *
   * disabled:	When disabled, a remote processor will remain in a crashed
   *		state if it crashes. This is useful for debugging purposes;
   *		without it, debugging a crash is substantially harder.
   *
   * recover:	This function will trigger an immediate recovery if the
   *		remote processor is in a crashed state, without changing
   *		or checking the recovery state (enabled/disabled).
   *		This is useful during debugging sessions, when one expects
   *		additional crashes to happen after enabling recovery. In this
   *		case, enabling recovery will make it hard to debug subsequent
   *		crashes, so it's recommended to keep recovery disabled, and
   *		instead use the "recover" command as needed.
   */
  static ssize_t recovery_store(struct device *dev,
  			      struct device_attribute *attr,
  			      const char *buf, size_t count)
  {
  	struct rproc *rproc = to_rproc(dev);
  
  	if (sysfs_streq(buf, "enabled")) {
  		/* change the flag and begin the recovery process if needed */
  		rproc->recovery_disabled = false;
  		rproc_trigger_recovery(rproc);
  	} else if (sysfs_streq(buf, "disabled")) {
  		rproc->recovery_disabled = true;
  	} else if (sysfs_streq(buf, "recover")) {
  		/* begin the recovery process without changing the flag */
  		rproc_trigger_recovery(rproc);
  	} else {
  		return -EINVAL;
  	}
  
  	return count;
  }
  static DEVICE_ATTR_RW(recovery);
  
  /*
   * A coredump-configuration-to-string lookup table, for exposing a
   * human readable configuration via sysfs. Always keep in sync with
   * enum rproc_coredump_mechanism
   */
  static const char * const rproc_coredump_str[] = {
  	[RPROC_COREDUMP_DISABLED]	= "disabled",
  	[RPROC_COREDUMP_ENABLED]	= "enabled",
  	[RPROC_COREDUMP_INLINE]		= "inline",
  };
  
  /* Expose the current coredump configuration via debugfs */
  static ssize_t coredump_show(struct device *dev,
  			     struct device_attribute *attr, char *buf)
  {
  	struct rproc *rproc = to_rproc(dev);
  
  	return sprintf(buf, "%s\n", rproc_coredump_str[rproc->dump_conf]);
  }
  
  /*
   * By writing to the 'coredump' sysfs entry, we control the behavior of the
   * coredump mechanism dynamically. The default value of this entry is "default".
   *
   * The 'coredump' sysfs entry supports these commands:
   *
   * disabled:	This is the default coredump mechanism. Recovery will proceed
   *		without collecting any dump.
   *
   * default:	When the remoteproc crashes the entire coredump will be
   *		copied to a separate buffer and exposed to userspace.
   *
   * inline:	The coredump will not be copied to a separate buffer and the
   *		recovery process will have to wait until data is read by
   *		userspace. But this avoid usage of extra memory.
   */
  static ssize_t coredump_store(struct device *dev,
  			      struct device_attribute *attr,
  			      const char *buf, size_t count)
  {
  	struct rproc *rproc = to_rproc(dev);
  
  	if (rproc->state == RPROC_CRASHED) {
  		dev_err(&rproc->dev, "can't change coredump configuration\n");
  		return -EBUSY;
  	}
  
  	if (sysfs_streq(buf, "disabled")) {
  		rproc->dump_conf = RPROC_COREDUMP_DISABLED;
  	} else if (sysfs_streq(buf, "enabled")) {
  		rproc->dump_conf = RPROC_COREDUMP_ENABLED;
  	} else if (sysfs_streq(buf, "inline")) {
  		rproc->dump_conf = RPROC_COREDUMP_INLINE;
  	} else {
  		dev_err(&rproc->dev, "Invalid coredump configuration\n");
  		return -EINVAL;
  	}
  
  	return count;
  }
  static DEVICE_ATTR_RW(coredump);
  
  /* Expose the loaded / running firmware name via sysfs */
  static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
  			  char *buf)
  {
  	struct rproc *rproc = to_rproc(dev);
  	const char *firmware = rproc->firmware;
  
  	/*
  	 * If the remote processor has been started by an external
  	 * entity we have no idea of what image it is running.  As such
  	 * simply display a generic string rather then rproc->firmware.
  	 *
  	 * Here we rely on the autonomous flag because a remote processor
  	 * may have been attached to and currently in a running state.
  	 */
  	if (rproc->autonomous)
  		firmware = "unknown";
  
  	return sprintf(buf, "%s\n", firmware);
  }
  
  /* Change firmware name via sysfs */
  static ssize_t firmware_store(struct device *dev,
  			      struct device_attribute *attr,
  			      const char *buf, size_t count)
  {
  	struct rproc *rproc = to_rproc(dev);
  	char *p;
  	int err, len = count;
  
  	err = mutex_lock_interruptible(&rproc->lock);
  	if (err) {
  		dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, err);
  		return -EINVAL;
  	}
  
  	if (rproc->state != RPROC_OFFLINE) {
  		dev_err(dev, "can't change firmware while running\n");
  		err = -EBUSY;
  		goto out;
  	}
  
  	len = strcspn(buf, "\n");
  	if (!len) {
  		dev_err(dev, "can't provide a NULL firmware\n");
  		err = -EINVAL;
  		goto out;
  	}
  
  	p = kstrndup(buf, len, GFP_KERNEL);
  	if (!p) {
  		err = -ENOMEM;
  		goto out;
  	}
  
  	kfree(rproc->firmware);
  	rproc->firmware = p;
  out:
  	mutex_unlock(&rproc->lock);
  
  	return err ? err : count;
  }
  static DEVICE_ATTR_RW(firmware);
  
  /*
   * A state-to-string lookup table, for exposing a human readable state
   * via sysfs. Always keep in sync with enum rproc_state
   */
  static const char * const rproc_state_string[] = {
  	[RPROC_OFFLINE]		= "offline",
  	[RPROC_SUSPENDED]	= "suspended",
  	[RPROC_RUNNING]		= "running",
  	[RPROC_CRASHED]		= "crashed",
  	[RPROC_DELETED]		= "deleted",
  	[RPROC_DETACHED]	= "detached",
  	[RPROC_LAST]		= "invalid",
  };
  
  /* Expose the state of the remote processor via sysfs */
  static ssize_t state_show(struct device *dev, struct device_attribute *attr,
  			  char *buf)
  {
  	struct rproc *rproc = to_rproc(dev);
  	unsigned int state;
  
  	state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
  	return sprintf(buf, "%s\n", rproc_state_string[state]);
  }
  
  /* Change remote processor state via sysfs */
  static ssize_t state_store(struct device *dev,
  			      struct device_attribute *attr,
  			      const char *buf, size_t count)
  {
  	struct rproc *rproc = to_rproc(dev);
  	int ret = 0;
  
  	if (sysfs_streq(buf, "start")) {
  		if (rproc->state == RPROC_RUNNING)
  			return -EBUSY;
  
  		ret = rproc_boot(rproc);
  		if (ret)
  			dev_err(&rproc->dev, "Boot failed: %d\n", ret);
  	} else if (sysfs_streq(buf, "stop")) {
  		if (rproc->state != RPROC_RUNNING)
  			return -EINVAL;
  
  		rproc_shutdown(rproc);
  	} else {
  		dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
  		ret = -EINVAL;
  	}
  	return ret ? ret : count;
  }
  static DEVICE_ATTR_RW(state);
  
  /* Expose the name of the remote processor via sysfs */
  static ssize_t name_show(struct device *dev, struct device_attribute *attr,
  			 char *buf)
  {
  	struct rproc *rproc = to_rproc(dev);
  
  	return sprintf(buf, "%s\n", rproc->name);
  }
  static DEVICE_ATTR_RO(name);
  
  static struct attribute *rproc_attrs[] = {
  	&dev_attr_coredump.attr,
  	&dev_attr_recovery.attr,
  	&dev_attr_firmware.attr,
  	&dev_attr_state.attr,
  	&dev_attr_name.attr,
  	NULL
  };
  
  static const struct attribute_group rproc_devgroup = {
  	.attrs = rproc_attrs
  };
  
  static const struct attribute_group *rproc_devgroups[] = {
  	&rproc_devgroup,
  	NULL
  };
  
  struct class rproc_class = {
  	.name		= "remoteproc",
  	.dev_groups	= rproc_devgroups,
  };
  
  int __init rproc_init_sysfs(void)
  {
  	/* create remoteproc device class for sysfs */
  	int err = class_register(&rproc_class);
  
  	if (err)
  		pr_err("remoteproc: unable to register class\n");
  	return err;
  }
  
  void __exit rproc_exit_sysfs(void)
  {
  	class_unregister(&rproc_class);
  }
  