[PATCH] bsps/shared/ofw: Implement RTEMS OFW interface
Christian Mauderer
oss at c-mauderer.de
Tue Aug 18 18:06:43 UTC 2020
On 18/08/2020 19:01, Niteesh G. S. wrote:
>
>
> On Tue, Aug 18, 2020 at 8:26 PM Christian Mauderer <oss at c-mauderer.de
> <mailto:oss at c-mauderer.de>> wrote:
>
> On 18/08/2020 11:25, Niteesh G. S. wrote:
> > How can we make this API FreeBSD compatible? We have to declare
> > defines for the OFW functions
> > Eg. #define OF_finddevice rtems_ofw_find_device
>
> I think that was the plan, wasn't it?
>
>
> Is everyone OK with this? I am going to start working on it. I would like to
> get at least one of my patches merge readybefore GSoC ends.
>From the current timeframe I'm not sure whether the new build system is
ready till then. So for a merge we will need a backport. Sorry for that.
I expected the new build system to be integrated earlier. On the other
hand it shouldn't be too much work. Basically it means adding the two
sources into a file of the old build system instead of the new one.
> My other patches are somewhat dependent on this patch so I want to get
> this fixed first.
>
> I also have a few questions now. If we do this change in libBSD and what
> about the imported drivers present in RTEMS? They have to define these
> translations locally in the driver itself. Or we should move openfirm.h into
> RTEMS. Both have their own problems. The first one will create a lot of
> redundant code And the second one has the following problems.
>
> 1) Where to place openfirm.h in RTEMS?
> 2) What about functions like OF_device_from_xref etc?
> These functions depend on the libBSD device struct one hack is to forward
> declare these in the openfirm.h implemented in RTEMS. Is everyone OK
> with this or is there any better solution to this?
> 3) We also modify the interface is that fine with BSD-4 license?
>
There is a third possibility: You can place these defines in a header
(e.g. openfirm_compat.h) and include that in libbsds openfirm.h and in
the ported RTEMS drivers.
>
> >
> > Should I change the openfirm.h in libBSD to this use these defines
> instead
> > of calling the functions in openfirm.c? Though there are some
> > functions which
> > for which this cannot be done.
> > Eg: OF_device_from_xref
> > For this, we will have to use the implementation present in openfirm.c
>
> At least as long as no one implements a replacement, yes.
>
> >
> >
> > On Tue, Aug 18, 2020 at 7:57 AM Chris Johns <chrisj at rtems.org
> <mailto:chrisj at rtems.org>
> > <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>>> wrote:
> >
> > On 17/8/20 2:57 pm, Niteesh G. S. wrote:
> > > On Mon, Aug 17, 2020 at 3:49 AM Chris Johns
> <chrisj at rtems.org <mailto:chrisj at rtems.org>
> > <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>>
> > > <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>
> <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>>>> wrote:
> > >
> > > On 16/8/20 11:19 pm, Niteesh G. S. wrote:
> > > >
> > > > On Sun, Aug 16, 2020 at 2:25 PM Chris Johns
> > <chrisj at rtems.org <mailto:chrisj at rtems.org>
> <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>>
> > > <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>
> <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>>>
> > > > <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>
> <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>>
> > <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>
> <mailto:chrisj at rtems.org <mailto:chrisj at rtems.org>>>>> wrote:
> > > >
> > > > On 16/8/20 4:49 am, G S Niteesh Babu wrote:
> > > > > ---
> > > >
> > > > > +
> > > > > +#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);
> > > > > +
> > > > > + /*
> > > > > + * Is assert a good option to handle error?
> > > > > + * AFIAK there is no other way to recover from
> > invalid FDT.
> > > > > + * On providing an invalid FDT most driver's will
> > fail/crash anyway.
> > > > > + */
> > > >
> > > > If you want to fail with an error I suggest a
> documented
> > internal error. I
> > > > however would prefer we fail in degraded manner but I
> > understand this
> > > may not be
> > > > possible.
> > > >
> > > >
> > > > During the initial discussion, we discussed adding a new
> > error code in
> > > case of an
> > > > invalid FDT, something like BSP_INVALID_FDT. I had
> also sent
> > a patch but
> > > then we
> > > > decided not to add one(for some reason that I don't
> > remember). Instead, use
> > > > RTEMS_NOT_CONFIGURED. This has also been used in my
> previous
> > OFW patch.
> > >
> > > I am sorry I missed the discussion or I would have
> commented.
> > Currently the FDT
> > > support in RTEMS is hostile. If you build a u-boot image and
> > forget to add FDT
> > > support added you get a low level crash dump and that is
> > unfriendly. I woud like
> > > to this changed.
> > >
> > > So should we add a proper fatal code in case of invalid FDT
> or FDT
> > is not provided?
> > > ARM, POWERPC and RISCV are the only architectures in RTEMS that
> > use FDT.
> > > Can we add an FDT check inside start.S before bsp_fdt_copy? and
> > fail properly in
> > > case of an invalid FDT.
> > > Or is it a better idea to add the check inside bsp_fdt_copy but
> > bsp_fdt_copy is
> > > optional
> > > in architectures like ARM, RISCV it is compile time guarded with
> > > BSP_START_COPY_FDT_FROM_UBOOT
> >
> > The crash only happens when you run libbsd so I feel the issue
> is in
> > there. If
> > support has been added to libbsd for FDT for a specific arch
> and BSP
> > then the
> > libbsd start up (or what ever) needs to handle the the lack of FDT
> > support in a
> > better manner than a crash. This could a console message and an
> > `exit()` or a
> > fatal RTEMS error. I am not sure.
> >
> > I do not want to stall this work for this issue if it can be
> > resolved else
> > where. What is not clear to me is how this can be resolved at a
> > system level and
> > I would like to see libbsd cleaned up and made a little friendlier
> > for FDT
> > support but that is not what this effort is about. I am not across
> > all the
> > detail to know what is needed so I hope others will help here.
> >
> > Chris
> >
> > >
> > > > So should we add a new error code like BSP_INVALID_FDT and
> > fatal exit or just
> > > > use RTEMS_NOT_CONIGURED like the previous patch?
> > >
> > > Not configured is fine with me.
> > >
> > > Chris
> > > >
> > > >
> > > > > + assert(rv == 0);
> > > >
> > > > I would prefer we did not make this code dependent on
> > -DNDEBUG.
> > > >
> > > > Chris
> > > >
> > > > > +
> > > > > + 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);
> > > > > +}
> > > > > +
> > > > > +size_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;
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_get_prop(
> > > > > + phandle_t node,
> > > > > + const char *propname,
> > > > > + void *buf,
> > > > > + size_t bufsize
> > > > > +)
> > > > > +{
> > > > > + 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;
> > > > > + }
> > > > > +
> > > > > + bcopy(prop, buf, MIN(len, bufsize));
> > > > > +
> > > > > + return len;
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_get_enc_prop(
> > > > > + phandle_t node,
> > > > > + const char *prop,
> > > > > + pcell_t *buf,
> > > > > + size_t len
> > > > > +)
> > > > > +{
> > > > > + size_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
> > > > > +)
> > > > > +{
> > > > > + size_t rv;
> > > > > +
> > > > > + rv = rtems_ofw_get_prop_len(node, propname);
> > > > > + return rv >= 0 ? 1 : 0;
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_search_prop(
> > > > > + phandle_t node,
> > > > > + const char *propname,
> > > > > + void *buf,
> > > > > + size_t len
> > > > > +)
> > > > > +{
> > > > > + size_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;
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_search_enc_prop(
> > > > > + phandle_t node,
> > > > > + const char *propname,
> > > > > + pcell_t *buf,
> > > > > + size_t len
> > > > > +)
> > > > > +{
> > > > > + size_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;
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_get_prop_alloc(
> > > > > + phandle_t node,
> > > > > + const char *propname,
> > > > > + void **buf
> > > > > +)
> > > > > +{
> > > > > + size_t len;
> > > > > +
> > > > > + if ((len = rtems_ofw_get_prop_len(node,
> propname))
> > == -1) {
> > > > > + return -1;
> > > > > + }
> > > > > +
> > > > > + *buf = NULL;
> > > > > +
> > > > > + if (len > 0) {
> > > > > + *buf = malloc(len);
> > > > > +
> > > > > + if (rtems_ofw_get_prop(node, propname,
> *buf, len)
> > == -1) {
> > > > > + rtems_ofw_free(buf);
> > > > > + *buf = NULL;
> > > > > + return -1;
> > > > > + }
> > > > > + }
> > > > > +
> > > > > + return len;
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_get_prop_alloc_multi(
> > > > > + phandle_t node,
> > > > > + const char *propname,
> > > > > + int elsz,
> > > > > + void **buf
> > > > > +)
> > > > > +{
> > > > > + size_t len;
> > > > > +
> > > > > + if ((len = rtems_ofw_get_prop_len(node,
> propname))
> > == -1 ||
> > > > > + (len % elsz != 0)) {
> > > > > + return -1;
> > > > > + }
> > > > > +
> > > > > + *buf = NULL;
> > > > > +
> > > > > + if (len > 0) {
> > > > > + *buf = malloc(len);
> > > > > +
> > > > > + if (rtems_ofw_get_prop(node, propname,
> *buf, len)
> > == -1) {
> > > > > + rtems_ofw_free(buf);
> > > > > + *buf = NULL;
> > > > > + return -1;
> > > > > + }
> > > > > + }
> > > > > +
> > > > > + return (len / elsz);
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_get_enc_prop_alloc(
> > > > > + phandle_t node,
> > > > > + const char *propname,
> > > > > + void **buf
> > > > > +)
> > > > > +{
> > > > > + size_t len;
> > > > > +
> > > > > + if ((len = rtems_ofw_get_prop_len(node,
> propname))
> > == -1) {
> > > > > + return -1;
> > > > > + }
> > > > > +
> > > > > + *buf = NULL;
> > > > > +
> > > > > + if (len > 0) {
> > > > > + *buf = malloc(len);
> > > > > +
> > > > > + if (rtems_ofw_get_enc_prop(node, propname,
> *buf,
> > len) == -1) {
> > > > > + rtems_ofw_free(buf);
> > > > > + *buf = NULL;
> > > > > + return -1;
> > > > > + }
> > > > > + }
> > > > > +
> > > > > + return len;
> > > > > +}
> > > > > +
> > > > > +size_t rtems_ofw_get_enc_prop_alloc_multi(
> > > > > + phandle_t node,
> > > > > + const char *propname,
> > > > > + int elsz,
> > > > > + void **buf
> > > > > +)
> > > > > +{
> > > > > + size_t len;
> > > > > +
> > > > > + if ((len = rtems_ofw_get_prop_len(node,
> propname))
> > == -1 ||
> > > > > + (len % elsz != 0)) {
> > > > > + return -1;
> > > > > + }
> > > > > +
> > > > > + *buf = NULL;
> > > > > +
> > > > > + if (len > 0) {
> > > > > + *buf = malloc(len);
> > > > > +
> > > > > + 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(node)) {
> > > > > + 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);
> > > > > +}
> > > > > +
> > > > > +size_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;
> > > > > +}
> > > > > +
> > > > > +size_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,
> > > > > + void *buf,
> > > > > + size_t size
> > > > > +)
> > > > > +{
> > > > > + int rv;
> > > > > +
> > > > > + rv = rtems_ofw_get_enc_prop(node, "interrupts",
> > buf, size);
> > > > > + return rv;
> > > > > +}
> > > > > +
> > > > > +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;
> > > > > +}
> > > > > diff --git a/spec/build/bsps/obj.yml
> > b/spec/build/bsps/obj.yml
> > > > > index 8809238057..141ba25f5e 100644
> > > > > --- a/spec/build/bsps/obj.yml
> > > > > +++ b/spec/build/bsps/obj.yml
> > > > > @@ -24,6 +24,9 @@ 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
> > > > > - destination: ${BSP_INCLUDEDIR}/libchip
> > > > > source:
> > > > > - bsps/include/libchip/am29lv160.h
> > > > > @@ -104,4 +107,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
> > > > >
> > > >
> > >
> >
> >
> > _______________________________________________
> > devel mailing list
> > devel at rtems.org <mailto:devel at rtems.org>
> > http://lists.rtems.org/mailman/listinfo/devel
> >
>
More information about the devel
mailing list