1de7b4b805
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. No functional change intended.
374 lines
11 KiB
C++
374 lines
11 KiB
C++
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* Copyright (c) 2013 David Chisnall
|
|
* All rights reserved.
|
|
*
|
|
* This software was developed by SRI International and the University of
|
|
* Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
|
|
* ("CTSRD"), as part of the DARPA CRASH research programme.
|
|
*
|
|
* 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.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#ifndef _DTB_HH_
|
|
#define _DTB_HH_
|
|
#include <map>
|
|
#include <string>
|
|
|
|
#include <assert.h>
|
|
|
|
#include "input_buffer.hh"
|
|
#include "util.hh"
|
|
|
|
namespace dtc
|
|
{
|
|
/**
|
|
* The dtb namespace contains code related to the generation of device tree
|
|
* blobs, the binary representation of flattened device trees. The abstract
|
|
* tree representation calls into this code to generate the output.
|
|
*/
|
|
namespace dtb
|
|
{
|
|
/** The token types in the DTB, as defined by §7.4.1 of the ePAPR
|
|
* specification. All of these values are written in big-endian format in the
|
|
* output.
|
|
*/
|
|
enum token_type
|
|
{
|
|
/**
|
|
* Marker indicating the start of a node in the tree. This is followed
|
|
* by the nul-terminated name. If a unit address is specified, then
|
|
* the name also contains the address, with an @ symbol between the end
|
|
* of the name and the start of the address.
|
|
*
|
|
* The name is then padded such that the next token begins on a 4-byte
|
|
* boundary. The node may contain properties, other nodes, both, or be
|
|
* empty.
|
|
*/
|
|
FDT_BEGIN_NODE = 0x00000001,
|
|
/**
|
|
* Marker indicating the end of a node.
|
|
*/
|
|
FDT_END_NODE = 0x00000002,
|
|
/**
|
|
* The start of a property. This is followed by two 32-bit big-endian
|
|
* values. The first indicates the length of the property value, the
|
|
* second its index in the strings table. It is then followed by the
|
|
* property value, if the value is of non-zero length.
|
|
*/
|
|
FDT_PROP = 0x00000003,
|
|
/**
|
|
* Ignored token. May be used for padding inside DTB nodes.
|
|
*/
|
|
FDT_NOP = 0x00000004,
|
|
/**
|
|
* Marker indicating the end of the tree.
|
|
*/
|
|
FDT_END = 0x00000009
|
|
};
|
|
|
|
/**
|
|
* Returns the token as a string. This is used for debugging and for printing
|
|
* human-friendly error messages about malformed DTB input.
|
|
*/
|
|
inline const char *token_type_name(token_type t)
|
|
{
|
|
switch(t)
|
|
{
|
|
case FDT_BEGIN_NODE:
|
|
return "FDT_BEGIN_NODE";
|
|
case FDT_END_NODE:
|
|
return "FDT_END_NODE";
|
|
case FDT_PROP:
|
|
return "FDT_PROP";
|
|
case FDT_NOP:
|
|
return "FDT_NOP";
|
|
case FDT_END:
|
|
return "FDT_END";
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
/**
|
|
* Abstract class for writing a section of the output. We create one
|
|
* of these for each section that needs to be written. It is intended to build
|
|
* a temporary buffer of the output in memory and then write it to a file
|
|
* stream. The size can be returned after all of the data has been written
|
|
* into the internal buffer, so the sizes of the three tables can be calculated
|
|
* before storing them in the buffer.
|
|
*/
|
|
struct output_writer
|
|
{
|
|
/**
|
|
* Writes a label into the output stream. This is only applicable for
|
|
* assembly output, where the labels become symbols that can be
|
|
* resolved at link time.
|
|
*/
|
|
virtual void write_label(const std::string &name) = 0;
|
|
/**
|
|
* Writes a comment into the output stream. Useful only when debugging
|
|
* the output.
|
|
*/
|
|
virtual void write_comment(const std::string &name) = 0;
|
|
/**
|
|
* Writes a string. A nul terminator is implicitly added.
|
|
*/
|
|
virtual void write_string(const std::string &name) = 0;
|
|
/**
|
|
* Writes a single 8-bit value.
|
|
*/
|
|
virtual void write_data(uint8_t) = 0;
|
|
/**
|
|
* Writes a single 32-bit value. The value is written in big-endian
|
|
* format, but should be passed in the host's native endian.
|
|
*/
|
|
virtual void write_data(uint32_t) = 0;
|
|
/**
|
|
* Writes a single 64-bit value. The value is written in big-endian
|
|
* format, but should be passed in the host's native endian.
|
|
*/
|
|
virtual void write_data(uint64_t) = 0;
|
|
/**
|
|
* Writes the collected output to the specified file descriptor.
|
|
*/
|
|
virtual void write_to_file(int fd) = 0;
|
|
/**
|
|
* Returns the number of bytes.
|
|
*/
|
|
virtual uint32_t size() = 0;
|
|
/**
|
|
* Helper for writing tokens to the output stream. This writes a
|
|
* comment above the token describing its value, for easier debugging
|
|
* of the output.
|
|
*/
|
|
inline void write_token(token_type t)
|
|
{
|
|
write_comment(token_type_name(t));
|
|
write_data((uint32_t)t);
|
|
}
|
|
/**
|
|
* Helper function that writes a byte buffer to the output, one byte at
|
|
* a time.
|
|
*/
|
|
void write_data(byte_buffer b);
|
|
};
|
|
|
|
/**
|
|
* Binary file writer. This class is responsible for writing the DTB output
|
|
* directly in blob format.
|
|
*/
|
|
class binary_writer : public output_writer
|
|
{
|
|
/**
|
|
* The internal buffer used to store the blob while it is being
|
|
* constructed.
|
|
*/
|
|
byte_buffer buffer;
|
|
public:
|
|
/**
|
|
* The binary format does not support labels, so this method
|
|
* does nothing.
|
|
*/
|
|
void write_label(const std::string &) override {}
|
|
/**
|
|
* Comments are ignored by the binary writer.
|
|
*/
|
|
void write_comment(const std::string&) override {}
|
|
void write_string(const std::string &name) override;
|
|
void write_data(uint8_t v) override;
|
|
void write_data(uint32_t v) override;
|
|
void write_data(uint64_t v) override;
|
|
void write_to_file(int fd) override;
|
|
uint32_t size() override;
|
|
};
|
|
/**
|
|
* Assembly writer. This class is responsible for writing the output in an
|
|
* assembly format that is suitable for linking into a kernel, loader, and so
|
|
* on.
|
|
*/
|
|
class asm_writer : public output_writer
|
|
{
|
|
/**
|
|
* The internal buffer for temporary values. Note that this actually
|
|
* contains ASCII text, but it is a byte buffer so that we can just
|
|
* copy strings across as-is.
|
|
*/
|
|
byte_buffer buffer;
|
|
/**
|
|
* The number of bytes written to the current line. This is used to
|
|
* allow line wrapping, where we aim to write four .byte directives to
|
|
* make the alignment clearer.
|
|
*/
|
|
int byte_count;
|
|
/**
|
|
* The current number of bytes written. This is the number in binary
|
|
* format, not the number of bytes in the buffer.
|
|
*/
|
|
uint32_t bytes_written;
|
|
|
|
/**
|
|
* Writes a string directly to the output as-is. This is the function that
|
|
* performs the real output.
|
|
*/
|
|
void write_string(const char *c);
|
|
/**
|
|
* Write a string to the output.
|
|
*/
|
|
void write_string(const std::string &c) override;
|
|
/**
|
|
* Writes the string, starting on a new line.
|
|
*/
|
|
void write_line(const char *c);
|
|
/**
|
|
* Writes a byte in binary format. This will emit a single .byte
|
|
* directive, with up to four per line.
|
|
*/
|
|
void write_byte(uint8_t b);
|
|
public:
|
|
asm_writer() : byte_count(0), bytes_written(0) {}
|
|
void write_label(const std::string &name) override;
|
|
void write_comment(const std::string &name) override;
|
|
void write_data(uint8_t v) override;
|
|
void write_data(uint32_t v) override;
|
|
void write_data(uint64_t v) override;
|
|
void write_to_file(int fd) override;
|
|
uint32_t size() override;
|
|
};
|
|
|
|
/**
|
|
* Class encapsulating the device tree blob header. This class stores all of
|
|
* the values found in the header and is responsible for writing them to the
|
|
* output.
|
|
*/
|
|
struct header
|
|
{
|
|
/**
|
|
* Magic value, used to validate that this really is a device tree
|
|
* blob. Should always be set to 0xd00dfeed.
|
|
*/
|
|
uint32_t magic;
|
|
/**
|
|
* The total size of the blob, including header, reservations, strings
|
|
* table, and padding.
|
|
*/
|
|
uint32_t totalsize;
|
|
/**
|
|
* The offset from the start of the blob of the struct table (i.e. the
|
|
* part of the blob containing the entire device tree).
|
|
*/
|
|
uint32_t off_dt_struct;
|
|
/**
|
|
* The offset from the start of the blob of the strings table.
|
|
*/
|
|
uint32_t off_dt_strings;
|
|
/**
|
|
* The offset of the reservation map from the start of the blob.
|
|
*/
|
|
uint32_t off_mem_rsvmap;
|
|
/**
|
|
* The version of the blob. This should always be 17.
|
|
*/
|
|
uint32_t version;
|
|
/**
|
|
* The earliest version of the DTB specification with which this blob
|
|
* is backwards compatible. This should always be 16.
|
|
*/
|
|
uint32_t last_comp_version;
|
|
/**
|
|
* The ID of the CPU where this boots.
|
|
*/
|
|
uint32_t boot_cpuid_phys;
|
|
/**
|
|
* The size of the strings table.
|
|
*/
|
|
uint32_t size_dt_strings;
|
|
/**
|
|
* The size of the struct table.
|
|
*/
|
|
uint32_t size_dt_struct;
|
|
/**
|
|
* Writes the entire header to the specified output buffer.
|
|
*/
|
|
void write(output_writer &out);
|
|
/**
|
|
* Reads the header from bits binary representation in a blob.
|
|
*/
|
|
bool read_dtb(input_buffer &input);
|
|
/**
|
|
* Default constructor. Initialises the values that have sensible
|
|
* defaults, leaves the others blank.
|
|
*/
|
|
header() : magic(0xd00dfeed), version(17), last_comp_version(16),
|
|
boot_cpuid_phys(0) {}
|
|
};
|
|
|
|
/**
|
|
* Class encapsulating the string table. FDT strings are stored in a string
|
|
* section. This maintains a map from strings to their offsets in the strings
|
|
* section.
|
|
*
|
|
* Note: We don't currently do suffix matching, which may save a small amount
|
|
* of space.
|
|
*/
|
|
class string_table {
|
|
/**
|
|
* Map from strings to their offset.
|
|
*/
|
|
std::map<std::string, uint32_t> string_offsets;
|
|
/**
|
|
* The strings, in the order in which they should be written to the
|
|
* output. The order must be stable - adding another string must not
|
|
* change the offset of any that we have already referenced - and so we
|
|
* simply write the strings in the order that they are passed.
|
|
*/
|
|
std::vector<std::string> strings;
|
|
/**
|
|
* The current size of the strings section.
|
|
*/
|
|
uint32_t size;
|
|
public:
|
|
/**
|
|
* Default constructor, creates an empty strings table.
|
|
*/
|
|
string_table() : size(0) {}
|
|
/**
|
|
* Adds a string to the table, returning the offset from the start
|
|
* where it will be written. If the string is already present, this
|
|
* will return its existing offset, otherwise it will return a new
|
|
* offset.
|
|
*/
|
|
uint32_t add_string(const std::string &str);
|
|
/**
|
|
* Writes the strings table to the specified output.
|
|
*/
|
|
void write(dtb::output_writer &writer);
|
|
};
|
|
|
|
} // namespace dtb
|
|
|
|
} // namespace dtc
|
|
|
|
#endif // !_DTB_HH_
|