[PATCH v1 1/2] bsps/shared/ofw: Implement RTEMS OFW interface

Niteesh G. S. niteesh.gs at gmail.com
Tue Nov 3 18:12:39 UTC 2020


Hello,

On Tue, Nov 3, 2020 at 12:53 PM Christian Mauderer <
christian.mauderer at embedded-brains.de> wrote:

> Hello Niteesh,
>
> On 03/11/2020 03:42, Niteesh G. S. wrote:
> > Hello Christian,
> >
> > On Tue, Nov 3, 2020 at 12:43 AM Christian Mauderer <oss at c-mauderer.de
> > <mailto:oss at c-mauderer.de>> wrote:
> >
> >     Hello Niteesh,
> >
> >     On 02/11/2020 18:06, Niteesh G. S. wrote:
> >     > ping.
> >
> >     Yes, of course you are right that it would be time to integrate it.
> The
> >     nasty part why I haven't started to do something into that direction
> is
> >     that we currently still have the old build system and the new in
> >     parallel. But I think we should start to integrate your code anyway.
> >
> >     Please correct me if I'm wrong: Currently there are two parts:
> >
> >     1. Adding the OFW interface.
> >
> >     2. Using in in BBB.
> >
> >     Is that correct?
> >
> > There is also the FreeBSD structures to makeporting of drivers easy.
> > I guess merging this after a thorough inspection should also not be
> > an issue.
> >
>
> Do the patches for the OFW interface and the FreeBSD structures still
> work on a current RTEMS master?
>

Currently, I have tested the OFW patch on a fresh pull of the current
master.
The previous patches won't work since some files have changed.
I will post the updated patches ASAP, please take a look at them.

And regarding FreeBSD structures, I haven't had a look into them. I'll soon
send an updated version of the patches.

Thanks,
Niteesh.



