mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 08:58:52 +09:00
438 lines
10 KiB
C
438 lines
10 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* (C) Copyright 2015
|
|
* Texas Instruments Incorporated - http://www.ti.com/
|
|
*/
|
|
#define pr_fmt(fmt) "%s: " fmt, __func__
|
|
#include <common.h>
|
|
#include <errno.h>
|
|
#include <fdtdec.h>
|
|
#include <log.h>
|
|
#include <malloc.h>
|
|
#include <remoteproc.h>
|
|
#include <asm/io.h>
|
|
#include <dm/device-internal.h>
|
|
#include <dm.h>
|
|
#include <dm/uclass.h>
|
|
#include <dm/uclass-internal.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
/**
|
|
* for_each_remoteproc_device() - iterate through the list of rproc devices
|
|
* @fn: check function to call per match, if this function returns fail,
|
|
* iteration is aborted with the resultant error value
|
|
* @skip_dev: Device to skip calling the callback about.
|
|
* @data: Data to pass to the callback function
|
|
*
|
|
* Return: 0 if none of the callback returned a non 0 result, else returns the
|
|
* result from the callback function
|
|
*/
|
|
static int for_each_remoteproc_device(int (*fn) (struct udevice *dev,
|
|
struct dm_rproc_uclass_pdata *uc_pdata,
|
|
const void *data),
|
|
struct udevice *skip_dev,
|
|
const void *data)
|
|
{
|
|
struct udevice *dev;
|
|
struct dm_rproc_uclass_pdata *uc_pdata;
|
|
int ret;
|
|
|
|
for (ret = uclass_find_first_device(UCLASS_REMOTEPROC, &dev); dev;
|
|
ret = uclass_find_next_device(&dev)) {
|
|
if (ret || dev == skip_dev)
|
|
continue;
|
|
uc_pdata = dev_get_uclass_platdata(dev);
|
|
ret = fn(dev, uc_pdata, data);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* _rproc_name_is_unique() - iteration helper to check if rproc name is unique
|
|
* @dev: device that we are checking name for
|
|
* @uc_pdata: uclass platform data
|
|
* @data: compare data (this is the name we want to ensure is unique)
|
|
*
|
|
* Return: 0 is there is no match(is unique); if there is a match(we dont
|
|
* have a unique name), return -EINVAL.
|
|
*/
|
|
static int _rproc_name_is_unique(struct udevice *dev,
|
|
struct dm_rproc_uclass_pdata *uc_pdata,
|
|
const void *data)
|
|
{
|
|
const char *check_name = data;
|
|
|
|
/* devices not yet populated with data - so skip them */
|
|
if (!uc_pdata->name || !check_name)
|
|
return 0;
|
|
|
|
/* Return 0 to search further if we dont match */
|
|
if (strlen(uc_pdata->name) != strlen(check_name))
|
|
return 0;
|
|
|
|
if (!strcmp(uc_pdata->name, check_name))
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* rproc_name_is_unique() - Check if the rproc name is unique
|
|
* @check_dev: Device we are attempting to ensure is unique
|
|
* @check_name: Name we are trying to ensure is unique.
|
|
*
|
|
* Return: true if we have a unique name, false if name is not unique.
|
|
*/
|
|
static bool rproc_name_is_unique(struct udevice *check_dev,
|
|
const char *check_name)
|
|
{
|
|
int ret;
|
|
|
|
ret = for_each_remoteproc_device(_rproc_name_is_unique,
|
|
check_dev, check_name);
|
|
return ret ? false : true;
|
|
}
|
|
|
|
/**
|
|
* rproc_pre_probe() - Pre probe accessor for the uclass
|
|
* @dev: device for which we are preprobing
|
|
*
|
|
* Parses and fills up the uclass pdata for use as needed by core and
|
|
* remote proc drivers.
|
|
*
|
|
* Return: 0 if all wernt ok, else appropriate error value.
|
|
*/
|
|
static int rproc_pre_probe(struct udevice *dev)
|
|
{
|
|
struct dm_rproc_uclass_pdata *uc_pdata;
|
|
const struct dm_rproc_ops *ops;
|
|
|
|
uc_pdata = dev_get_uclass_platdata(dev);
|
|
|
|
/* See if we need to populate via fdt */
|
|
|
|
if (!dev->platdata) {
|
|
#if CONFIG_IS_ENABLED(OF_CONTROL)
|
|
int node = dev_of_offset(dev);
|
|
const void *blob = gd->fdt_blob;
|
|
bool tmp;
|
|
if (!blob) {
|
|
debug("'%s' no dt?\n", dev->name);
|
|
return -EINVAL;
|
|
}
|
|
debug("'%s': using fdt\n", dev->name);
|
|
uc_pdata->name = fdt_getprop(blob, node,
|
|
"remoteproc-name", NULL);
|
|
|
|
/* Default is internal memory mapped */
|
|
uc_pdata->mem_type = RPROC_INTERNAL_MEMORY_MAPPED;
|
|
tmp = fdtdec_get_bool(blob, node,
|
|
"remoteproc-internal-memory-mapped");
|
|
if (tmp)
|
|
uc_pdata->mem_type = RPROC_INTERNAL_MEMORY_MAPPED;
|
|
#else
|
|
/* Nothing much we can do about this, can we? */
|
|
return -EINVAL;
|
|
#endif
|
|
|
|
} else {
|
|
struct dm_rproc_uclass_pdata *pdata = dev->platdata;
|
|
|
|
debug("'%s': using legacy data\n", dev->name);
|
|
if (pdata->name)
|
|
uc_pdata->name = pdata->name;
|
|
uc_pdata->mem_type = pdata->mem_type;
|
|
uc_pdata->driver_plat_data = pdata->driver_plat_data;
|
|
}
|
|
|
|
/* Else try using device Name */
|
|
if (!uc_pdata->name)
|
|
uc_pdata->name = dev->name;
|
|
if (!uc_pdata->name) {
|
|
debug("Unnamed device!");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!rproc_name_is_unique(dev, uc_pdata->name)) {
|
|
debug("%s duplicate name '%s'\n", dev->name, uc_pdata->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
ops = rproc_get_ops(dev);
|
|
if (!ops) {
|
|
debug("%s driver has no ops?\n", dev->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!ops->load || !ops->start) {
|
|
debug("%s driver has missing mandatory ops?\n", dev->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* rproc_post_probe() - post probe accessor for the uclass
|
|
* @dev: deivce we finished probing
|
|
*
|
|
* initiate init function after the probe is completed. This allows
|
|
* the remote processor drivers to split up the initializations between
|
|
* probe and init as needed.
|
|
*
|
|
* Return: if the remote proc driver has a init routine, invokes it and
|
|
* hands over the return value. overall, 0 if all went well, else appropriate
|
|
* error value.
|
|
*/
|
|
static int rproc_post_probe(struct udevice *dev)
|
|
{
|
|
const struct dm_rproc_ops *ops;
|
|
|
|
ops = rproc_get_ops(dev);
|
|
if (!ops) {
|
|
debug("%s driver has no ops?\n", dev->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (ops->init)
|
|
return ops->init(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
UCLASS_DRIVER(rproc) = {
|
|
.id = UCLASS_REMOTEPROC,
|
|
.name = "remoteproc",
|
|
.flags = DM_UC_FLAG_SEQ_ALIAS,
|
|
.pre_probe = rproc_pre_probe,
|
|
.post_probe = rproc_post_probe,
|
|
.per_device_platdata_auto_alloc_size =
|
|
sizeof(struct dm_rproc_uclass_pdata),
|
|
};
|
|
|
|
/* Remoteproc subsystem access functions */
|
|
/**
|
|
* _rproc_probe_dev() - iteration helper to probe a rproc device
|
|
* @dev: device to probe
|
|
* @uc_pdata: uclass data allocated for the device
|
|
* @data: unused
|
|
*
|
|
* Return: 0 if all ok, else appropriate error value.
|
|
*/
|
|
static int _rproc_probe_dev(struct udevice *dev,
|
|
struct dm_rproc_uclass_pdata *uc_pdata,
|
|
const void *data)
|
|
{
|
|
int ret;
|
|
|
|
ret = device_probe(dev);
|
|
|
|
if (ret)
|
|
debug("%s: Failed to initialize - %d\n", dev->name, ret);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* _rproc_dev_is_probed() - check if the device has been probed
|
|
* @dev: device to check
|
|
* @uc_pdata: unused
|
|
* @data: unused
|
|
*
|
|
* Return: -EAGAIN if not probed else return 0
|
|
*/
|
|
static int _rproc_dev_is_probed(struct udevice *dev,
|
|
struct dm_rproc_uclass_pdata *uc_pdata,
|
|
const void *data)
|
|
{
|
|
if (dev->flags & DM_FLAG_ACTIVATED)
|
|
return 0;
|
|
|
|
return -EAGAIN;
|
|
}
|
|
|
|
bool rproc_is_initialized(void)
|
|
{
|
|
int ret = for_each_remoteproc_device(_rproc_dev_is_probed, NULL, NULL);
|
|
return ret ? false : true;
|
|
}
|
|
|
|
int rproc_init(void)
|
|
{
|
|
int ret;
|
|
|
|
if (rproc_is_initialized()) {
|
|
debug("Already initialized\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
ret = for_each_remoteproc_device(_rproc_probe_dev, NULL, NULL);
|
|
return ret;
|
|
}
|
|
|
|
int rproc_dev_init(int id)
|
|
{
|
|
struct udevice *dev = NULL;
|
|
int ret;
|
|
|
|
ret = uclass_get_device_by_seq(UCLASS_REMOTEPROC, id, &dev);
|
|
if (ret) {
|
|
debug("Unknown remote processor id '%d' requested(%d)\n",
|
|
id, ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = device_probe(dev);
|
|
if (ret)
|
|
debug("%s: Failed to initialize - %d\n", dev->name, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int rproc_load(int id, ulong addr, ulong size)
|
|
{
|
|
struct udevice *dev = NULL;
|
|
struct dm_rproc_uclass_pdata *uc_pdata;
|
|
const struct dm_rproc_ops *ops;
|
|
int ret;
|
|
|
|
ret = uclass_get_device_by_seq(UCLASS_REMOTEPROC, id, &dev);
|
|
if (ret) {
|
|
debug("Unknown remote processor id '%d' requested(%d)\n",
|
|
id, ret);
|
|
return ret;
|
|
}
|
|
|
|
uc_pdata = dev_get_uclass_platdata(dev);
|
|
|
|
ops = rproc_get_ops(dev);
|
|
if (!ops) {
|
|
debug("%s driver has no ops?\n", dev->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
debug("Loading to '%s' from address 0x%08lX size of %lu bytes\n",
|
|
uc_pdata->name, addr, size);
|
|
if (ops->load)
|
|
return ops->load(dev, addr, size);
|
|
|
|
debug("%s: data corruption?? mandatory function is missing!\n",
|
|
dev->name);
|
|
|
|
return -EINVAL;
|
|
};
|
|
|
|
/*
|
|
* Completely internal helper enums..
|
|
* Keeping this isolated helps this code evolve independent of other
|
|
* parts..
|
|
*/
|
|
enum rproc_ops {
|
|
RPROC_START,
|
|
RPROC_STOP,
|
|
RPROC_RESET,
|
|
RPROC_PING,
|
|
RPROC_RUNNING,
|
|
};
|
|
|
|
/**
|
|
* _rproc_ops_wrapper() - wrapper for invoking remote proc driver callback
|
|
* @id: id of the remote processor
|
|
* @op: one of rproc_ops that indicate what operation to invoke
|
|
*
|
|
* Most of the checks and verification for remoteproc operations are more
|
|
* or less same for almost all operations. This allows us to put a wrapper
|
|
* and use the common checks to allow the driver to function appropriately.
|
|
*
|
|
* Return: 0 if all ok, else appropriate error value.
|
|
*/
|
|
static int _rproc_ops_wrapper(int id, enum rproc_ops op)
|
|
{
|
|
struct udevice *dev = NULL;
|
|
struct dm_rproc_uclass_pdata *uc_pdata;
|
|
const struct dm_rproc_ops *ops;
|
|
int (*fn)(struct udevice *dev);
|
|
bool mandatory = false;
|
|
char *op_str;
|
|
int ret;
|
|
|
|
ret = uclass_get_device_by_seq(UCLASS_REMOTEPROC, id, &dev);
|
|
if (ret) {
|
|
debug("Unknown remote processor id '%d' requested(%d)\n",
|
|
id, ret);
|
|
return ret;
|
|
}
|
|
|
|
uc_pdata = dev_get_uclass_platdata(dev);
|
|
|
|
ops = rproc_get_ops(dev);
|
|
if (!ops) {
|
|
debug("%s driver has no ops?\n", dev->name);
|
|
return -EINVAL;
|
|
}
|
|
switch (op) {
|
|
case RPROC_START:
|
|
fn = ops->start;
|
|
mandatory = true;
|
|
op_str = "Starting";
|
|
break;
|
|
case RPROC_STOP:
|
|
fn = ops->stop;
|
|
op_str = "Stopping";
|
|
break;
|
|
case RPROC_RESET:
|
|
fn = ops->reset;
|
|
op_str = "Resetting";
|
|
break;
|
|
case RPROC_RUNNING:
|
|
fn = ops->is_running;
|
|
op_str = "Checking if running:";
|
|
break;
|
|
case RPROC_PING:
|
|
fn = ops->ping;
|
|
op_str = "Pinging";
|
|
break;
|
|
default:
|
|
debug("what is '%d' operation??\n", op);
|
|
return -EINVAL;
|
|
}
|
|
|
|
debug("%s %s...\n", op_str, uc_pdata->name);
|
|
if (fn)
|
|
return fn(dev);
|
|
|
|
if (mandatory)
|
|
debug("%s: data corruption?? mandatory function is missing!\n",
|
|
dev->name);
|
|
|
|
return -ENOSYS;
|
|
}
|
|
|
|
int rproc_start(int id)
|
|
{
|
|
return _rproc_ops_wrapper(id, RPROC_START);
|
|
};
|
|
|
|
int rproc_stop(int id)
|
|
{
|
|
return _rproc_ops_wrapper(id, RPROC_STOP);
|
|
};
|
|
|
|
int rproc_reset(int id)
|
|
{
|
|
return _rproc_ops_wrapper(id, RPROC_RESET);
|
|
};
|
|
|
|
int rproc_ping(int id)
|
|
{
|
|
return _rproc_ops_wrapper(id, RPROC_PING);
|
|
};
|
|
|
|
int rproc_is_running(int id)
|
|
{
|
|
return _rproc_ops_wrapper(id, RPROC_RUNNING);
|
|
};
|