forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
436 lines
10 KiB
436 lines
10 KiB
// 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 <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); |
|
};
|
|
|