> Best regards
>
> Christian
>
> >
> >     I think the first one should be not too hard. There are already some
> >     parts that use only the new build system. Wouldn't be a problem to do
> >     that with OFW too. So to all participating at the discussion: Is
> there
> >     any blocker left why we wouldn't integrate an updated version of the
> >     patches?
> >
> >
> > The only blocker seen during the development was the license issue.
> > But that is now resolved since we figured out that all the referenced
> > code comes under the BSD 2 license.
> >
> >
> >     The second part is a bit harder. BBB is one of the BSPs that are
> quite
> >     entry friendly and therefore it should currently build with old and
> new
> >     build system till the old system is removed.
> >
> >
> > OK. I'll wait until the old system gets removed, I still have some work
> left
> > to do on the drivers.
> >
> > Thanks,
> > Niteesh
> >
> >     Best regards
> >
> >     Christian
> >
> >     >
> >     > On Thu, Sep 24, 2020 at 9:00 AM Niteesh G. S.
> >     <niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>
> >     > <mailto:niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>>>
> wrote:
> >     >
> >     >     Hello,
> >     >
> >     >     On Sat, Sep 19, 2020 at 4:13 PM Christian Mauderer
> >     >     <oss at c-mauderer.de <mailto:oss at c-mauderer.de>
> >     <mailto:oss at c-mauderer.de <mailto:oss at c-mauderer.de>>> wrote:
> >     >
> >     >         Hello Niteesh,
> >     >
> >     >         sorry for adding another delay: I think the new build
> system
> >     >         needs a bit
> >     >         of time to settle. As soon as there are some more PASS in
> the
> >     >         table that
> >     >         Sebastian created [1] (especially for beagle) we should
> try to
> >     >         get these
> >     >         patches merged. Before that I would like to avoid big
> changes
> >     >         because it
> >     >         might get hard to distinguish new bugs from build system
> bugs.
> >     >
> >     >
> >     >     No problem. Currently, I have my university exams going on and
> >     also I am
> >     >     waiting for my logic analyzer. As soon as it arrives I'll start
> >     >     verifying the previous
> >     >     drivers and finish refactoring the other ones.
> >     >
> >     >     Thanks,
> >     >     Niteesh.
> >     >
> >     >
> >     >
> >     >
> >     >         Best regards
> >     >
> >     >         Christian
> >     >
> >     >         [1]
> >     https://devel.rtems.org/wiki/Release/6/Waf%20BSP%20Checklist
> >     >
> >     >         On 16/09/2020 19:05, Niteesh G. S. wrote:
> >     >         > Hello,
> >     >         >
> >     >         > Sorry for the delay, I was a bit occupied with my
> >     university work.
> >     >         > Now since the new build system is merged I would like to
> >     get my
> >     >         > GSoC work merged too.
> >     >         >
> >     >         > The goal of this series patches is to implement the OFW
> API
> >     >         into RTEMS
> >     >         > and modify libBSD to use this RTEMS API instead of its
> own.
> >     >         >
> >     >         > Thanks,
> >     >         > Niteesh.
> >     >         >
> >     >         > On Wed, Sep 16, 2020 at 10:33 PM G S Niteesh Babu
> >     >         <niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>
> >     <mailto:niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>>
> >     >         > <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com> <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com>>>>
> >     >         wrote:
> >     >         >
> >     >         >     RTEMS OFW is a FDT only implementation of the
> >     OpenFirmWare
> >     >         >     interface. This API is created to be compatible with
> >     FreeBSD
> >     >         >     OpenFirmWare interface. The main intention is to make
> >     >         >     porting of FreeBSD drivers to RTEMS easier.
> >     >         >
> >     >         >     Most functions implemented have an direct one-one
> >     mapping
> >     >         >     with the original OFW API and some extra auxiliary
> >     functions
> >     >         >     were implemented to make working with device trees
> >     easier in
> >     >         >     RTEMS.
> >     >         >
> >     >         >     Update #3784
> >     >         >     ---
> >     >         >      bsps/include/ofw/ofw.h        | 548
> >     >         +++++++++++++++++++++++++++
> >     >         >      bsps/include/ofw/ofw_compat.h |  74 ++++
> >     >         >      bsps/shared/ofw/ofw.c         | 682
> >     >         ++++++++++++++++++++++++++++++++++
> >     >         >      spec/build/bsps/obj.yml       |   5 +
> >     >         >      4 files changed, 1309 insertions(+)
> >     >         >      create mode 100644 bsps/include/ofw/ofw.h
> >     >         >      create mode 100644 bsps/include/ofw/ofw_compat.h
> >     >         >      create mode 100644 bsps/shared/ofw/ofw.c
> >     >         >
> >     >         >     diff --git a/bsps/include/ofw/ofw.h
> >     b/bsps/include/ofw/ofw.h
> >     >         >     new file mode 100644
> >     >         >     index 0000000000..411010be89
> >     >         >     --- /dev/null
> >     >         >     +++ b/bsps/include/ofw/ofw.h
> >     >         >     @@ -0,0 +1,548 @@
> >     >         >     +/* SPDX-License-Identifier: BSD-2-Clause */
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @file
> >     >         >     + *
> >     >         >     + * @ingroup ofw
> >     >         >     + *
> >     >         >     + * RTEMS FDT implementation of OpenFirmWare
> Interface.
> >     >         >     + *
> >     >         >     + * RTEMS OFW is a FDT only implementation of the
> >     OpenFirmWare
> >     >         >     interface.
> >     >         >     + * This API is created to be compatible with FreeBSD
> >     >         OpenFirmWare
> >     >         >     interface.
> >     >         >     + * The main intention is to make porting of FreeBSD
> >     >         drivers to
> >     >         >     RTEMS easier.
> >     >         >     + */
> >     >         >     +
> >     >         >     +/*
> >     >         >     + * Copyright (C) 2020 Niteesh Babu G S
> >     >         <niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>
> >     <mailto:niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>>
> >     >         >     <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com> <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com>>>>
> >     >         >     + *
> >     >         >     + * 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 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.
> >     >         >     + */
> >     >         >     +
> >     >         >     +#ifndef _OFW_H
> >     >         >     +#define _OFW_H
> >     >         >     +
> >     >         >     +#ifdef __cplusplus
> >     >         >     +extern "C" {
> >     >         >     +#endif
> >     >         >     +
> >     >         >     +#include <rtems.h>
> >     >         >     +#include <stdint.h>
> >     >         >     +#include <sys/types.h>
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * Represents a node in the device tree. The offset
> >     from
> >     >         fdtp to
> >     >         >     node is used
> >     >         >     + * instead of fdt offset to make sure this is
> >     compatible
> >     >         with OF
> >     >         >     interface in
> >     >         >     + * FreeBSD.
> >     >         >     + */
> >     >         >     +typedef uint32_t  phandle_t;
> >     >         >     +/**
> >     >         >     + * Represents the effective phandle of the node.
> >     >         >     + */
> >     >         >     +typedef uint32_t  ihandle_t;
> >     >         >     +/**
> >     >         >     + * Represents the data type of the buffer.
> >     >         >     + */
> >     >         >     +typedef uint32_t  pcell_t;
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @struct rtems_ofw_memory_area
> >     >         >     + *
> >     >         >     + * This is used to represent elements(FDT
> properties)
> >     >         that define
> >     >         >     + * region of memory address.
> >     >         >     + */
> >     >         >     +typedef struct {
> >     >         >     +  /** The start address of the memory region. */
> >     >         >     +  uint32_t start;
> >     >         >     +  /** The size of the memory region. */
> >     >         >     +  uint32_t size;
> >     >         >     +} rtems_ofw_memory_area;
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @struct rtems_ofw_ranges
> >     >         >     + *
> >     >         >     + * This is used to represent the ranges property in
> the
> >     >         device tree.
> >     >         >     + */
> >     >         >     +typedef struct {
> >     >         >     +  /** The physical address within the child bus
> address
> >     >         space */
> >     >         >     +  uint32_t child_bus;
> >     >         >     +  /** The physical address within the parent bus
> >     address
> >     >         space */
> >     >         >     +  uint32_t parent_bus;
> >     >         >     +  /** The size of the range in the child’s address
> >     space */
> >     >         >     +  uint32_t size;
> >     >         >     +} rtems_ofw_ranges;
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the node that is next to @a node.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + *
> >     >         >     + * @retval Peer node offset Successful operation.
> >     >         >     + * @retval 0 No peer node or invalid node handle
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_peer(
> >     >         >     +  phandle_t   node
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the node that is the child of @a
> node.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + *
> >     >         >     + * @retval child node offset Successful operation.
> >     >         >     + * @retval 0 No child node or invalid node handle
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_child(
> >     >         >     +  phandle_t   node
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the node that is the parent of @a
> node.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + *
> >     >         >     + * @retval child node offset Successful operation.
> >     >         >     + * @retval 0 No child node or invalid node handle
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_parent(
> >     >         >     +  phandle_t   node
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the length of the property mentioned
> >     in @a
> >     >         propname.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] prop Property name
> >     >         >     + *
> >     >         >     + * @retval -1 Invalid node or property
> >     >         >     + * @retval  Length of property on successful
> operation
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_get_prop_len(
> >     >         >     +  phandle_t   node,
> >     >         >     +  const char *propname
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the value of property mentioned in @a
> >     >         propname.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] prop Property name
> >     >         >     + * @param[out] buf The property value gets stored
> >     in this
> >     >         buffer
> >     >         >     (Pre-allocated)
> >     >         >     + * @param[in] len Length of the buffer
> >     >         >     +
> >     >         >     + * @retval -1 Invalid node or property
> >     >         >     + * @retval  Length of property on successful
> operation
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_get_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void        *buf,
> >     >         >     +  size_t       len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the value of property mentioned in
> >     @a prop.
> >     >         >     + *
> >     >         >     + * Gets the value of property of @a node and
> >     converts the
> >     >         value
> >     >         >     into the host's
> >     >         >     + * endianness.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] prop Property name
> >     >         >     + * @param[out] buf The property value gets stored
> >     in this
> >     >         >     buffer(Pre-allocated)
> >     >         >     + * after converted to the host's endianness
> >     >         >     + * @param[in] len Length of the buffer
> >     >         >     + *
> >     >         >     + * @retval -1 Invalid node or property
> >     >         >     + * @retval  Length of property on successful
> operation
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_get_enc_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *prop,
> >     >         >     +  pcell_t     *buf,
> >     >         >     +  size_t       len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Checks if the property @a propname is
> present
> >     >         in @a node.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] propname Property name
> >     >         >     + *
> >     >         >     + *  @retval  0 Property not present.
> >     >         >     + *  @retval  1 Property is present.
> >     >         >     + */
> >     >         >     +int rtems_ofw_has_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Searches for property @a propname in @a
> node.
> >     >         >     + *
> >     >         >     + * Searches the node and its parent recursively for
> the
> >     >         property
> >     >         >     and fills the
> >     >         >     + * buffer with the first found value.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] propname Property name
> >     >         >     + * @param[out] buf The property value gets stored
> >     in this
> >     >         buffer
> >     >         >     (Pre-allocated)
> >     >         >     + * @param[in] len Length of the buffer
> >     >         >     + *
> >     >         >     + * @retval  Length of the property if property is
> >     found.
> >     >         >     + * @retval  -1 Property is not found.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_search_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void        *buf,
> >     >         >     +  size_t       len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Searches for property @a propname in @a
> node.
> >     >         >     + *
> >     >         >     + * Searches the node and its parent recursively for
> the
> >     >         property
> >     >         >     and fills the
> >     >         >     + * buffer with the first value found after
> >     converting it
> >     >         to the
> >     >         >     endianness of
> >     >         >     + * the host.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] propname Property name
> >     >         >     + * @param[out] buf The property value gets stored
> >     in this
> >     >         >     buffer(Pre-allocated)
> >     >         >     + * after converted to the host's endianness
> >     >         >     + * @param[in] len Length of the buffer
> >     >         >     + *
> >     >         >     + * @retval  Length of the property if property is
> >     found.
> >     >         >     + * @retval  -1 Property is not found.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_search_enc_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  pcell_t     *buf,
> >     >         >     +  size_t       len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the value of property mentioned in @a
> >     >         propname.
> >     >         >     + *
> >     >         >     + * Same as rtems_ofw_getprop, but the @a buf is
> >     allocated
> >     >         in this
> >     >         >     routine and
> >     >         >     + * the user is responsible for freeing it.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] propname Property name
> >     >         >     + * @param[out] buf The buffer is allocated in this
> >     >         routine and user is
> >     >         >     + * responsible for freeing.
> >     >         >     + *
> >     >         >     + * @retval  -1 Property is not found.
> >     >         >     + * @retval  Length of the property if property is
> >     found.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_get_prop_alloc(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void       **buf
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets multiple values of the property @a
> >     propname.
> >     >         >     + *
> >     >         >     + * Same as rtems_ofw_getprop_alloc but it can read
> >     >         properties with
> >     >         >     multiple
> >     >         >     + * values.
> >     >         >     + * For eg: reg = <0x1000 0x10 0x2000 0x20>
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] propname Property name
> >     >         >     + * @param[in] elsz Size of the single value
> >     >         >     + * @param[out] buf The buffer is allocated in this
> >     >         routine and user is
> >     >         >     + * responsible for freeing.
> >     >         >     + *
> >     >         >     + * @retval  -1 Property is not found.
> >     >         >     + * @retval   Number of values read.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_get_prop_alloc_multi(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  int          elsz,
> >     >         >     +  void       **buf
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets the value of property mentioned in @a
> >     >         propname.
> >     >         >     + *
> >     >         >     + * Same as rtems_ofw_getprop_alloc but the value
> stored
> >     >         in the
> >     >         >     buffer is
> >     >         >     + * converted into the host's endianness.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] propname Property name
> >     >         >     + * @param[out] buf The buffer is allocated in this
> >     >         routine and user is
> >     >         >     + * responsible for freeing.
> >     >         >     + *
> >     >         >     + * @retval  -1 Property is not found.
> >     >         >     + * @retval  Length of the property if property is
> >     found.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_get_enc_prop_alloc(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void       **buf
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets multiple values of the property @a
> >     propname.
> >     >         >     + *
> >     >         >     + * Same as rtems_ofw_getprop_alloc_multi but the
> values
> >     >         stored in
> >     >         >     the buffer
> >     >         >     + * are converted to the host's endianness.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] propname Property name
> >     >         >     + * @param[in] elsz Size of the single value
> >     >         >     + * @param[out] buf The buffer is allocated in this
> >     >         routine and user is
> >     >         >     + * responsible for freeing.
> >     >         >     + *
> >     >         >     + * @retval  -1 Property is not found.
> >     >         >     + * @retval   Number of values read.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_get_enc_prop_alloc_multi(
> >     >         >     +  phandle_t     node,
> >     >         >     +  const char   *propname,
> >     >         >     +  int           elsz,
> >     >         >     +  void        **buf
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Free's the buffers allocated by the
> >     >         rtems_ofw_*_alloc
> >     >         >     functions.
> >     >         >     + *
> >     >         >     + * @param[in] buf Buffer to be freed
> >     >         >     + */
> >     >         >     +void rtems_ofw_free(
> >     >         >     +  void   *buf
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Finds the next property of @a node.
> >     >         >     + *
> >     >         >     + * Finds the next property of the node and when @a
> >     >         propname is NULL
> >     >         >     it returns
> >     >         >     + * the value in the first property.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] previous Previous property name
> >     >         >     + * @param[out] buf The value of the next property
> gets
> >     >         stored in
> >     >         >     this buffer
> >     >         >     + * (Pre-allocated)
> >     >         >     + * @param[in] len Length of the buffer
> >     >         >     + *
> >     >         >     + * @retval  -1 node or previous property does not
> exist
> >     >         >     + * @retval   0 no more properties
> >     >         >     + * @retval   1 success
> >     >         >     + */
> >     >         >     +int rtems_ofw_next_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *previous,
> >     >         >     +  char        *buf,
> >     >         >     +  size_t       len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Sets the property @name of @a node to @a
> buf.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[in] name Property name
> >     >         >     + * @param[in] buf Buffer contains the value to be
> set.
> >     >         >     + * @param[in] len Length of the buffer
> >     >         >     + *
> >     >         >     + * @retval  -1 node does not exist
> >     >         >     + * @retval   0 on success
> >     >         >     + * @retval   libFDT error codes on unsuccessful
> setting
> >     >         operation
> >     >         >     + */
> >     >         >     +int rtems_ofw_set_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *name,
> >     >         >     +  const void  *buf,
> >     >         >     +  size_t       len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Converts a device specifier to a fully
> >     >         qualified path name.
> >     >         >     + *
> >     >         >     + * @param[in] dev device specifier
> >     >         >     + * @param[out] buf The path is filled into the
> >     >         buffer(Pre-allocated)
> >     >         >     + * @param[in] length of the buffer
> >     >         >     + *
> >     >         >     + * @retval  -1 always. Unimplemented.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_canon(
> >     >         >     +  const char  *dev,
> >     >         >     +  char        *buf,
> >     >         >     +  size_t       len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Finds the node at the given path
> >     >         >     + *
> >     >         >     + * @param[in] path to the node from root
> >     >         >     + *
> >     >         >     + * @retval  -1 node does not exist
> >     >         >     + * @retval   node handle on success
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_find_device(
> >     >         >     +  const char  *path
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief This routine converts effective phandle
> >     @a xref
> >     >         to node
> >     >         >     offset.
> >     >         >     + *
> >     >         >     + * @param[in] xref Node phandle
> >     >         >     + *
> >     >         >     + * @retval Node offset on success
> >     >         >     + * @retval Node phandle on failure
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_node_from_xref(
> >     >         >     +  phandle_t   xref
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief This routine converts node offset to
> >     effective
> >     >         phandle of
> >     >         >     @a node.
> >     >         >     + *
> >     >         >     + * @retval Node phandle on success
> >     >         >     + * @retval Node offset on failure
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_xref_from_node(
> >     >         >     +  phandle_t   node
> >     >         >     +);
> >     >         >     +
> >     >         >     +/*
> >     >         >     + * instance handles(ihandle_t) as same as phandles
> >     in the FDT
> >     >         >     implementation
> >     >         >     + * of OF interface.
> >     >         >     + */
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Converts @a instance handle to phandle.
> >     >         >     + *
> >     >         >     + * instance are same as node offsets in FDT.
> >     >         >     + *
> >     >         >     + * @param[in] instance Node offset
> >     >         >     + *
> >     >         >     + * @retval phandle of node on success.
> >     >         >     + * @retval instance of node on failure.
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_instance_to_package(
> >     >         >     +  ihandle_t   instance
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Find the node's path from phandle.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[out] buf Path is filled into this
> >     >         buffer(Pre-allocated).
> >     >         >     + * @param[in] len Length of the buffer.
> >     >         >     + *
> >     >         >     + * @retval -1 always. Unimplemented.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_package_to_path(
> >     >         >     +  phandle_t   node,
> >     >         >     +  char       *buf,
> >     >         >     +  size_t      len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Find the node's path from ihandle.
> >     >         >     + *
> >     >         >     + * @param[in] instance Node offset
> >     >         >     + * @param[out] buf Path is filled into this
> >     >         buffer(Pre-allocated).
> >     >         >     + * @param[in] len Length of the buffer.
> >     >         >     + *
> >     >         >     + * @retval -1 always. Unimplemented.
> >     >         >     + */
> >     >         >     +ssize_t rtems_ofw_instance_to_path(
> >     >         >     +  ihandle_t  instance,
> >     >         >     +  char      *buf,
> >     >         >     +  size_t     len
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Queries the node's reg value.
> >     >         >     + *
> >     >         >     + * This routine fills the buffer @a buf with the
> values
> >     >         in reg
> >     >         >     property of node
> >     >         >     + * @a node. It reads all the values of the property
> and
> >     >         fills the
> >     >         >     buffer to max
> >     >         >     + * size.
> >     >         >     + * This routine is local to RTEMS OFW and does not
> >     have an
> >     >         >     corresponding
> >     >         >     + * FreeBSD OFW pair.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[out] buf Register values are stored in
> this
> >     >         >     buffer(Pre-allocated).
> >     >         >     + * @param[in] size Length of the buffer.
> >     >         >     + *
> >     >         >     + * @retval -1 If reg property is missing.
> >     >         >     + * @retval  Length of the reg property in bytes.
> >     >         >     + */
> >     >         >     +int rtems_ofw_get_reg(
> >     >         >     +  phandle_t              node,
> >     >         >     +  rtems_ofw_memory_area *buf,
> >     >         >     +  size_t                 size
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Queries the node's interrupt value.
> >     >         >     + *
> >     >         >     + * This routine fills the buffer @a buf with the
> >     >         interrupt number.
> >     >         >     In case of
> >     >         >     + * multiple numbers it fills the buffer to its full
> >     extent.
> >     >         >     + * This routine is local to RTEMS OFW and does not
> >     have an
> >     >         >     corresponding
> >     >         >     + * FreeBSD OFW pair.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + * @param[out] buf Interrupt values are stored in
> this
> >     >         >     buffer(Pre-allocated).
> >     >         >     + * @param[in] size Length of the buffer.
> >     >         >     + *
> >     >         >     + * @retval -1 If interrupts property is missing.
> >     >         >     + * @retval  The number of interrupt numbers read.
> >     >         >     + */
> >     >         >     +int rtems_ofw_get_interrupts(
> >     >         >     +  phandle_t            node,
> >     >         >     +  rtems_vector_number *buf,
> >     >         >     +  size_t               size
> >     >         >     +);
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Queries the node's status.
> >     >         >     + *
> >     >         >     + * This routine is local to RTEMS OFW and does not
> >     have an
> >     >         >     corresponding
> >     >         >     + * FreeBSD OFW pair.
> >     >         >     + *
> >     >         >     + * @param[in] node Node offset
> >     >         >     + *
> >     >         >     + * @retval true  Status is OK or empty.
> >     >         >     + * @retval false Status is not OK or missing.
> >     >         >     + */
> >     >         >     +bool rtems_ofw_node_status( phandle_t node );
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @brief Gets node phandle from compatible
> property.
> >     >         >     + *
> >     >         >     + * This routine is local to RTEMS OFW and does not
> >     have an
> >     >         >     corresponding
> >     >         >     + * FreeBSD OFW pair.
> >     >         >     + *
> >     >         >     + * @param[in] compat Compatible string
> >     >         >     + *
> >     >         >     + * @retval 0 Node with @a compat as compatible
> >     string not
> >     >         found
> >     >         >     + * @retval Node phandle on success.
> >     >         >     + */
> >     >         >     +phandle_t rtems_ofw_find_device_by_compat( const
> char
> >     >         *compat );
> >     >         >     +
> >     >         >     +#ifdef __cplusplus
> >     >         >     +}
> >     >         >     +#endif
> >     >         >     +
> >     >         >     +#endif /* _OFW_H */
> >     >         >     diff --git a/bsps/include/ofw/ofw_compat.h
> >     >         >     b/bsps/include/ofw/ofw_compat.h
> >     >         >     new file mode 100644
> >     >         >     index 0000000000..be4a5ea3ce
> >     >         >     --- /dev/null
> >     >         >     +++ b/bsps/include/ofw/ofw_compat.h
> >     >         >     @@ -0,0 +1,74 @@
> >     >         >     +/* SPDX-License-Identifier: BSD-2-Clause */
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @file
> >     >         >     + *
> >     >         >     + * @ingroup ofw
> >     >         >     + *
> >     >         >     + * This file defines necessary symbols to make the
> >     RTEMS
> >     >         OFW API
> >     >         >     compatible
> >     >         >     + * with FreeBSD OFW.
> >     >         >     + */
> >     >         >     +
> >     >         >     +/*
> >     >         >     + * Copyright (C) 2020 Niteesh Babu G S
> >     >         <niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>
> >     <mailto:niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>>
> >     >         >     <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com> <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com>>>>
> >     >         >     + *
> >     >         >     + * 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 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.
> >     >         >     + */
> >     >         >     +
> >     >         >     +#ifndef _OFW_COMPAT_H
> >     >         >     +#define _OFW_COMPAT_H
> >     >         >     +
> >     >         >     +#ifdef __cplusplus
> >     >         >     +extern "C" {
> >     >         >     +#endif
> >     >         >     +
> >     >         >     +#include <ofw/ofw.h>
> >     >         >     +
> >     >         >     +#define OF_peer                   rtems_ofw_peer
> >     >         >     +#define OF_child                  rtems_ofw_child
> >     >         >     +#define OF_parent                 rtems_ofw_parent
> >     >         >     +#define OF_getproplen
> >      rtems_ofw_get_prop_len
> >     >         >     +#define OF_getprop                rtems_ofw_get_prop
> >     >         >     +#define OF_getencprop
> >      rtems_ofw_get_enc_prop
> >     >         >     +#define OF_hasprop                rtems_ofw_has_prop
> >     >         >     +#define OF_searchprop
>  rtems_ofw_search_prop
> >     >         >     +#define OF_searchencprop
> >     rtems_ofw_search_enc_prop
> >     >         >     +#define OF_getprop_alloc
> >     rtems_ofw_get_prop_alloc
> >     >         >     +#define OF_getprop_alloc_multi
> >     >         rtems_ofw_get_prop_alloc_multi
> >     >         >     +#define OF_getencprop_alloc_multi
> >     >         rtems_ofw_get_enc_prop_alloc_multi
> >     >         >     +#define OF_getencprop_alloc
> >     >          rtems_ofw_get_enc_prop_alloc
> >     >         >     +#define OF_prop_free              rtems_ofw_free
> >     >         >     +#define OF_nextprop
>  rtems_ofw_next_prop
> >     >         >     +#define OF_setprop                rtems_ofw_set_prop
> >     >         >     +#define OF_canon                  rtems_ofw_canon
> >     >         >     +#define OF_finddevice
>  rtems_ofw_find_device
> >     >         >     +#define OF_package_to_path
> >     rtems_ofw_package_to_path
> >     >         >     +#define OF_node_from_xref
> >      rtems_ofw_node_from_xref
> >     >         >     +#define OF_xref_from_node
> >      rtems_ofw_xref_from_node
> >     >         >     +#define OF_instance_to_package
> >     >         rtems_ofw_instance_to_package
> >     >         >     +#define OF_instance_to_path
> >      rtems_ofw_instance_to_path
> >     >         >     +
> >     >         >     +#ifdef __cplusplus
> >     >         >     +}
> >     >         >     +#endif
> >     >         >     +
> >     >         >     +#endif /* _OFW_COMPAT_H */
> >     >         >     diff --git a/bsps/shared/ofw/ofw.c
> >     b/bsps/shared/ofw/ofw.c
> >     >         >     new file mode 100644
> >     >         >     index 0000000000..2b1dff8bf8
> >     >         >     --- /dev/null
> >     >         >     +++ b/bsps/shared/ofw/ofw.c
> >     >         >     @@ -0,0 +1,682 @@
> >     >         >     +/* SPDX-License-Identifier: BSD-2-Clause */
> >     >         >     +
> >     >         >     +/**
> >     >         >     + * @file
> >     >         >     + *
> >     >         >     + * @ingroup ofw
> >     >         >     + */
> >     >         >     +
> >     >         >     +/*
> >     >         >     + * Copyright (C) 2020 Niteesh Babu G S
> >     >         <niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>
> >     <mailto:niteesh.gs at gmail.com <mailto:niteesh.gs at gmail.com>>
> >     >         >     <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com> <mailto:niteesh.gs at gmail.com
> >     <mailto:niteesh.gs at gmail.com>>>>
> >     >         >     + *
> >     >         >     + * 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 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.
> >     >         >     + */
> >     >         >     +
> >     >         >     +#ifdef HAVE_CONFIG_H
> >     >         >     +#include "config.h"
> >     >         >     +#endif
> >     >         >     +
> >     >         >     +#include <bsp/fdt.h>
> >     >         >     +#include <sys/param.h>
> >     >         >     +#include <ofw/ofw.h>
> >     >         >     +#include <libfdt.h>
> >     >         >     +#include <assert.h>
> >     >         >     +#include <rtems/sysinit.h>
> >     >         >     +
> >     >         >     +const void *fdtp = NULL;
> >     >         >     +
> >     >         >     +static phandle_t rtems_fdt_offset_to_phandle( int
> >     offset )
> >     >         >     +{
> >     >         >     +  if (offset < 0) {
> >     >         >     +    return 0;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return (phandle_t)offset +
> fdt_off_dt_struct(fdtp);
> >     >         >     +}
> >     >         >     +
> >     >         >     +static int rtems_fdt_phandle_to_offset( phandle_t
> >     handle )
> >     >         >     +{
> >     >         >     +  int off;
> >     >         >     +  int fdt_off;
> >     >         >     +
> >     >         >     +  off = (int) handle;
> >     >         >     +  fdt_off = fdt_off_dt_struct(fdtp);
> >     >         >     +
> >     >         >     +  if (off < fdt_off) {
> >     >         >     +    return -1;
> >     >         >     +
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return off - fdt_off;
> >     >         >     +}
> >     >         >     +
> >     >         >     +static void rtems_ofw_init( void ) {
> >     >         >     +  int rv;
> >     >         >     +  const void *fdt;
> >     >         >     +
> >     >         >     +  fdt = bsp_fdt_get();
> >     >         >     +
> >     >         >     +  rv = fdt_check_header(fdt);
> >     >         >     +
> >     >         >     +  /*
> >     >         >     +   * If the FDT is invalid exit through fatal.
> >     >         >     +   */
> >     >         >     +  if (rv != 0) {
> >     >         >     +
> rtems_fatal_error_occurred(RTEMS_NOT_CONFIGURED);
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  fdtp = fdt;
> >     >         >     +}
> >     >         >     +
> >     >         >     +RTEMS_SYSINIT_ITEM(
> >     >         >     +  rtems_ofw_init,
> >     >         >     +  RTEMS_SYSINIT_BSP_PRE_DRIVERS,
> >     >         >     +  RTEMS_SYSINIT_ORDER_FIRST
> >     >         >     +);
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_peer( phandle_t node )
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +
> >     >         >     +  if (node == 0) {
> >     >         >     +    int root = fdt_path_offset(fdtp, "/");
> >     >         >     +    return rtems_fdt_offset_to_phandle(root);
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +  if (offset < 0) {
> >     >         >     +    return 0;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  offset = fdt_next_subnode(fdtp, offset);
> >     >         >     +  return rtems_fdt_offset_to_phandle(offset);
> >     >         >     +}
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_child( phandle_t node )
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +
> >     >         >     +  if (offset < 0) {
> >     >         >     +    return 0;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  offset = fdt_first_subnode(fdtp, offset);
> >     >         >     +  return rtems_fdt_offset_to_phandle(offset);
> >     >         >     +}
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_parent( phandle_t node )
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +
> >     >         >     +  if (offset < 0) {
> >     >         >     +    return 0;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  offset = fdt_parent_offset(fdtp, offset);
> >     >         >     +  return rtems_fdt_offset_to_phandle(offset);
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_get_prop_len(
> >     >         >     +  phandle_t node,
> >     >         >     +  const char *propname
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +  int len;
> >     >         >     +  const void *prop;
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +
> >     >         >     +  if (offset < 0) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  prop = fdt_getprop(fdtp, offset, propname, &len);
> >     >         >     +
> >     >         >     +  if (prop == NULL && strcmp(propname, "name") ==
> 0) {
> >     >         >     +    fdt_get_name(fdtp, offset, &len);
> >     >         >     +    return len + 1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (prop == NULL && strcmp(propname, "/chosen")
> >     == 0) {
> >     >         >     +    if (strcmp(propname, "fdtbootcpu") == 0)
> >     >         >     +      return sizeof(pcell_t);
> >     >         >     +    if (strcmp(propname, "fdtmemreserv") == 0)
> >     >         >     +      return 2 * sizeof(uint64_t) *
> >     fdt_num_mem_rsv(fdtp);
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (prop == NULL) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return len;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_get_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void        *buf,
> >     >         >     +  size_t       bufsize
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  const void *prop;
> >     >         >     +  int offset;
> >     >         >     +  int len;
> >     >         >     +  uint32_t cpuid;
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +
> >     >         >     +  if (offset < 0) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  prop = fdt_getprop(fdtp, offset, propname, &len);
> >     >         >     +
> >     >         >     +  if (prop == NULL && strcmp(propname, "name") ==
> 0) {
> >     >         >     +    prop = fdt_get_name(fdtp, offset, &len);
> >     >         >     +    strncpy(buf, prop, bufsize);
> >     >         >     +    return len + 1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (prop == NULL && strcmp(propname, "/chosen")
> >     == 0) {
> >     >         >     +    if (strcmp(propname, "fdtbootcpu") == 0) {
> >     >         >     +      cpuid =
> cpu_to_fdt32(fdt_boot_cpuid_phys(fdtp));
> >     >         >     +      len = sizeof(cpuid);
> >     >         >     +      prop = &cpuid;
> >     >         >     +    }
> >     >         >     +    if (strcmp(propname, "fdtmemreserv") == 0) {
> >     >         >     +      prop = (char *)fdtp +
> fdt_off_mem_rsvmap(fdtp);
> >     >         >     +      len =
> sizeof(uint64_t)*2*fdt_num_mem_rsv(fdtp);
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (prop == NULL) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  bcopy(prop, buf, MIN(len, bufsize));
> >     >         >     +
> >     >         >     +  return len;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_get_enc_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *prop,
> >     >         >     +  pcell_t     *buf,
> >     >         >     +  size_t       len
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t rv;
> >     >         >     +
> >     >         >     +  assert(len % 4 == 0);
> >     >         >     +  rv = rtems_ofw_get_prop(node, prop, buf, len);
> >     >         >     +
> >     >         >     +  if (rv < 0) {
> >     >         >     +    return rv;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  for (int i = 0; i < (len / 4); i++) {
> >     >         >     +    buf[i] = fdt32_to_cpu(buf[i]);
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return rv;
> >     >         >     +}
> >     >         >     +
> >     >         >     +int rtems_ofw_has_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t rv;
> >     >         >     +
> >     >         >     +  rv = rtems_ofw_get_prop_len(node, propname);
> >     >         >     +  return rv >= 0 ? 1 : 0;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_search_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void        *buf,
> >     >         >     +  size_t       len
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t rv;
> >     >         >     +
> >     >         >     +  for (; node != 0; node = rtems_ofw_parent(node)) {
> >     >         >     +    if ((rv = rtems_ofw_get_prop(node, propname,
> buf,
> >     >         len) != -1)) {
> >     >         >     +      return rv;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return -1;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_search_enc_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  pcell_t     *buf,
> >     >         >     +  size_t       len
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t rv;
> >     >         >     +
> >     >         >     +  for (; node != 0; node = rtems_ofw_parent(node)) {
> >     >         >     +    if ((rv = rtems_ofw_get_enc_prop(node,
> >     propname, buf,
> >     >         len) !=
> >     >         >     -1)) {
> >     >         >     +      return rv;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return -1;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_get_prop_alloc(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void       **buf
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t len;
> >     >         >     +
> >     >         >     +  *buf = NULL;
> >     >         >     +  if ((len = rtems_ofw_get_prop_len(node,
> >     propname)) == -1) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (len > 0) {
> >     >         >     +    *buf = malloc(len);
> >     >         >     +    if (*buf == NULL) {
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +
> >     >         >     +    if (rtems_ofw_get_prop(node, propname, *buf,
> >     len) ==
> >     >         -1) {
> >     >         >     +      rtems_ofw_free(buf);
> >     >         >     +      *buf = NULL;
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return len;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_get_prop_alloc_multi(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  int          elsz,
> >     >         >     +  void       **buf
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t len;
> >     >         >     +
> >     >         >     +  *buf = NULL;
> >     >         >     +  if ((len = rtems_ofw_get_prop_len(node,
> >     propname)) == -1 ||
> >     >         >     +      (len % elsz != 0)) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (len > 0) {
> >     >         >     +    *buf = malloc(len);
> >     >         >     +    if (*buf == NULL) {
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +
> >     >         >     +    if (rtems_ofw_get_prop(node, propname, *buf,
> >     len) ==
> >     >         -1) {
> >     >         >     +      rtems_ofw_free(buf);
> >     >         >     +      *buf = NULL;
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return (len / elsz);
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_get_enc_prop_alloc(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *propname,
> >     >         >     +  void       **buf
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t len;
> >     >         >     +
> >     >         >     +  *buf = NULL;
> >     >         >     +  if ((len = rtems_ofw_get_prop_len(node,
> >     propname)) == -1) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (len > 0) {
> >     >         >     +    *buf = malloc(len);
> >     >         >     +    if (*buf == NULL) {
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +
> >     >         >     +    if (rtems_ofw_get_enc_prop(node, propname,
> >     *buf, len)
> >     >         == -1) {
> >     >         >     +      rtems_ofw_free(buf);
> >     >         >     +      *buf = NULL;
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return len;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_get_enc_prop_alloc_multi(
> >     >         >     +  phandle_t     node,
> >     >         >     +  const char   *propname,
> >     >         >     +  int           elsz,
> >     >         >     +  void        **buf
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  ssize_t len;
> >     >         >     +
> >     >         >     +  *buf = NULL;
> >     >         >     +  if ((len = rtems_ofw_get_prop_len(node,
> >     propname)) == -1 ||
> >     >         >     +      (len % elsz != 0)) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (len > 0) {
> >     >         >     +    *buf = malloc(len);
> >     >         >     +    if (*buf == NULL) {
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +
> >     >         >     +    if (rtems_ofw_get_enc_prop(node, propname,
> >     *buf, len)
> >     >         == -1) {
> >     >         >     +      rtems_ofw_free(buf);
> >     >         >     +      *buf = NULL;
> >     >         >     +      return -1;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return (len / elsz);
> >     >         >     +}
> >     >         >     +
> >     >         >     +void rtems_ofw_free( void *buf )
> >     >         >     +{
> >     >         >     +  free(buf);
> >     >         >     +}
> >     >         >     +
> >     >         >     +int rtems_ofw_next_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *previous,
> >     >         >     +  char        *buf,
> >     >         >     +  size_t       len
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  const void *name;
> >     >         >     +  const void *prop;
> >     >         >     +  int offset;
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +
> >     >         >     +  if (offset < 0) {
> >     >         >     +    return -1;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (previous == NULL) {
> >     >         >     +    offset = fdt_first_property_offset(fdtp,
> offset);
> >     >         >     +  } else {
> >     >         >     +    fdt_for_each_property_offset(offset, fdtp,
> >     offset) {
> >     >         >     +      prop = fdt_getprop_by_offset(fdtp, offset,
> >     (const char
> >     >         >     **)&name, NULL);
> >     >         >     +      if (prop == NULL)
> >     >         >     +        return -1;
> >     >         >     +
> >     >         >     +      if (strcmp(previous, name) != 0)
> >     >         >     +        continue;
> >     >         >     +
> >     >         >     +      offset = fdt_next_property_offset(fdtp,
> offset);
> >     >         >     +      break;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  if (offset < 0)
> >     >         >     +    return 0;
> >     >         >     +
> >     >         >     +  prop = fdt_getprop_by_offset(fdtp, offset, (const
> >     char
> >     >         **)&name,
> >     >         >     &offset);
> >     >         >     +  if (prop == NULL)
> >     >         >     +    return -1;
> >     >         >     +
> >     >         >     +  strncpy(buf, name, len);
> >     >         >     +
> >     >         >     +  return 1;
> >     >         >     +}
> >     >         >     +
> >     >         >     +int rtems_ofw_set_prop(
> >     >         >     +  phandle_t    node,
> >     >         >     +  const char  *name,
> >     >         >     +  const void  *buf,
> >     >         >     +  size_t       len
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +
> >     >         >     +  if (offset < 0)
> >     >         >     +    return -1;
> >     >         >     +
> >     >         >     +  if (fdt_setprop_inplace(fdtp, offset, name, buf,
> >     len) != 0)
> >     >         >     +    return (fdt_setprop(fdtp, offset, name, buf,
> len));
> >     >         >     +
> >     >         >     +  return 0;
> >     >         >     +}
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_find_device( const char *path )
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +
> >     >         >     +  offset = fdt_path_offset(fdtp, path);
> >     >         >     +  if (offset < 0)
> >     >         >     +    return -1;
> >     >         >     +
> >     >         >     +  return rtems_fdt_offset_to_phandle(offset);
> >     >         >     +}
> >     >         >     +
> >     >         >     +static phandle_t rtems_ofw_get_effective_phandle(
> >     >         >     +  phandle_t node,
> >     >         >     +  phandle_t xref
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  phandle_t child;
> >     >         >     +  phandle_t ref;
> >     >         >     +
> >     >         >     +  for (child = rtems_ofw_child(node); child != 0;
> >     child =
> >     >         >     rtems_ofw_peer(child)) {
> >     >         >     +    ref = rtems_ofw_get_effective_phandle(child,
> xref);
> >     >         >     +    if (ref != -1)
> >     >         >     +      return ref;
> >     >         >     +
> >     >         >     +    if (rtems_ofw_get_enc_prop(child, "phandle",
> &ref,
> >     >         sizeof(ref))
> >     >         >     == -1 &&
> >     >         >     +        rtems_ofw_get_enc_prop(child,
> >     "ibm,phandle", &ref,
> >     >         >     sizeof(ref)) == -1 &&
> >     >         >     +        rtems_ofw_get_enc_prop(child,
> >     "linux,phandle", &ref,
> >     >         >     sizeof(ref)) == -1
> >     >         >     +    ) {
> >     >         >     +      continue;
> >     >         >     +    }
> >     >         >     +
> >     >         >     +    if (ref == xref)
> >     >         >     +      return child;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return -1;
> >     >         >     +}
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_node_from_xref( phandle_t xref )
> >     >         >     +{
> >     >         >     +  phandle_t node;
> >     >         >     +
> >     >         >     +  if ((node =
> >     >         rtems_ofw_get_effective_phandle(rtems_ofw_peer(0),
> >     >         >     xref)) == -1)
> >     >         >     +    return xref;
> >     >         >     +
> >     >         >     +  return node;
> >     >         >     +}
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_xref_from_node( phandle_t node )
> >     >         >     +{
> >     >         >     +  phandle_t ref;
> >     >         >     +
> >     >         >     +    if (rtems_ofw_get_enc_prop(node, "phandle",
> &ref,
> >     >         sizeof(ref))
> >     >         >     == -1 &&
> >     >         >     +        rtems_ofw_get_enc_prop(node, "ibm,phandle",
> >     &ref,
> >     >         >     sizeof(ref)) == -1 &&
> >     >         >     +        rtems_ofw_get_enc_prop(node,
> >     "linux,phandle", &ref,
> >     >         >     sizeof(ref)) == -1)
> >     >         >     +    {
> >     >         >     +      return node;
> >     >         >     +    }
> >     >         >     +
> >     >         >     +    return ref;
> >     >         >     +}
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_instance_to_package( ihandle_t
> >     instance )
> >     >         >     +{
> >     >         >     +  return rtems_ofw_node_from_xref(instance);
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_package_to_path(
> >     >         >     +  phandle_t   node,
> >     >         >     +  char       *buf,
> >     >         >     +  size_t      len
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +  int rv;
> >     >         >     +
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(node);
> >     >         >     +
> >     >         >     +  rv = fdt_get_path(fdtp, offset, buf, len);
> >     >         >     +  if (rv != 0)
> >     >         >     +    return -1;
> >     >         >     +
> >     >         >     +  return rv;
> >     >         >     +}
> >     >         >     +
> >     >         >     +ssize_t rtems_ofw_instance_to_path(
> >     >         >     +  ihandle_t  instance,
> >     >         >     +  char      *buf,
> >     >         >     +  size_t     len
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +  int rv;
> >     >         >     +
> >     >         >     +  offset = rtems_ofw_instance_to_package(instance);
> >     >         >     +  offset = rtems_fdt_phandle_to_offset(offset);
> >     >         >     +
> >     >         >     +  rv = fdt_get_path(fdtp, offset, buf, len);
> >     >         >     +  if (rv != 0)
> >     >         >     +    return -1;
> >     >         >     +
> >     >         >     +  return rv;
> >     >         >     +}
> >     >         >     +
> >     >         >     +int rtems_ofw_get_reg(
> >     >         >     +  phandle_t              node,
> >     >         >     +  rtems_ofw_memory_area *buf,
> >     >         >     +  size_t                 size
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  int len;
> >     >         >     +  int offset;
> >     >         >     +  int nranges;
> >     >         >     +  int nregs;
> >     >         >     +  phandle_t parent;
> >     >         >     +  rtems_ofw_ranges range;
> >     >         >     +  const rtems_ofw_ranges *ptr;
> >     >         >     +
> >     >         >     +  len = rtems_ofw_get_enc_prop(node, "reg", (pcell_t
> >     >         *)buf, size);
> >     >         >     +  if (len <= 0) {
> >     >         >     +    return len;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  nregs = MIN(len, size) /
> >     sizeof(rtems_ofw_memory_area);
> >     >         >     +
> >     >         >     +  for (parent = rtems_ofw_parent(node); parent > 0;
> >     >         >     +      parent = rtems_ofw_parent(parent)) {
> >     >         >     +
> >     >         >     +    offset = rtems_fdt_phandle_to_offset(parent);
> >     >         >     +    ptr = fdt_getprop(fdtp, offset, "ranges", &len);
> >     >         >     +
> >     >         >     +    if (len < 0) {
> >     >         >     +      break;
> >     >         >     +    }
> >     >         >     +
> >     >         >     +    nranges = len / sizeof(rtems_ofw_ranges);
> >     >         >     +
> >     >         >     +    offset = 0;
> >     >         >     +    for (int i=0; i < nregs; i++) {
> >     >         >     +      for (int j=0; j < nranges; j++) {
> >     >         >     +
> >     >         >     +        range.parent_bus =
> >     fdt32_to_cpu(ptr[j].parent_bus);
> >     >         >     +        range.child_bus =
> >     fdt32_to_cpu(ptr[j].child_bus);
> >     >         >     +        range.size = fdt32_to_cpu(ptr[j].size);
> >     >         >     +
> >     >         >     +        if (buf[i].start >= range.child_bus &&
> >     >         >     +            buf[i].start < range.child_bus +
> >     range.size) {
> >     >         >     +          offset = range.parent_bus -
> range.child_bus;
> >     >         >     +          break;
> >     >         >     +        }
> >     >         >     +
> >     >         >     +      }
> >     >         >     +      buf[i].start += offset;
> >     >         >     +    }
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return nregs;
> >     >         >     +}
> >     >         >     +
> >     >         >     +int rtems_ofw_get_interrupts(
> >     >         >     +  phandle_t            node,
> >     >         >     +  rtems_vector_number *buf,
> >     >         >     +  size_t               size
> >     >         >     +)
> >     >         >     +{
> >     >         >     +  int rv;
> >     >         >     +
> >     >         >     +  rv = rtems_ofw_get_enc_prop(node, "interrupts",
> >     buf, size);
> >     >         >     +
> >     >         >     +  if (rv <= 0) {
> >     >         >     +    return rv;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return MIN(size, rv) /
> sizeof(rtems_vector_number);
> >     >         >     +}
> >     >         >     +
> >     >         >     +bool rtems_ofw_node_status( phandle_t node )
> >     >         >     +{
> >     >         >     +  int len;
> >     >         >     +  const char buf[10];
> >     >         >     +
> >     >         >     +  len = rtems_ofw_get_prop(node, "status", &buf[0],
> >     >         sizeof(buf));
> >     >         >     +  if ((len == -1) ||
> >     >         >     +      (strncmp(buf, "okay", MIN(5, len)) == 0) ||
> >     >         >     +      (strncmp(buf, "ok", MIN(3, len)) == 0)) {
> >     >         >     +      return true;
> >     >         >     +  }
> >     >         >     +
> >     >         >     +  return false;
> >     >         >     +}
> >     >         >     +
> >     >         >     +phandle_t rtems_ofw_find_device_by_compat( const
> char
> >     >         *compat )
> >     >         >     +{
> >     >         >     +  int offset;
> >     >         >     +
> >     >         >     +  offset = fdt_node_offset_by_compatible(fdtp, -1,
> >     compat);
> >     >         >     +  return rtems_fdt_offset_to_phandle(offset);
> >     >         >     +}
> >     >         >     diff --git a/spec/build/bsps/obj.yml
> >     b/spec/build/bsps/obj.yml
> >     >         >     index 8809238057..0ea07fc83d 100644
> >     >         >     --- a/spec/build/bsps/obj.yml
> >     >         >     +++ b/spec/build/bsps/obj.yml
> >     >         >     @@ -24,6 +24,10 @@ install:
> >     >         >        - bsps/include/bsp/u-boot.h
> >     >         >        - bsps/include/bsp/uart-output-char.h
> >     >         >        - bsps/include/bsp/utility.h
> >     >         >     +- destination: ${BSP_INCLUDEDIR}/ofw
> >     >         >     +  source:
> >     >         >     +  - bsps/include/ofw/ofw.h
> >     >         >     +  - bsps/include/ofw/ofw_compat.h
> >     >         >      - destination: ${BSP_INCLUDEDIR}/libchip
> >     >         >        source:
> >     >         >        - bsps/include/libchip/am29lv160.h
> >     >         >     @@ -104,4 +108,5 @@ source:
> >     >         >      - bsps/shared/dev/serial/z85c30_reg.c
> >     >         >      - bsps/shared/start/bootcard.c
> >     >         >      - bsps/shared/rtems-version.c
> >     >         >     +- bsps/shared/ofw/ofw.c
> >     >         >      type: build
> >     >         >     --
> >     >         >     2.17.1
> >     >         >
> >     >         >
> >     >         > _______________________________________________
> >     >         > devel mailing list
> >     >         > devel at rtems.org <mailto:devel at rtems.org>
> >     <mailto:devel at rtems.org <mailto:devel at rtems.org>>
> >     >         > http://lists.rtems.org/mailman/listinfo/devel
> >     >         >
> >     >
> >
> >
> > _______________________________________________
> > devel mailing list
> > devel at rtems.org
> > http://lists.rtems.org/mailman/listinfo/devel
> >
>
> --
> --------------------------------------------
> embedded brains GmbH
> Herr Christian Mauderer
> Dornierstr. 4
> D-82178 Puchheim
> Germany
> email: christian.mauderer at embedded-brains.de
> Phone: +49-89-18 94 741 - 18
> Fax:   +49-89-18 94 741 - 08
> PGP: Public key available on request.
>
> Diese Nachricht ist keine geschäftliche Mitteilung im Sinne des EHUG.
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.rtems.org/pipermail/devel/attachments/20201103/7852417a/attachment-0001.html>


More information about the devel mailing list