From owner-svn-src-all@FreeBSD.ORG Tue May 25 15:21:39 2010 Return-Path: Delivered-To: svn-src-all@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id B1F1D1065674; Tue, 25 May 2010 15:21:39 +0000 (UTC) (envelope-from raj@FreeBSD.org) Received: from svn.freebsd.org (unknown [IPv6:2001:4f8:fff6::2c]) by mx1.freebsd.org (Postfix) with ESMTP id 9E3238FC21; Tue, 25 May 2010 15:21:39 +0000 (UTC) Received: from svn.freebsd.org (localhost [127.0.0.1]) by svn.freebsd.org (8.14.3/8.14.3) with ESMTP id o4PFLd4H060686; Tue, 25 May 2010 15:21:39 GMT (envelope-from raj@svn.freebsd.org) Received: (from raj@localhost) by svn.freebsd.org (8.14.3/8.14.3/Submit) id o4PFLdFa060679; Tue, 25 May 2010 15:21:39 GMT (envelope-from raj@svn.freebsd.org) Message-Id: <201005251521.o4PFLdFa060679@svn.freebsd.org> From: Rafal Jaworowski Date: Tue, 25 May 2010 15:21:39 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org X-SVN-Group: head MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cc: Subject: svn commit: r208538 - in head/sys: arm/include boot/arm/uboot boot/fdt boot/powerpc/uboot boot/uboot/common boot/uboot/lib powerpc/include X-BeenThere: svn-src-all@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: "SVN commit messages for the entire src tree \(except for " user" and " projects" \)" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 25 May 2010 15:21:39 -0000 Author: raj Date: Tue May 25 15:21:39 2010 New Revision: 208538 URL: http://svn.freebsd.org/changeset/base/208538 Log: Initial loader(8) support for Flattened Device Tree. o This is disabled by default for now, and can be enabled using WITH_FDT at build time. o Tested with ARM and PowerPC. Reviewed by: imp Sponsored by: The FreeBSD Foundation Added: head/sys/boot/fdt/ head/sys/boot/fdt/Makefile (contents, props changed) head/sys/boot/fdt/fdt_loader_cmd.c (contents, props changed) Modified: head/sys/arm/include/metadata.h head/sys/boot/arm/uboot/Makefile head/sys/boot/arm/uboot/version head/sys/boot/powerpc/uboot/Makefile head/sys/boot/powerpc/uboot/version head/sys/boot/uboot/common/main.c head/sys/boot/uboot/common/metadata.c head/sys/boot/uboot/lib/Makefile head/sys/powerpc/include/metadata.h Modified: head/sys/arm/include/metadata.h ============================================================================== --- head/sys/arm/include/metadata.h Tue May 25 15:12:21 2010 (r208537) +++ head/sys/arm/include/metadata.h Tue May 25 15:21:39 2010 (r208538) @@ -30,5 +30,6 @@ #define _MACHINE_METADATA_H_ #define MODINFOMD_BOOTINFO 0x1001 +#define MODINFOMD_DTBP 0x1002 #endif /* !_MACHINE_METADATA_H_ */ Modified: head/sys/boot/arm/uboot/Makefile ============================================================================== --- head/sys/boot/arm/uboot/Makefile Tue May 25 15:12:21 2010 (r208537) +++ head/sys/boot/arm/uboot/Makefile Tue May 25 15:21:39 2010 (r208538) @@ -18,6 +18,11 @@ LOADER_NFS_SUPPORT?= yes LOADER_TFTP_SUPPORT?= no LOADER_GZIP_SUPPORT?= no LOADER_BZIP2_SUPPORT?= no +.if defined(WITH_FDT) +LOADER_FDT_SUPPORT= yes +.else +LOADER_FDT_SUPPORT= no +.endif .if ${LOADER_DISK_SUPPORT} == "yes" CFLAGS+= -DLOADER_DISK_SUPPORT @@ -46,6 +51,12 @@ CFLAGS+= -DLOADER_NFS_SUPPORT .if ${LOADER_TFTP_SUPPORT} == "yes" CFLAGS+= -DLOADER_TFTP_SUPPORT .endif +.if ${LOADER_FDT_SUPPORT} == "yes" +CFLAGS+= -I${.CURDIR}/../../fdt +CFLAGS+= -I${.OBJDIR}/../../fdt +CFLAGS+= -DLOADER_FDT_SUPPORT +LIBFDT= ${.OBJDIR}/../../fdt/libfdt.a +.endif .if !defined(NO_FORTH) # Enable BootForth @@ -79,8 +90,8 @@ CFLAGS+= -I${.OBJDIR}/../../uboot/lib # where to get libstand from CFLAGS+= -I${.CURDIR}/../../../../lib/libstand/ -DPADD= ${LIBFICL} ${LIBUBOOT} ${LIBSTAND} -LDADD= ${LIBFICL} ${LIBUBOOT} -lstand +DPADD= ${LIBFICL} ${LIBUBOOT} ${LIBFDT} ${LIBSTAND} +LDADD= ${LIBFICL} ${LIBUBOOT} ${LIBFDT} -lstand vers.c: ${.CURDIR}/../../common/newvers.sh ${.CURDIR}/version sh ${.CURDIR}/../../common/newvers.sh ${.CURDIR}/version ${NEWVERSWHAT} Modified: head/sys/boot/arm/uboot/version ============================================================================== --- head/sys/boot/arm/uboot/version Tue May 25 15:12:21 2010 (r208537) +++ head/sys/boot/arm/uboot/version Tue May 25 15:21:39 2010 (r208538) @@ -3,5 +3,6 @@ $FreeBSD$ NOTE ANY CHANGES YOU MAKE TO THE BOOTBLOCKS HERE. The format of this file is important. Make sure the current version number is on line 6. +1.1: Flattened Device Tree blob support. 1.0: Added storage support. Booting from HDD, USB, etc. is now possible. 0.5: Initial U-Boot/arm version (netbooting only). Added: head/sys/boot/fdt/Makefile ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/boot/fdt/Makefile Tue May 25 15:21:39 2010 (r208538) @@ -0,0 +1,25 @@ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../contrib/libfdt/ + +LIB= fdt +INTERNALLIB= + +# Vendor sources of libfdt. +SRCS+= fdt.c fdt_ro.c fdt_wip.c fdt_sw.c fdt_rw.c fdt_strerror.c + +# Loader's fdt commands extension sources. +SRCS+= fdt_loader_cmd.c + +CFLAGS+= -I${.CURDIR}/../../contrib/libfdt/ -I${.CURDIR}/../common/ \ + -I${.CURDIR}/../uboot/lib + +CFLAGS+= -ffreestanding + +.if ${MACHINE_ARCH} == "powerpc" || ${MACHINE_ARCH} == "arm" +CFLAGS+= -msoft-float +.endif + +CFLAGS+= -Wformat -Wall + +.include Added: head/sys/boot/fdt/fdt_loader_cmd.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/boot/fdt/fdt_loader_cmd.c Tue May 25 15:21:39 2010 (r208538) @@ -0,0 +1,1290 @@ +/*- + * Copyright (c) 2009-2010 The FreeBSD Foundation + * All rights reserved. + * + * This software was developed by Semihalf under sponsorship from + * the FreeBSD Foundation. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include + +#include "bootstrap.h" +#include "glue.h" + +#define DEBUG + +#ifdef DEBUG +#define debugf(fmt, args...) do { printf("%s(): ", __func__); \ + printf(fmt,##args); } while (0) +#else +#define debugf(fmt, args...) +#endif + +#define FDT_CWD_LEN 256 +#define FDT_MAX_DEPTH 6 + +#define FDT_PROP_SEP " = " + +#define STR(number) #number +#define STRINGIFY(number) STR(number) + +#define MIN(num1, num2) (((num1) < (num2)) ? (num1):(num2)) + +static struct fdt_header *fdtp = NULL; + +static int fdt_cmd_nyi(int argc, char *argv[]); + +static int fdt_cmd_mkprop(int argc, char *argv[]); +static int fdt_cmd_cd(int argc, char *argv[]); +static int fdt_cmd_hdr(int argc, char *argv[]); +static int fdt_cmd_ls(int argc, char *argv[]); +static int fdt_cmd_prop(int argc, char *argv[]); +static int fdt_cmd_pwd(int argc, char *argv[]); +static int fdt_cmd_rm(int argc, char *argv[]); +static int fdt_cmd_mknode(int argc, char *argv[]); + +typedef int cmdf_t(int, char *[]); + +struct cmdtab { + char *name; + cmdf_t *handler; +}; + +static const struct cmdtab commands[] = { + { "alias", &fdt_cmd_nyi }, + { "cd", &fdt_cmd_cd }, + { "header", &fdt_cmd_hdr }, + { "ls", &fdt_cmd_ls }, + { "mknode", &fdt_cmd_mknode }, + { "mkprop", &fdt_cmd_mkprop }, + { "mres", &fdt_cmd_nyi }, + { "prop", &fdt_cmd_prop }, + { "pwd", &fdt_cmd_pwd }, + { "rm", &fdt_cmd_rm }, + { NULL, NULL } +}; + +static char cwd[FDT_CWD_LEN] = "/"; + +static int +fdt_setup_fdtp() +{ + struct preloaded_file *bfp; + int err; + + /* + * Find the device tree blob. + */ + bfp = file_findfile(NULL, "dtb"); + if (bfp == NULL) { + command_errmsg = "no device tree blob loaded"; + return (CMD_ERROR); + } + fdtp = (struct fdt_header *)bfp->f_addr; + + /* + * Validate the blob. + */ + err = fdt_check_header(fdtp); + if (err < 0) { + if (err == -FDT_ERR_BADVERSION) + sprintf(command_errbuf, + "incompatible blob version: %d, should be: %d", + fdt_version(fdtp), FDT_LAST_SUPPORTED_VERSION); + + else + sprintf(command_errbuf, "error validating blob: %s", + fdt_strerror(err)); + return (CMD_ERROR); + } + return (CMD_OK); +} + +#define fdt_strtovect(str, cellbuf, lim, cellsize) _fdt_strtovect((str), \ + (cellbuf), (lim), (cellsize), 0); + +/* Force using base 16 */ +#define fdt_strtovectx(str, cellbuf, lim, cellsize) _fdt_strtovect((str), \ + (cellbuf), (lim), (cellsize), 16); + +static int +_fdt_strtovect(char *str, void *cellbuf, int lim, unsigned char cellsize, + uint8_t base) +{ + char *buf = str; + char *end = str + strlen(str) - 2; + uint32_t *u32buf = NULL; + uint8_t *u8buf = NULL; + int cnt = 0; + + if (cellsize == sizeof(uint32_t)) + u32buf = (uint32_t *)cellbuf; + else + u8buf = (uint8_t *)cellbuf; + + if (lim == 0) + return (0); + + while (buf < end) { + + /* Skip white whitespace(s)/separators */ + while (!isxdigit(*buf) && buf < end) + buf++; + + if (u32buf != NULL) + u32buf[cnt] = + cpu_to_fdt32((uint32_t)strtol(buf, NULL, base)); + + else + u8buf[cnt] = (uint8_t)strtol(buf, NULL, base); + + if (cnt + 1 <= lim - 1) + cnt++; + else + break; + buf++; + /* Find another number */ + while ((isxdigit(*buf) || *buf == 'x') && buf < end) + buf++; + } + return (cnt); +} + +#define TMP_MAX_ETH 8 + +void +fixup_ethernet(const char *env, char *ethstr, int *eth_no, int len) +{ + char *end, *str; + uint8_t tmp_addr[6]; + int i, n; + + /* Extract interface number */ + i = strtol(env + 3, &end, 10); + if (end == (env + 3)) + /* 'ethaddr' means interface 0 address */ + n = 0; + else + n = i; + + if (n > TMP_MAX_ETH) + return; + + str = ub_env_get(env); + + /* Convert macaddr string into a vector of uints */ + fdt_strtovectx(str, &tmp_addr, 6, sizeof(uint8_t)); + if (n != 0) { + i = strlen(env) - 7; + strncpy(ethstr + 8, env + 3, i); + } + /* Set actual property to a value from vect */ + fdt_setprop(fdtp, fdt_path_offset(fdtp, ethstr), + "local-mac-address", &tmp_addr, 6 * sizeof(uint8_t)); + + /* Clear ethernet..XXXX.. string */ + bzero(ethstr + 8, len - 8); + + if (n + 1 > *eth_no) + *eth_no = n + 1; +} + +void +fixup_cpubusfreqs(unsigned long cpufreq, unsigned long busfreq) +{ + int lo, o = 0, o2, maxo = 0, depth; + const uint32_t zero = 0; + + /* We want to modify every subnode of /cpus */ + o = fdt_path_offset(fdtp, "/cpus"); + + /* maxo should contain offset of node next to /cpus */ + depth = 0; + maxo = o; + while (depth != -1) + maxo = fdt_next_node(fdtp, maxo, &depth); + + /* Find CPU frequency properties */ + o = fdt_node_offset_by_prop_value(fdtp, o, "clock-frequency", + &zero, sizeof(uint32_t)); + + o2 = fdt_node_offset_by_prop_value(fdtp, o, "bus-frequency", &zero, + sizeof(uint32_t)); + + lo = MIN(o, o2); + + while (o != -FDT_ERR_NOTFOUND && o2 != -FDT_ERR_NOTFOUND) { + + o = fdt_node_offset_by_prop_value(fdtp, lo, + "clock-frequency", &zero, sizeof(uint32_t)); + + o2 = fdt_node_offset_by_prop_value(fdtp, lo, "bus-frequency", + &zero, sizeof(uint32_t)); + + /* We're only interested in /cpus subnode(s) */ + if (lo > maxo) + break; + + fdt_setprop_inplace_cell(fdtp, lo, "clock-frequency", + (uint32_t)cpufreq); + + fdt_setprop_inplace_cell(fdtp, lo, "bus-frequency", + (uint32_t)busfreq); + + lo = MIN(o, o2); + } +} + +int +fdt_reg_valid(uint32_t *reg, int len, int addr_cells, int size_cells) +{ + int cells_in_tuple, i, tuples, tuple_size; + uint32_t cur_start, cur_size; + + cells_in_tuple = (addr_cells + size_cells); + tuple_size = cells_in_tuple * sizeof(uint32_t); + tuples = len / tuple_size; + if (tuples == 0) + return (EINVAL); + + for (i = 0; i < tuples; i++) { + if (addr_cells == 2) + cur_start = fdt64_to_cpu(reg[i * cells_in_tuple]); + else + cur_start = fdt32_to_cpu(reg[i * cells_in_tuple]); + + if (size_cells == 2) + cur_size = fdt64_to_cpu(reg[i * cells_in_tuple + 2]); + else + cur_size = fdt32_to_cpu(reg[i * cells_in_tuple + 1]); + + if (cur_size == 0) + return (EINVAL); + + debugf(" reg#%d (start: 0x%0x size: 0x%0x) valid!\n", + i, cur_start, cur_size); + } + return (0); +} + +void +fixup_memory(struct sys_info *si) +{ + struct mem_region *curmr; + uint32_t addr_cells, size_cells; + uint32_t *addr_cellsp, *reg, *size_cellsp; + int err, i, len, memory, realmrno, root; + uint8_t *buf, *sb; + + root = fdt_path_offset(fdtp, "/"); + if (root < 0) { + sprintf(command_errbuf, "Could not find root node !"); + return; + } + + memory = fdt_path_offset(fdtp, "/memory"); + if (memory <= 0) { + /* Create proper '/memory' node. */ + memory = fdt_add_subnode(fdtp, root, "memory"); + if (memory <= 0) { + sprintf(command_errbuf, "Could not fixup '/memory' " + "node, error code : %d!\n", memory); + return; + } + + err = fdt_setprop(fdtp, memory, "device_type", "memory", + sizeof("memory")); + + if (err < 0) + return; + } + + addr_cellsp = (uint32_t *)fdt_getprop(fdtp, root, "#address-cells", + NULL); + size_cellsp = (uint32_t *)fdt_getprop(fdtp, root, "#size-cells", NULL); + + if (addr_cellsp == NULL || size_cellsp == NULL) { + sprintf(command_errbuf, "Could not fixup '/memory' node : " + "%s %s property not found in root node!\n", + (!addr_cellsp) ? "#address-cells" : "", + (!size_cellsp) ? "#size-cells" : ""); + return; + } + + addr_cells = fdt32_to_cpu(*addr_cellsp); + size_cells = fdt32_to_cpu(*size_cellsp); + + /* Count valid memory regions entries in sysinfo. */ + realmrno = si->mr_no; + for (i = 0; i < si->mr_no; i++) + if (si->mr[i].start == 0 && si->mr[i].size == 0) + realmrno--; + + if (realmrno == 0) { + sprintf(command_errbuf, "Could not fixup '/memory' node : " + "sysinfo doesn't contain valid memory regions info!\n"); + return; + } + + if ((reg = (uint32_t *)fdt_getprop(fdtp, memory, "reg", + &len)) != NULL) { + + if (fdt_reg_valid(reg, len, addr_cells, size_cells) == 0) + /* + * Do not apply fixup if existing 'reg' property + * seems to be valid. + */ + return; + } + + len = (addr_cells + size_cells) * realmrno * sizeof(uint32_t); + sb = buf = (uint8_t *)malloc(len); + if (!buf) + return; + + bzero(buf, len); + + for (i = 0; i < si->mr_no; i++) { + curmr = &si->mr[i]; + if (curmr->size != 0) { + /* Ensure endianess, and put cells into a buffer */ + if (addr_cells == 2) + *(uint64_t *)buf = + cpu_to_fdt64(curmr->start); + else + *(uint32_t *)buf = + cpu_to_fdt32(curmr->start); + + buf += sizeof(uint32_t) * addr_cells; + if (size_cells == 2) + *(uint64_t *)buf = + cpu_to_fdt64(curmr->size); + else + *(uint32_t *)buf = + cpu_to_fdt32(curmr->size); + + buf += sizeof(uint32_t) * size_cells; + } + } + + /* Set property */ + if ((err = fdt_setprop(fdtp, memory, "reg", sb, len)) < 0) + sprintf(command_errbuf, "Could not fixup '/memory' node.\n"); +} + +void +fixup_stdout(const char *env) +{ + const char *str; + char *ptr; + int serialno; + int len, no, sero; + const struct fdt_property *prop; + char *tmp[10]; + + str = ub_env_get(env); + ptr = (char *)str + strlen(str) - 1; + while (ptr > str && isdigit(*(str - 1))) + str--; + + if (ptr == str) + return; + + serialno = (int)strtol(ptr, NULL, 0); + no = fdt_path_offset(fdtp, "/chosen"); + if (no < 0) + return; + + prop = fdt_get_property(fdtp, no, "stdout", &len); + + /* If /chosen/stdout does not extist, create it */ + if (prop == NULL || (prop != NULL && len == 0)) { + + bzero(tmp, 10 * sizeof(char)); + strcpy((char *)&tmp, "serial"); + if (strlen(ptr) > 3) + /* Serial number too long */ + return; + + strncpy((char *)tmp + 6, ptr, 3); + sero = fdt_path_offset(fdtp, (const char *)tmp); + if (sero < 0) + /* + * If serial device we're trying to assign + * stdout to doesn't exist in DT -- return. + */ + return; + + fdt_setprop(fdtp, no, "stdout", &tmp, + strlen((char *)&tmp) + 1); + fdt_setprop(fdtp, no, "stdin", &tmp, + strlen((char *)&tmp) + 1); + } +} + +int +fdt_fixup(void) +{ + const char *env; + char *ethstr; + int chosen, err, eth_no, len; + struct sys_info *si; + + env = NULL; + eth_no = 0; + ethstr = NULL; + len = 0; + + if (!fdtp) { + err = fdt_setup_fdtp(); + if (err) { + sprintf(command_errbuf, "Could not perform blob " + "fixups. Error code: %d\n", err); + return (err); + } + } + + /* Create /chosen node (if not exists) */ + if ((chosen = fdt_subnode_offset(fdtp, 0, "chosen")) == + -FDT_ERR_NOTFOUND) + chosen = fdt_add_subnode(fdtp, 0, "chosen"); + + /* Value assigned to fixup-applied does not matter. */ + if (fdt_getprop(fdtp, chosen, "fixup-applied", NULL)) + return (CMD_OK); + + /* Acquire sys_info */ + si = ub_get_sys_info(); + + while ((env = ub_env_enum(env)) != NULL) { + if (strncmp(env, "eth", 3) == 0 && + strncmp(env + (strlen(env) - 4), "addr", 4) == 0) { + /* + * Handle Ethernet addrs: parse uboot env eth%daddr + */ + + if (!eth_no) { + /* + * Check how many chars we will need to store + * maximal eth iface number. + */ + len = strlen(STRINGIFY(TMP_MAX_ETH)) + + strlen("ethernet"); + + /* + * Reserve mem for string "ethernet" and len + * chars for iface no. + */ + ethstr = (char *)malloc(len * sizeof(char)); + bzero(ethstr, len * sizeof(char)); + strcpy(ethstr, "ethernet0"); + } + + /* Modify blob */ + fixup_ethernet(env, ethstr, ð_no, len); + + } else if (strcmp(env, "consoledev") == 0) + fixup_stdout(env); + } + + /* Modify cpu(s) and bus clock frequenties in /cpus node [Hz] */ + fixup_cpubusfreqs(si->clk_cpu, si->clk_bus); + + /* Fixup memory regions */ + fixup_memory(si); + + fdt_setprop(fdtp, chosen, "fixup-applied", NULL, 0); + + return (CMD_OK); +} + +int +command_fdt_internal(int argc, char *argv[]) +{ + cmdf_t *cmdh; + char *cmd; + int i, err; + + if (argc < 2) { + command_errmsg = "usage is 'fdt []"; + return (CMD_ERROR); + } + + /* + * Check if uboot env vars were parsed already. If not, do it now. + */ + fdt_fixup(); + + /* + * Validate fdt . + */ + cmd = strdup(argv[1]); + i = 0; + cmdh = NULL; + while (!(commands[i].name == NULL)) { + if (strcmp(cmd, commands[i].name) == 0) { + /* found it */ + cmdh = commands[i].handler; + break; + } + i++; + } + if (cmdh == NULL) { + command_errmsg = "unknown command"; + return (CMD_ERROR); + } + + if (!fdtp) + if (fdt_setup_fdtp()) + return (CMD_ERROR); + + /* + * Call command handler. + */ + err = (*cmdh)(argc, argv); + + return (err); +} + +static int +fdt_cmd_cd(int argc, char *argv[]) +{ + char *path; + char tmp[FDT_CWD_LEN]; + int len, o; + + path = (argc > 2) ? argv[2] : "/"; + + if (path[0] == '/') { + len = strlen(path); + if (len >= FDT_CWD_LEN) + goto fail; + } else { + /* Handle path specification relative to cwd */ + len = strlen(cwd) + strlen(path) + 1; + if (len >= FDT_CWD_LEN) + goto fail; + + strcpy(tmp, cwd); + strcat(tmp, "/"); + strcat(tmp, path); + path = tmp; + } + + o = fdt_path_offset(fdtp, path); + if (o < 0) { + sprintf(command_errbuf, "could not find node: '%s'", path); + return (CMD_ERROR); + } + + strcpy(cwd, path); + return (CMD_OK); + +fail: + sprintf(command_errbuf, "path too long: %d, max allowed: %d", + len, FDT_CWD_LEN - 1); + return (CMD_ERROR); +} + +static int +fdt_cmd_hdr(int argc __unused, char *argv[] __unused) +{ + char line[80]; + int ver; + + if (fdtp == NULL) { + command_errmsg = "no device tree blob pointer?!"; + return (CMD_ERROR); + } + + ver = fdt_version(fdtp); + pager_open(); + sprintf(line, "\nFlattened device tree header (%p):\n", fdtp); + pager_output(line); + sprintf(line, " magic = 0x%08x\n", fdt_magic(fdtp)); + pager_output(line); + sprintf(line, " size = %d\n", fdt_totalsize(fdtp)); + pager_output(line); + sprintf(line, " off_dt_struct = 0x%08x\n", + fdt_off_dt_struct(fdtp)); + pager_output(line); + sprintf(line, " off_dt_strings = 0x%08x\n", + fdt_off_dt_strings(fdtp)); + pager_output(line); + sprintf(line, " off_mem_rsvmap = 0x%08x\n", + fdt_off_mem_rsvmap(fdtp)); + pager_output(line); + sprintf(line, " version = %d\n", ver); + pager_output(line); + sprintf(line, " last compatible version = %d\n", + fdt_last_comp_version(fdtp)); + pager_output(line); + if (ver >= 2) { + sprintf(line, " boot_cpuid = %d\n", + fdt_boot_cpuid_phys(fdtp)); + pager_output(line); + } + if (ver >= 3) { + sprintf(line, " size_dt_strings = %d\n", + fdt_size_dt_strings(fdtp)); + pager_output(line); + } + if (ver >= 17) { + sprintf(line, " size_dt_struct = %d\n", + fdt_size_dt_struct(fdtp)); + pager_output(line); + } + pager_close(); + + return (CMD_OK); +} + +static int +fdt_cmd_ls(int argc, char *argv[]) +{ + const char *prevname[FDT_MAX_DEPTH] = { NULL }; + const char *name; + char *path; + int i, o, depth, len; + + path = (argc > 2) ? argv[2] : NULL; + if (path == NULL) + path = cwd; + + o = fdt_path_offset(fdtp, path); + if (o < 0) { + sprintf(command_errbuf, "could not find node: '%s'", path); + return (CMD_ERROR); + } + + for (depth = 0; + (o >= 0) && (depth >= 0); + o = fdt_next_node(fdtp, o, &depth)) { + + name = fdt_get_name(fdtp, o, &len); + + if (depth > FDT_MAX_DEPTH) { + printf("max depth exceeded: %d\n", depth); + continue; + } + + prevname[depth] = name; + + /* Skip root (i = 1) when printing devices */ + for (i = 1; i <= depth; i++) { + if (prevname[i] == NULL) + break; + + if (strcmp(cwd, "/") == 0) + printf("/"); + printf("%s", prevname[i]); + } + printf("\n"); + } + + return (CMD_OK); +} + +static __inline int +isprint(int c) +{ + + return (c >= ' ' && c <= 0x7e); +} + +static int +fdt_isprint(const void *data, int len, int *count) +{ + const char *d; + char ch; + int yesno, i; + + if (len == 0) + return (0); + + d = (const char *)data; + if (d[len - 1] != '\0') + return (0); + + *count = 0; + yesno = 1; + for (i = 0; i < len; i++) { + ch = *(d + i); + if (isprint(ch) || (ch == '\0' && i > 0)) { + /* Count strings */ + if (ch == '\0') + (*count)++; + continue; + } + + yesno = 0; + break; + } + + return (yesno); +} + +static int +fdt_data_str(const void *data, int len, int count, char **buf) +{ + char tmp[80], *b; + const char *d; + int i, l; + + /* + * Calculate the length for the string and allocate memory. + * + * Note len already includes at least one terminator. + */ + l = len; + if (count > 1) { + /* + * Each token had already a terminator buried in 'len', but we + * only need one eventually, don't count space for these. + */ + l -= count - 1; + + /* Each consecutive token requires a ", " separator. */ + l += count * 2; + } + /* Space for surrounding double quotes. */ + l += count * 2; + + b = (char *)malloc(l); + if (b == NULL) + return (1); + b[0] = '\0'; + + /* + * Now that we have space, format the string. + */ + i = 0; + do { + d = (const char *)data + i; + l = strlen(d) + 1; + + sprintf(tmp, "\"%s\"%s", d, + (i + l) < len ? ", " : ""); + strcat(b, tmp); + + i += l; + + } while (i < len); + *buf = b; + + return (0); +} + +static int +fdt_data_cell(const void *data, int len, char **buf) +{ + char tmp[80], *b; + const uint32_t *c; + int count, i, l; + + /* Number of cells */ + count = len / 4; + + /* + * Calculate the length for the string and allocate memory. + */ + + /* Each byte translates to 2 output characters */ + l = len * 2; + if (count > 1) { + /* Each consecutive cell requires a " " separator. */ + l += (count - 1) * 1; + } + /* Each cell will have a "0x" prefix */ + l += count * 2; + /* Space for surrounding <> and terminator */ + l += 3; + + b = (char *)malloc(l); + if (b == NULL) + return (1); + + b[0] = '\0'; + strcat(b, "<"); + + for (i = 0; i < len; i += 4) { + c = (const uint32_t *)((const uint8_t *)data + i); + sprintf(tmp, "0x%08x%s", fdt32_to_cpu(*c), + i < (len - 4) ? " " : ""); + strcat(b, tmp); + } + strcat(b, ">"); + *buf = b; + + return (0); +} + +static int +fdt_data_bytes(const void *data, int len, char **buf) +{ + char tmp[80], *b; + const char *d; + int i, l; + + /* + * Calculate the length for the string and allocate memory. + */ + + /* Each byte translates to 2 output characters */ + l = len * 2; + if (len > 1) + /* Each consecutive byte requires a " " separator. */ + l += (len - 1) * 1; + /* Each byte will have a "0x" prefix */ + l += len * 2; + /* Space for surrounding [] and terminator. */ + l += 3; + + b = (char *)malloc(l); + if (b == NULL) + return (1); + + b[0] = '\0'; + strcat(b, "["); + + for (i = 0, d = data; i < len; i++) { + sprintf(tmp, "0x%02x%s", d[i], i < len - 1 ? " " : ""); + strcat(b, tmp); + } + strcat(b, "]"); + *buf = b; + + return (0); +} + +static int +fdt_data_fmt(const void *data, int len, char **buf) +{ + int count; + + if (len == 0) { + *buf = NULL; + return (1); + } + + if (fdt_isprint(data, len, &count)) + return (fdt_data_str(data, len, count, buf)); + + else if ((len % 4) == 0) + return (fdt_data_cell(data, len, buf)); + + else + return (fdt_data_bytes(data, len, buf)); +} + +static int +fdt_prop(int offset) +{ + char *line, *buf; + const struct fdt_property *prop; + const char *name; + const void *data; + int len, rv; *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***