fdtmap.c - chromiumos/third_party/flashrom - Git at Google

 /*
  * Copyright 2013, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *    * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *    * 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.
  *    * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
  * OWNER 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.
  *
  * Alternatively, this software may be distributed under the terms of the
  * GNU General Public License ("GPL") version 2 as published by the Free
  * Software Foundation.
  */

 #include <ctype.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <zlib.h>

 #include "flash.h"
 #include "fdtmap.h"
 #include "flash.h"
 #include "libfdt.h"
 #include "layout.h"

 #ifdef DEBUG
 #define debug(a, b...) printf(a, ##b)
 #else
 #define debug(a, b...)
 #endif

 /* An entry in the flashmap - we only care about the offset and length */
 struct fmap_entry {
 	uint32_t offset;
 	uint32_t length;
 };

 /**
  * Look up a property in a node and check that it has a minimum length.
  *
  * @blob: FDT blob
  * @node: node to examine
  * @prop_name: name of property to find
  * @min_len: minimum property length in bytes
  * @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;
 }

 static int fdtdec_get_int_array(const void *blob, int node,
 		const char *prop_name, uint32_t *array, int count)
 {
 	const uint32_t *cell;
 	int i, err = 0;

 	debug("%s: %s\n", __func__, prop_name);
 	cell = get_prop_check_min_len(blob, node, prop_name,
 				      sizeof(uint32_t) * count, &err);
 	if (!err) {
 		for (i = 0; i < count; i++)
 			array[i] = fdt32_to_cpu(cell[i]);
 	}
 	return err;
 }

 /**
  * Read a flash entry from the fdt
  *
  * @blob: FDT blob
  * @node: Offset of node to read
  * @name: Name of node being read
  * @entry: Place to put offset and size of this node
  * @return 0 if ok, -ve on error
  */
 static int read_entry(const void *blob, int node, const char *name,
 		      struct fmap_entry *entry)
 {
 	uint32_t reg[2];
 	int ret;

 	ret = fdtdec_get_int_array(blob, node, "reg", reg, 2);
 	if (ret) {
 		debug("Node '%s' has bad/missing 'reg' property\n", name);
 		return ret;
 	}
 	entry->offset = reg[0];
 	entry->length = reg[1];

 	return 0;
 }

 static int scan_flashmap(const void *blob, romlayout_t *rom_entries,
 			  int max_entries)
 {
 	int romimages;
 	int offset;
 	int depth;
 	int node;

 	offset = fdt_node_offset_by_compatible(blob, -1,
 			"chromeos,flashmap");
 	if (offset < 0)
 		return offset;

 	for (depth = romimages = 0; offset > 0 && depth >= 0; offset = node) {
 		struct fmap_entry entry;
 		const char *name;
 		romlayout_t *rl;
 		char *s;
 		int ret;

 		node = fdt_next_node(blob, offset, &depth);
 		if (node < 0)
 			return node;
 		if (depth != 1)
 			continue;

 		name = fdt_getprop(blob, node, "label", NULL);
 		ret = read_entry(blob, node, name, &entry);
 		if (ret)
 			return ret;

 		if (romimages >= max_entries) {
 			msg_gerr("ROM image contains too many regions\n");
 			return -1;
 		}
 		rl = &rom_entries[romimages];
 		rl->start = entry.offset;

 		/*
 		 * Flashrom rom entries use absolute addresses. So for non-zero
 		 * length entries, we need to subtract 1 from offset + size to
 		 * determine the end address.
 		 */
 		rl->end = entry.offset + entry.length;
 		if (entry.length)
 			rl->end--;

 		/* Use an upper case name for flashrom, with _ instead of - */
 		strncpy(rl->name, name, sizeof(rl->name));
 		rl->name[sizeof(rl->name) - 1] = '\0';
 		for (s = rl->name; *s; s++)
 			if (*s == '-')
 				*s = '_';
 			else if (*s == '@')
 				break;
 			else
 				*s = toupper(*s);
 		*s = '\0';

 		*rl->file = '\0';
 		rl->included = 0;

 		msg_gdbg("added fdtmap region \"%s\" (file=\"%s\") as %sincluded,"
 			 " offset: 0x%08x, end: 0x%08x\n",
 			  rl->name,
 			  rl->file,
 			  rl->included ? "" : "not ",
 			  rl->start,
 			  rl->end);
 		romimages++;
 	}

 	msg_gdbg("Found %d regions\n", romimages);

 	return romimages;
 }

 int fdtmap_add_entries_from_buf(const void *blob, romlayout_t *rom_entries,
 				int max_entries)
 {
 	int count;

 	count = scan_flashmap(blob, rom_entries, max_entries);
 	if (count < 0) {
 		msg_gerr("Failed to read flashmap: '%s'\n", fdt_strerror(count));
 		return -1;
 	}

 	return count;
 }

 int fdtmap_find(void *source_handle,
 		int (*read_chunk)(void *handle,
 				  void *dest,
 				  size_t offset,
 				  size_t size),
 		struct fdtmap_hdr *hdr,
 		loff_t offset, uint8_t **buf)
 {
 	int fmap_size;
 	uint32_t crc;

 	if (memcmp(hdr->sig, FDTMAP_SIGNATURE, sizeof(hdr->sig)))
 		return 0;

 	msg_gdbg("%s: found possible fdtmap at offset %#lx\n",
 		 __func__, (unsigned long)offset);

 	fmap_size = hdr->size;
 	*buf = malloc(fmap_size);
 	msg_gdbg("%s: fdtmap size %#x\n", __func__, fmap_size);

 	if (read_chunk(source_handle, *buf, offset + sizeof(*hdr), fmap_size)) {
 		msg_gdbg("[L%d] failed to read %d bytes at offset %#lx\n",
 			 __LINE__, fmap_size, (unsigned long)offset);
 		return 0;
 	}

 	/* Sanity check, the FDT total size should equal fmap_size */
 	if (fdt_totalsize(*buf) != fmap_size) {
 		msg_gdbg("[L%d] FDT size %#x did not match header size %#x at %#lx\n",
 			 __LINE__, fdt_totalsize(*buf),
 			 fmap_size, (unsigned long)offset);
 		return 0;
 	}

 	crc = crc32(0, Z_NULL, 0);
 	crc = crc32(crc, *buf, fmap_size);
 	/* Sanity check, the FDT total size should equal fmap_size */
 	if (crc != hdr->crc32) {
 		msg_gdbg("[L%d] CRC32 %#08x did not match expected %#08x at %#lx\n",
 			 __LINE__, crc, hdr->crc32, (unsigned long)offset);
 		return 0;
 	}

 	return 1;
 }
	/*
	* Copyright 2013, Google Inc.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	*
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * 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.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
	* OWNER 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.
	*
	* Alternatively, this software may be distributed under the terms of the
	* GNU General Public License ("GPL") version 2 as published by the Free
	* Software Foundation.
	*/

	#include <ctype.h>
	#include <stdint.h>
	#include <stdlib.h>
	#include <zlib.h>

	#include "flash.h"
	#include "fdtmap.h"
	#include "flash.h"
	#include "libfdt.h"
	#include "layout.h"

	#ifdef DEBUG
	#define debug(a, b...) printf(a, ##b)
	#else
	#define debug(a, b...)
	#endif

	/* An entry in the flashmap - we only care about the offset and length */
	struct fmap_entry {
	uint32_t offset;
	uint32_t length;
	};

	/**
	* Look up a property in a node and check that it has a minimum length.
	*
	* @blob: FDT blob
	* @node: node to examine
	* @prop_name: name of property to find
	* @min_len: minimum property length in bytes
	* @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;
	}

	static int fdtdec_get_int_array(const void *blob, int node,
	const char prop_name, uint32_t array, int count)
	{
	const uint32_t *cell;
	int i, err = 0;

	debug("%s: %s\n", __func__, prop_name);
	cell = get_prop_check_min_len(blob, node, prop_name,
	sizeof(uint32_t) * count, &err);
	if (!err) {
	for (i = 0; i < count; i++)
	array[i] = fdt32_to_cpu(cell[i]);
	}
	return err;
	}

	/**
	* Read a flash entry from the fdt
	*
	* @blob: FDT blob
	* @node: Offset of node to read
	* @name: Name of node being read
	* @entry: Place to put offset and size of this node
	* @return 0 if ok, -ve on error
	*/
	static int read_entry(const void blob, int node, const char name,
	struct fmap_entry *entry)
	{
	uint32_t reg[2];
	int ret;

	ret = fdtdec_get_int_array(blob, node, "reg", reg, 2);
	if (ret) {
	debug("Node '%s' has bad/missing 'reg' property\n", name);
	return ret;
	}
	entry->offset = reg[0];
	entry->length = reg[1];

	return 0;
	}

	static int scan_flashmap(const void blob, romlayout_t rom_entries,
	int max_entries)
	{
	int romimages;
	int offset;
	int depth;
	int node;

	offset = fdt_node_offset_by_compatible(blob, -1,
	"chromeos,flashmap");
	if (offset < 0)
	return offset;

	for (depth = romimages = 0; offset > 0 && depth >= 0; offset = node) {
	struct fmap_entry entry;
	const char *name;
	romlayout_t *rl;
	char *s;
	int ret;

	node = fdt_next_node(blob, offset, &depth);
	if (node < 0)
	return node;
	if (depth != 1)
	continue;

	name = fdt_getprop(blob, node, "label", NULL);
	ret = read_entry(blob, node, name, &entry);
	if (ret)
	return ret;

	if (romimages >= max_entries) {
	msg_gerr("ROM image contains too many regions\n");
	return -1;
	}
	rl = &rom_entries[romimages];
	rl->start = entry.offset;

	/*
	* Flashrom rom entries use absolute addresses. So for non-zero
	* length entries, we need to subtract 1 from offset + size to
	* determine the end address.
	*/
	rl->end = entry.offset + entry.length;
	if (entry.length)
	rl->end--;

	/* Use an upper case name for flashrom, with _ instead of - */
	strncpy(rl->name, name, sizeof(rl->name));
	rl->name[sizeof(rl->name) - 1] = '\0';
	for (s = rl->name; *s; s++)
	if (*s == '-')
	*s = '_';
	else if (*s == '@')
	break;
	else
	s = toupper(s);
	*s = '\0';

	*rl->file = '\0';
	rl->included = 0;

	msg_gdbg("added fdtmap region \"%s\" (file=\"%s\") as %sincluded,"
	" offset: 0x%08x, end: 0x%08x\n",
	rl->name,
	rl->file,
	rl->included ? "" : "not ",
	rl->start,
	rl->end);
	romimages++;
	}

	msg_gdbg("Found %d regions\n", romimages);

	return romimages;
	}

	int fdtmap_add_entries_from_buf(const void blob, romlayout_t rom_entries,
	int max_entries)
	{
	int count;

	count = scan_flashmap(blob, rom_entries, max_entries);
	if (count < 0) {
	msg_gerr("Failed to read flashmap: '%s'\n", fdt_strerror(count));
	return -1;
	}

	return count;
	}

	int fdtmap_find(void *source_handle,
	int (read_chunk)(void handle,
	void *dest,
	size_t offset,
	size_t size),
	struct fdtmap_hdr *hdr,
	loff_t offset, uint8_t **buf)
	{
	int fmap_size;
	uint32_t crc;

	if (memcmp(hdr->sig, FDTMAP_SIGNATURE, sizeof(hdr->sig)))
	return 0;

	msg_gdbg("%s: found possible fdtmap at offset %#lx\n",
	__func__, (unsigned long)offset);

	fmap_size = hdr->size;
	*buf = malloc(fmap_size);
	msg_gdbg("%s: fdtmap size %#x\n", __func__, fmap_size);

	if (read_chunk(source_handle, buf, offset + sizeof(hdr), fmap_size)) {
	msg_gdbg("[L%d] failed to read %d bytes at offset %#lx\n",
	__LINE__, fmap_size, (unsigned long)offset);
	return 0;
	}

	/* Sanity check, the FDT total size should equal fmap_size */
	if (fdt_totalsize(*buf) != fmap_size) {
	msg_gdbg("[L%d] FDT size %#x did not match header size %#x at %#lx\n",
	__LINE__, fdt_totalsize(*buf),
	fmap_size, (unsigned long)offset);
	return 0;
	}

	crc = crc32(0, Z_NULL, 0);
	crc = crc32(crc, *buf, fmap_size);
	/* Sanity check, the FDT total size should equal fmap_size */
	if (crc != hdr->crc32) {
	msg_gdbg("[L%d] CRC32 %#08x did not match expected %#08x at %#lx\n",
	__LINE__, crc, hdr->crc32, (unsigned long)offset);
	return 0;
	}

	return 1;
	}