mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Suman Anna](/assets/img/avatar_default.png)
A new API, rproc_set_firmware() is added to allow the remoteproc platform drivers and remoteproc client drivers to be able to configure a custom firmware name that is different from the default name used during remoteproc registration. This function is being introduced to provide a kernel-level equivalent of the current sysfs interface to remoteproc client drivers, and can only change firmwares when the remoteproc is offline. This allows some remoteproc drivers to choose different firmwares at runtime based on the functionality the remote processor is providing. The TI PRU Ethernet driver will be an example of such usage as it requires to use different firmwares for different supported protocols. Also, update the firmware_store() function used by the sysfs interface to reuse this function to avoid code duplication. Reviewed-by: Rishabh Bhatnagar <rishabhb@codeaurora.org> Signed-off-by: Suman Anna <s-anna@ti.com> Link: https://lore.kernel.org/r/20201121032042.6195-1-s-anna@ti.com Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
264 lines
7.4 KiB
C
264 lines
7.4 KiB
C
// 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);
|
|
int err;
|
|
|
|
err = rproc_set_firmware(rproc, buf);
|
|
|
|
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);
|
|
}
|