mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-09-08 13:53:21 +09:00
![Stephen Warren](/assets/img/avatar_default.png)
Tegra124's MMC controller is very similar to earlier SoC generations, and can be supported by the same driver. However, there are some non-backwards-compatible HW differences, and hence a new DT compatible value must be used to describe the HW. This patch updates the driver to support that new compatible value. That said, the HW differences are only relevant when enabling certain high-performance transfer modes. Since the driver is currently very simple and doesn't enable those modes, we don't actually need to address any of these HW differences in the code yet, hence the simple nature of this patch. Signed-off-by: Stephen Warren <swarren@nvidia.com> Acked-by: Pantelis Antoniou <panto@antoniou-consulting.com> Tested-by: Thierry Reding <treding@nvidia.com> Acked-by: Simon Glass <sjg@chromium.org> Signed-off-by: Tom Warren <twarren@nvidia.com>
620 lines
16 KiB
C
620 lines
16 KiB
C
/*
|
|
* Copyright (c) 2011 The Chromium OS Authors.
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <serial.h>
|
|
#include <libfdt.h>
|
|
#include <fdtdec.h>
|
|
|
|
#include <asm/gpio.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
/*
|
|
* Here are the type we know about. One day we might allow drivers to
|
|
* register. For now we just put them here. The COMPAT macro allows us to
|
|
* turn this into a sparse list later, and keeps the ID with the name.
|
|
*/
|
|
#define COMPAT(id, name) name
|
|
static const char * const compat_names[COMPAT_COUNT] = {
|
|
COMPAT(UNKNOWN, "<none>"),
|
|
COMPAT(NVIDIA_TEGRA20_USB, "nvidia,tegra20-ehci"),
|
|
COMPAT(NVIDIA_TEGRA30_USB, "nvidia,tegra30-ehci"),
|
|
COMPAT(NVIDIA_TEGRA114_USB, "nvidia,tegra114-ehci"),
|
|
COMPAT(NVIDIA_TEGRA114_I2C, "nvidia,tegra114-i2c"),
|
|
COMPAT(NVIDIA_TEGRA20_I2C, "nvidia,tegra20-i2c"),
|
|
COMPAT(NVIDIA_TEGRA20_DVC, "nvidia,tegra20-i2c-dvc"),
|
|
COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"),
|
|
COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"),
|
|
COMPAT(NVIDIA_TEGRA20_KBC, "nvidia,tegra20-kbc"),
|
|
COMPAT(NVIDIA_TEGRA20_NAND, "nvidia,tegra20-nand"),
|
|
COMPAT(NVIDIA_TEGRA20_PWM, "nvidia,tegra20-pwm"),
|
|
COMPAT(NVIDIA_TEGRA20_DC, "nvidia,tegra20-dc"),
|
|
COMPAT(NVIDIA_TEGRA124_SDMMC, "nvidia,tegra124-sdhci"),
|
|
COMPAT(NVIDIA_TEGRA30_SDMMC, "nvidia,tegra30-sdhci"),
|
|
COMPAT(NVIDIA_TEGRA20_SDMMC, "nvidia,tegra20-sdhci"),
|
|
COMPAT(NVIDIA_TEGRA20_SFLASH, "nvidia,tegra20-sflash"),
|
|
COMPAT(NVIDIA_TEGRA20_SLINK, "nvidia,tegra20-slink"),
|
|
COMPAT(NVIDIA_TEGRA114_SPI, "nvidia,tegra114-spi"),
|
|
COMPAT(SMSC_LAN9215, "smsc,lan9215"),
|
|
COMPAT(SAMSUNG_EXYNOS5_SROMC, "samsung,exynos-sromc"),
|
|
COMPAT(SAMSUNG_S3C2440_I2C, "samsung,s3c2440-i2c"),
|
|
COMPAT(SAMSUNG_EXYNOS5_SOUND, "samsung,exynos-sound"),
|
|
COMPAT(WOLFSON_WM8994_CODEC, "wolfson,wm8994-codec"),
|
|
COMPAT(SAMSUNG_EXYNOS_SPI, "samsung,exynos-spi"),
|
|
COMPAT(GOOGLE_CROS_EC, "google,cros-ec"),
|
|
COMPAT(GOOGLE_CROS_EC_KEYB, "google,cros-ec-keyb"),
|
|
COMPAT(SAMSUNG_EXYNOS_EHCI, "samsung,exynos-ehci"),
|
|
COMPAT(SAMSUNG_EXYNOS5_XHCI, "samsung,exynos5250-xhci"),
|
|
COMPAT(SAMSUNG_EXYNOS_USB_PHY, "samsung,exynos-usb-phy"),
|
|
COMPAT(SAMSUNG_EXYNOS5_USB3_PHY, "samsung,exynos5250-usb3-phy"),
|
|
COMPAT(SAMSUNG_EXYNOS_TMU, "samsung,exynos-tmu"),
|
|
COMPAT(SAMSUNG_EXYNOS_FIMD, "samsung,exynos-fimd"),
|
|
COMPAT(SAMSUNG_EXYNOS5_DP, "samsung,exynos5-dp"),
|
|
COMPAT(SAMSUNG_EXYNOS5_DWMMC, "samsung,exynos5250-dwmmc"),
|
|
COMPAT(SAMSUNG_EXYNOS_SERIAL, "samsung,exynos4210-uart"),
|
|
COMPAT(MAXIM_MAX77686_PMIC, "maxim,max77686_pmic"),
|
|
COMPAT(GENERIC_SPI_FLASH, "spi-flash"),
|
|
COMPAT(MAXIM_98095_CODEC, "maxim,max98095-codec"),
|
|
COMPAT(INFINEON_SLB9635_TPM, "infineon,slb9635-tpm"),
|
|
COMPAT(INFINEON_SLB9645_TPM, "infineon,slb9645-tpm"),
|
|
COMPAT(SAMSUNG_EXYNOS5_I2C, "samsung,exynos5-hsi2c"),
|
|
};
|
|
|
|
const char *fdtdec_get_compatible(enum fdt_compat_id id)
|
|
{
|
|
/* We allow reading of the 'unknown' ID for testing purposes */
|
|
assert(id >= 0 && id < COMPAT_COUNT);
|
|
return compat_names[id];
|
|
}
|
|
|
|
fdt_addr_t fdtdec_get_addr_size(const void *blob, int node,
|
|
const char *prop_name, fdt_size_t *sizep)
|
|
{
|
|
const fdt_addr_t *cell;
|
|
int len;
|
|
|
|
debug("%s: %s: ", __func__, prop_name);
|
|
cell = fdt_getprop(blob, node, prop_name, &len);
|
|
if (cell && ((!sizep && len == sizeof(fdt_addr_t)) ||
|
|
len == sizeof(fdt_addr_t) * 2)) {
|
|
fdt_addr_t addr = fdt_addr_to_cpu(*cell);
|
|
if (sizep) {
|
|
const fdt_size_t *size;
|
|
|
|
size = (fdt_size_t *)((char *)cell +
|
|
sizeof(fdt_addr_t));
|
|
*sizep = fdt_size_to_cpu(*size);
|
|
debug("addr=%08lx, size=%08x\n",
|
|
(ulong)addr, *sizep);
|
|
} else {
|
|
debug("%08lx\n", (ulong)addr);
|
|
}
|
|
return addr;
|
|
}
|
|
debug("(not found)\n");
|
|
return FDT_ADDR_T_NONE;
|
|
}
|
|
|
|
fdt_addr_t fdtdec_get_addr(const void *blob, int node,
|
|
const char *prop_name)
|
|
{
|
|
return fdtdec_get_addr_size(blob, node, prop_name, NULL);
|
|
}
|
|
|
|
s32 fdtdec_get_int(const void *blob, int node, const char *prop_name,
|
|
s32 default_val)
|
|
{
|
|
const s32 *cell;
|
|
int len;
|
|
|
|
debug("%s: %s: ", __func__, prop_name);
|
|
cell = fdt_getprop(blob, node, prop_name, &len);
|
|
if (cell && len >= sizeof(s32)) {
|
|
s32 val = fdt32_to_cpu(cell[0]);
|
|
|
|
debug("%#x (%d)\n", val, val);
|
|
return val;
|
|
}
|
|
debug("(not found)\n");
|
|
return default_val;
|
|
}
|
|
|
|
uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name,
|
|
uint64_t default_val)
|
|
{
|
|
const uint64_t *cell64;
|
|
int length;
|
|
|
|
cell64 = fdt_getprop(blob, node, prop_name, &length);
|
|
if (!cell64 || length < sizeof(*cell64))
|
|
return default_val;
|
|
|
|
return fdt64_to_cpu(*cell64);
|
|
}
|
|
|
|
int fdtdec_get_is_enabled(const void *blob, int node)
|
|
{
|
|
const char *cell;
|
|
|
|
/*
|
|
* It should say "okay", so only allow that. Some fdts use "ok" but
|
|
* this is a bug. Please fix your device tree source file. See here
|
|
* for discussion:
|
|
*
|
|
* http://www.mail-archive.com/u-boot@lists.denx.de/msg71598.html
|
|
*/
|
|
cell = fdt_getprop(blob, node, "status", NULL);
|
|
if (cell)
|
|
return 0 == strcmp(cell, "okay");
|
|
return 1;
|
|
}
|
|
|
|
enum fdt_compat_id fdtdec_lookup(const void *blob, int node)
|
|
{
|
|
enum fdt_compat_id id;
|
|
|
|
/* Search our drivers */
|
|
for (id = COMPAT_UNKNOWN; id < COMPAT_COUNT; id++)
|
|
if (0 == fdt_node_check_compatible(blob, node,
|
|
compat_names[id]))
|
|
return id;
|
|
return COMPAT_UNKNOWN;
|
|
}
|
|
|
|
int fdtdec_next_compatible(const void *blob, int node,
|
|
enum fdt_compat_id id)
|
|
{
|
|
return fdt_node_offset_by_compatible(blob, node, compat_names[id]);
|
|
}
|
|
|
|
int fdtdec_next_compatible_subnode(const void *blob, int node,
|
|
enum fdt_compat_id id, int *depthp)
|
|
{
|
|
do {
|
|
node = fdt_next_node(blob, node, depthp);
|
|
} while (*depthp > 1);
|
|
|
|
/* If this is a direct subnode, and compatible, return it */
|
|
if (*depthp == 1 && 0 == fdt_node_check_compatible(
|
|
blob, node, compat_names[id]))
|
|
return node;
|
|
|
|
return -FDT_ERR_NOTFOUND;
|
|
}
|
|
|
|
int fdtdec_next_alias(const void *blob, const char *name,
|
|
enum fdt_compat_id id, int *upto)
|
|
{
|
|
#define MAX_STR_LEN 20
|
|
char str[MAX_STR_LEN + 20];
|
|
int node, err;
|
|
|
|
/* snprintf() is not available */
|
|
assert(strlen(name) < MAX_STR_LEN);
|
|
sprintf(str, "%.*s%d", MAX_STR_LEN, name, *upto);
|
|
node = fdt_path_offset(blob, str);
|
|
if (node < 0)
|
|
return node;
|
|
err = fdt_node_check_compatible(blob, node, compat_names[id]);
|
|
if (err < 0)
|
|
return err;
|
|
if (err)
|
|
return -FDT_ERR_NOTFOUND;
|
|
(*upto)++;
|
|
return node;
|
|
}
|
|
|
|
int fdtdec_find_aliases_for_id(const void *blob, const char *name,
|
|
enum fdt_compat_id id, int *node_list, int maxcount)
|
|
{
|
|
memset(node_list, '\0', sizeof(*node_list) * maxcount);
|
|
|
|
return fdtdec_add_aliases_for_id(blob, name, id, node_list, maxcount);
|
|
}
|
|
|
|
/* TODO: Can we tighten this code up a little? */
|
|
int fdtdec_add_aliases_for_id(const void *blob, const char *name,
|
|
enum fdt_compat_id id, int *node_list, int maxcount)
|
|
{
|
|
int name_len = strlen(name);
|
|
int nodes[maxcount];
|
|
int num_found = 0;
|
|
int offset, node;
|
|
int alias_node;
|
|
int count;
|
|
int i, j;
|
|
|
|
/* find the alias node if present */
|
|
alias_node = fdt_path_offset(blob, "/aliases");
|
|
|
|
/*
|
|
* start with nothing, and we can assume that the root node can't
|
|
* match
|
|
*/
|
|
memset(nodes, '\0', sizeof(nodes));
|
|
|
|
/* First find all the compatible nodes */
|
|
for (node = count = 0; node >= 0 && count < maxcount;) {
|
|
node = fdtdec_next_compatible(blob, node, id);
|
|
if (node >= 0)
|
|
nodes[count++] = node;
|
|
}
|
|
if (node >= 0)
|
|
debug("%s: warning: maxcount exceeded with alias '%s'\n",
|
|
__func__, name);
|
|
|
|
/* Now find all the aliases */
|
|
for (offset = fdt_first_property_offset(blob, alias_node);
|
|
offset > 0;
|
|
offset = fdt_next_property_offset(blob, offset)) {
|
|
const struct fdt_property *prop;
|
|
const char *path;
|
|
int number;
|
|
int found;
|
|
|
|
node = 0;
|
|
prop = fdt_get_property_by_offset(blob, offset, NULL);
|
|
path = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
|
|
if (prop->len && 0 == strncmp(path, name, name_len))
|
|
node = fdt_path_offset(blob, prop->data);
|
|
if (node <= 0)
|
|
continue;
|
|
|
|
/* Get the alias number */
|
|
number = simple_strtoul(path + name_len, NULL, 10);
|
|
if (number < 0 || number >= maxcount) {
|
|
debug("%s: warning: alias '%s' is out of range\n",
|
|
__func__, path);
|
|
continue;
|
|
}
|
|
|
|
/* Make sure the node we found is actually in our list! */
|
|
found = -1;
|
|
for (j = 0; j < count; j++)
|
|
if (nodes[j] == node) {
|
|
found = j;
|
|
break;
|
|
}
|
|
|
|
if (found == -1) {
|
|
debug("%s: warning: alias '%s' points to a node "
|
|
"'%s' that is missing or is not compatible "
|
|
" with '%s'\n", __func__, path,
|
|
fdt_get_name(blob, node, NULL),
|
|
compat_names[id]);
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Add this node to our list in the right place, and mark
|
|
* it as done.
|
|
*/
|
|
if (fdtdec_get_is_enabled(blob, node)) {
|
|
if (node_list[number]) {
|
|
debug("%s: warning: alias '%s' requires that "
|
|
"a node be placed in the list in a "
|
|
"position which is already filled by "
|
|
"node '%s'\n", __func__, path,
|
|
fdt_get_name(blob, node, NULL));
|
|
continue;
|
|
}
|
|
node_list[number] = node;
|
|
if (number >= num_found)
|
|
num_found = number + 1;
|
|
}
|
|
nodes[found] = 0;
|
|
}
|
|
|
|
/* Add any nodes not mentioned by an alias */
|
|
for (i = j = 0; i < maxcount; i++) {
|
|
if (!node_list[i]) {
|
|
for (; j < maxcount; j++)
|
|
if (nodes[j] &&
|
|
fdtdec_get_is_enabled(blob, nodes[j]))
|
|
break;
|
|
|
|
/* Have we run out of nodes to add? */
|
|
if (j == maxcount)
|
|
break;
|
|
|
|
assert(!node_list[i]);
|
|
node_list[i] = nodes[j++];
|
|
if (i >= num_found)
|
|
num_found = i + 1;
|
|
}
|
|
}
|
|
|
|
return num_found;
|
|
}
|
|
|
|
int fdtdec_check_fdt(void)
|
|
{
|
|
/*
|
|
* We must have an FDT, but we cannot panic() yet since the console
|
|
* is not ready. So for now, just assert(). Boards which need an early
|
|
* FDT (prior to console ready) will need to make their own
|
|
* arrangements and do their own checks.
|
|
*/
|
|
assert(!fdtdec_prepare_fdt());
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This function is a little odd in that it accesses global data. At some
|
|
* point if the architecture board.c files merge this will make more sense.
|
|
* Even now, it is common code.
|
|
*/
|
|
int fdtdec_prepare_fdt(void)
|
|
{
|
|
if (!gd->fdt_blob || ((uintptr_t)gd->fdt_blob & 3) ||
|
|
fdt_check_header(gd->fdt_blob)) {
|
|
printf("No valid FDT found - please append one to U-Boot "
|
|
"binary, use u-boot-dtb.bin or define "
|
|
"CONFIG_OF_EMBED. For sandbox, use -d <file.dtb>\n");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name)
|
|
{
|
|
const u32 *phandle;
|
|
int lookup;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
phandle = fdt_getprop(blob, node, prop_name, NULL);
|
|
if (!phandle)
|
|
return -FDT_ERR_NOTFOUND;
|
|
|
|
lookup = fdt_node_offset_by_phandle(blob, fdt32_to_cpu(*phandle));
|
|
return lookup;
|
|
}
|
|
|
|
/**
|
|
* Look up a property in a node and check that it has a minimum length.
|
|
*
|
|
* @param blob FDT blob
|
|
* @param node node to examine
|
|
* @param prop_name name of property to find
|
|
* @param min_len minimum property length in bytes
|
|
* @param err 0 if ok, or -FDT_ERR_NOTFOUND if the property is not
|
|
found, or -FDT_ERR_BADLAYOUT if not enough data
|
|
* @return pointer to cell, which is only valid if err == 0
|
|
*/
|
|
static const void *get_prop_check_min_len(const void *blob, int node,
|
|
const char *prop_name, int min_len, int *err)
|
|
{
|
|
const void *cell;
|
|
int len;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
cell = fdt_getprop(blob, node, prop_name, &len);
|
|
if (!cell)
|
|
*err = -FDT_ERR_NOTFOUND;
|
|
else if (len < min_len)
|
|
*err = -FDT_ERR_BADLAYOUT;
|
|
else
|
|
*err = 0;
|
|
return cell;
|
|
}
|
|
|
|
int fdtdec_get_int_array(const void *blob, int node, const char *prop_name,
|
|
u32 *array, int count)
|
|
{
|
|
const u32 *cell;
|
|
int i, err = 0;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
cell = get_prop_check_min_len(blob, node, prop_name,
|
|
sizeof(u32) * count, &err);
|
|
if (!err) {
|
|
for (i = 0; i < count; i++)
|
|
array[i] = fdt32_to_cpu(cell[i]);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
const u32 *fdtdec_locate_array(const void *blob, int node,
|
|
const char *prop_name, int count)
|
|
{
|
|
const u32 *cell;
|
|
int err;
|
|
|
|
cell = get_prop_check_min_len(blob, node, prop_name,
|
|
sizeof(u32) * count, &err);
|
|
return err ? NULL : cell;
|
|
}
|
|
|
|
int fdtdec_get_bool(const void *blob, int node, const char *prop_name)
|
|
{
|
|
const s32 *cell;
|
|
int len;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
cell = fdt_getprop(blob, node, prop_name, &len);
|
|
return cell != NULL;
|
|
}
|
|
|
|
/**
|
|
* Decode a list of GPIOs from an FDT. This creates a list of GPIOs with no
|
|
* terminating item.
|
|
*
|
|
* @param blob FDT blob to use
|
|
* @param node Node to look at
|
|
* @param prop_name Node property name
|
|
* @param gpio Array of gpio elements to fill from FDT. This will be
|
|
* untouched if either 0 or an error is returned
|
|
* @param max_count Maximum number of elements allowed
|
|
* @return number of GPIOs read if ok, -FDT_ERR_BADLAYOUT if max_count would
|
|
* be exceeded, or -FDT_ERR_NOTFOUND if the property is missing.
|
|
*/
|
|
int fdtdec_decode_gpios(const void *blob, int node, const char *prop_name,
|
|
struct fdt_gpio_state *gpio, int max_count)
|
|
{
|
|
const struct fdt_property *prop;
|
|
const u32 *cell;
|
|
const char *name;
|
|
int len, i;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
assert(max_count > 0);
|
|
prop = fdt_get_property(blob, node, prop_name, &len);
|
|
if (!prop) {
|
|
debug("%s: property '%s' missing\n", __func__, prop_name);
|
|
return -FDT_ERR_NOTFOUND;
|
|
}
|
|
|
|
/* We will use the name to tag the GPIO */
|
|
name = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
|
|
cell = (u32 *)prop->data;
|
|
len /= sizeof(u32) * 3; /* 3 cells per GPIO record */
|
|
if (len > max_count) {
|
|
debug(" %s: too many GPIOs / cells for "
|
|
"property '%s'\n", __func__, prop_name);
|
|
return -FDT_ERR_BADLAYOUT;
|
|
}
|
|
|
|
/* Read out the GPIO data from the cells */
|
|
for (i = 0; i < len; i++, cell += 3) {
|
|
gpio[i].gpio = fdt32_to_cpu(cell[1]);
|
|
gpio[i].flags = fdt32_to_cpu(cell[2]);
|
|
gpio[i].name = name;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
int fdtdec_decode_gpio(const void *blob, int node, const char *prop_name,
|
|
struct fdt_gpio_state *gpio)
|
|
{
|
|
int err;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
gpio->gpio = FDT_GPIO_NONE;
|
|
gpio->name = NULL;
|
|
err = fdtdec_decode_gpios(blob, node, prop_name, gpio, 1);
|
|
return err == 1 ? 0 : err;
|
|
}
|
|
|
|
int fdtdec_get_gpio(struct fdt_gpio_state *gpio)
|
|
{
|
|
int val;
|
|
|
|
if (!fdt_gpio_isvalid(gpio))
|
|
return -1;
|
|
|
|
val = gpio_get_value(gpio->gpio);
|
|
return gpio->flags & FDT_GPIO_ACTIVE_LOW ? val ^ 1 : val;
|
|
}
|
|
|
|
int fdtdec_set_gpio(struct fdt_gpio_state *gpio, int val)
|
|
{
|
|
if (!fdt_gpio_isvalid(gpio))
|
|
return -1;
|
|
|
|
val = gpio->flags & FDT_GPIO_ACTIVE_LOW ? val ^ 1 : val;
|
|
return gpio_set_value(gpio->gpio, val);
|
|
}
|
|
|
|
int fdtdec_setup_gpio(struct fdt_gpio_state *gpio)
|
|
{
|
|
/*
|
|
* Return success if there is no GPIO defined. This is used for
|
|
* optional GPIOs)
|
|
*/
|
|
if (!fdt_gpio_isvalid(gpio))
|
|
return 0;
|
|
|
|
if (gpio_request(gpio->gpio, gpio->name))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name,
|
|
u8 *array, int count)
|
|
{
|
|
const u8 *cell;
|
|
int err;
|
|
|
|
cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
|
|
if (!err)
|
|
memcpy(array, cell, count);
|
|
return err;
|
|
}
|
|
|
|
const u8 *fdtdec_locate_byte_array(const void *blob, int node,
|
|
const char *prop_name, int count)
|
|
{
|
|
const u8 *cell;
|
|
int err;
|
|
|
|
cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
|
|
if (err)
|
|
return NULL;
|
|
return cell;
|
|
}
|
|
|
|
int fdtdec_get_config_int(const void *blob, const char *prop_name,
|
|
int default_val)
|
|
{
|
|
int config_node;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
config_node = fdt_path_offset(blob, "/config");
|
|
if (config_node < 0)
|
|
return default_val;
|
|
return fdtdec_get_int(blob, config_node, prop_name, default_val);
|
|
}
|
|
|
|
int fdtdec_get_config_bool(const void *blob, const char *prop_name)
|
|
{
|
|
int config_node;
|
|
const void *prop;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
config_node = fdt_path_offset(blob, "/config");
|
|
if (config_node < 0)
|
|
return 0;
|
|
prop = fdt_get_property(blob, config_node, prop_name, NULL);
|
|
|
|
return prop != NULL;
|
|
}
|
|
|
|
char *fdtdec_get_config_string(const void *blob, const char *prop_name)
|
|
{
|
|
const char *nodep;
|
|
int nodeoffset;
|
|
int len;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
nodeoffset = fdt_path_offset(blob, "/config");
|
|
if (nodeoffset < 0)
|
|
return NULL;
|
|
|
|
nodep = fdt_getprop(blob, nodeoffset, prop_name, &len);
|
|
if (!nodep)
|
|
return NULL;
|
|
|
|
return (char *)nodep;
|
|
}
|
|
|
|
int fdtdec_decode_region(const void *blob, int node,
|
|
const char *prop_name, void **ptrp, size_t *size)
|
|
{
|
|
const fdt_addr_t *cell;
|
|
int len;
|
|
|
|
debug("%s: %s\n", __func__, prop_name);
|
|
cell = fdt_getprop(blob, node, prop_name, &len);
|
|
if (!cell || (len != sizeof(fdt_addr_t) * 2))
|
|
return -1;
|
|
|
|
*ptrp = map_sysmem(fdt_addr_to_cpu(*cell), *size);
|
|
*size = fdt_size_to_cpu(cell[1]);
|
|
debug("%s: size=%zx\n", __func__, *size);
|
|
return 0;
|
|
}
|