Changeset 42f1b37 in rtems for cpukit/dtc


Ignore:
Timestamp:
Oct 18, 2017, 6:22:40 AM (2 years ago)
Author:
David Gibson <david@…>
Branches:
master
Children:
4e5f848
Parents:
f5e879f
git-author:
David Gibson <david@…> (10/18/17 06:22:40)
git-committer:
Sebastian Huber <sebastian.huber@…> (07/19/18 05:01:11)
Message:

libfdt: Remove leading underscores from identifiers

In a lot of places libfdt uses a leading _ character to mark an identifier
as "internal" (not part of the published libfdt API). This is a bad idea,
because identifiers with a leading _ are generally reserved by the C
library or system. It's particularly dangerous for libfdt, because it's
designed to be able to be integrated into lots of different environments.

In some cases the leading _ has no purpose, so we simply drop it. In most
cases we move it to the end, as our new convention for marking internal
identifiers.

Signed-off-by: David Gibson <david@…>

Location:
cpukit/dtc/libfdt
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • cpukit/dtc/libfdt/fdt.c

    rf5e879f r42f1b37  
    8989                        return NULL;
    9090
    91         return _fdt_offset_ptr(fdt, offset);
     91        return fdt_offset_ptr_(fdt, offset);
    9292}
    9393
     
    142142}
    143143
    144 int _fdt_check_node_offset(const void *fdt, int offset)
     144int fdt_check_node_offset_(const void *fdt, int offset)
    145145{
    146146        if ((offset < 0) || (offset % FDT_TAGSIZE)
     
    151151}
    152152
    153 int _fdt_check_prop_offset(const void *fdt, int offset)
     153int fdt_check_prop_offset_(const void *fdt, int offset)
    154154{
    155155        if ((offset < 0) || (offset % FDT_TAGSIZE)
     
    166166
    167167        if (offset >= 0)
    168                 if ((nextoffset = _fdt_check_node_offset(fdt, offset)) < 0)
     168                if ((nextoffset = fdt_check_node_offset_(fdt, offset)) < 0)
    169169                        return nextoffset;
    170170
     
    228228}
    229229
    230 const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
     230const char *fdt_find_string_(const char *strtab, int tabsize, const char *s)
    231231{
    232232        int len = strlen(s) + 1;
  • cpukit/dtc/libfdt/fdt_ro.c

    rf5e879f r42f1b37  
    5656#include "libfdt_internal.h"
    5757
    58 static int _fdt_nodename_eq(const void *fdt, int offset,
     58static int fdt_nodename_eq_(const void *fdt, int offset,
    5959                            const char *s, int len)
    6060{
     
    8181}
    8282
    83 static int _fdt_string_eq(const void *fdt, int stroffset,
     83static int fdt_string_eq_(const void *fdt, int stroffset,
    8484                          const char *s, int len)
    8585{
     
    118118{
    119119        FDT_CHECK_HEADER(fdt);
    120         *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
    121         *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
     120        *address = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->address);
     121        *size = fdt64_to_cpu(fdt_mem_rsv_(fdt, n)->size);
    122122        return 0;
    123123}
     
    127127        int i = 0;
    128128
    129         while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
     129        while (fdt64_to_cpu(fdt_mem_rsv_(fdt, i)->size) != 0)
    130130                i++;
    131131        return i;
    132132}
    133133
    134 static int _nextprop(const void *fdt, int offset)
     134static int nextprop_(const void *fdt, int offset)
    135135{
    136136        uint32_t tag;
     
    167167             offset = fdt_next_node(fdt, offset, &depth))
    168168                if ((depth == 1)
    169                     && _fdt_nodename_eq(fdt, offset, name, namelen))
     169                    && fdt_nodename_eq_(fdt, offset, name, namelen))
    170170                        return offset;
    171171
     
    233233const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
    234234{
    235         const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);
     235        const struct fdt_node_header *nh = fdt_offset_ptr_(fdt, nodeoffset);
    236236        int err;
    237237
    238238        if (((err = fdt_check_header(fdt)) != 0)
    239             || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
     239            || ((err = fdt_check_node_offset_(fdt, nodeoffset)) < 0))
    240240                        goto fail;
    241241
     
    255255        int offset;
    256256
    257         if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
     257        if ((offset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
    258258                return offset;
    259259
    260         return _nextprop(fdt, offset);
     260        return nextprop_(fdt, offset);
    261261}
    262262
    263263int fdt_next_property_offset(const void *fdt, int offset)
    264264{
    265         if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)
     265        if ((offset = fdt_check_prop_offset_(fdt, offset)) < 0)
    266266                return offset;
    267267
    268         return _nextprop(fdt, offset);
     268        return nextprop_(fdt, offset);
    269269}
    270270
     
    276276        const struct fdt_property *prop;
    277277
    278         if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
     278        if ((err = fdt_check_prop_offset_(fdt, offset)) < 0) {
    279279                if (lenp)
    280280                        *lenp = err;
     
    282282        }
    283283
    284         prop = _fdt_offset_ptr(fdt, offset);
     284        prop = fdt_offset_ptr_(fdt, offset);
    285285
    286286        if (lenp)
     
    304304                        break;
    305305                }
    306                 if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
     306                if (fdt_string_eq_(fdt, fdt32_to_cpu(prop->nameoff),
    307307                                   name, namelen))
    308308                        return prop;
  • cpukit/dtc/libfdt/fdt_rw.c

    rf5e879f r42f1b37  
    5656#include "libfdt_internal.h"
    5757
    58 static int _fdt_blocks_misordered(const void *fdt,
    59                               int mem_rsv_size, int struct_size)
     58static int fdt_blocks_misordered_(const void *fdt,
     59                                  int mem_rsv_size, int struct_size)
    6060{
    6161        return (fdt_off_mem_rsvmap(fdt) < FDT_ALIGN(sizeof(struct fdt_header), 8))
     
    6868}
    6969
    70 static int _fdt_rw_check_header(void *fdt)
     70static int fdt_rw_check_header_(void *fdt)
    7171{
    7272        FDT_CHECK_HEADER(fdt);
     
    7474        if (fdt_version(fdt) < 17)
    7575                return -FDT_ERR_BADVERSION;
    76         if (_fdt_blocks_misordered(fdt, sizeof(struct fdt_reserve_entry),
     76        if (fdt_blocks_misordered_(fdt, sizeof(struct fdt_reserve_entry),
    7777                                   fdt_size_dt_struct(fdt)))
    7878                return -FDT_ERR_BADLAYOUT;
     
    8585#define FDT_RW_CHECK_HEADER(fdt) \
    8686        { \
    87                 int __err; \
    88                 if ((__err = _fdt_rw_check_header(fdt)) != 0) \
    89                         return __err; \
     87                int err_; \
     88                if ((err_ = fdt_rw_check_header_(fdt)) != 0) \
     89                        return err_; \
    9090        }
    9191
    92 static inline int _fdt_data_size(void *fdt)
     92static inline int fdt_data_size_(void *fdt)
    9393{
    9494        return fdt_off_dt_strings(fdt) + fdt_size_dt_strings(fdt);
    9595}
    9696
    97 static int _fdt_splice(void *fdt, void *splicepoint, int oldlen, int newlen)
     97static int fdt_splice_(void *fdt, void *splicepoint, int oldlen, int newlen)
    9898{
    9999        char *p = splicepoint;
    100         char *end = (char *)fdt + _fdt_data_size(fdt);
     100        char *end = (char *)fdt + fdt_data_size_(fdt);
    101101
    102102        if (((p + oldlen) < p) || ((p + oldlen) > end))
     
    110110}
    111111
    112 static int _fdt_splice_mem_rsv(void *fdt, struct fdt_reserve_entry *p,
     112static int fdt_splice_mem_rsv_(void *fdt, struct fdt_reserve_entry *p,
    113113                               int oldn, int newn)
    114114{
    115115        int delta = (newn - oldn) * sizeof(*p);
    116116        int err;
    117         err = _fdt_splice(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
     117        err = fdt_splice_(fdt, p, oldn * sizeof(*p), newn * sizeof(*p));
    118118        if (err)
    119119                return err;
     
    123123}
    124124
    125 static int _fdt_splice_struct(void *fdt, void *p,
     125static int fdt_splice_struct_(void *fdt, void *p,
    126126                              int oldlen, int newlen)
    127127{
     
    129129        int err;
    130130
    131         if ((err = _fdt_splice(fdt, p, oldlen, newlen)))
     131        if ((err = fdt_splice_(fdt, p, oldlen, newlen)))
    132132                return err;
    133133
     
    137137}
    138138
    139 static int _fdt_splice_string(void *fdt, int newlen)
     139static int fdt_splice_string_(void *fdt, int newlen)
    140140{
    141141        void *p = (char *)fdt
     
    143143        int err;
    144144
    145         if ((err = _fdt_splice(fdt, p, 0, newlen)))
     145        if ((err = fdt_splice_(fdt, p, 0, newlen)))
    146146                return err;
    147147
     
    150150}
    151151
    152 static int _fdt_find_add_string(void *fdt, const char *s)
     152static int fdt_find_add_string_(void *fdt, const char *s)
    153153{
    154154        char *strtab = (char *)fdt + fdt_off_dt_strings(fdt);
     
    158158        int err;
    159159
    160         p = _fdt_find_string(strtab, fdt_size_dt_strings(fdt), s);
     160        p = fdt_find_string_(strtab, fdt_size_dt_strings(fdt), s);
    161161        if (p)
    162162                /* found it */
     
    164164
    165165        new = strtab + fdt_size_dt_strings(fdt);
    166         err = _fdt_splice_string(fdt, len);
     166        err = fdt_splice_string_(fdt, len);
    167167        if (err)
    168168                return err;
     
    179179        FDT_RW_CHECK_HEADER(fdt);
    180180
    181         re = _fdt_mem_rsv_w(fdt, fdt_num_mem_rsv(fdt));
    182         err = _fdt_splice_mem_rsv(fdt, re, 0, 1);
     181        re = fdt_mem_rsv_w_(fdt, fdt_num_mem_rsv(fdt));
     182        err = fdt_splice_mem_rsv_(fdt, re, 0, 1);
    183183        if (err)
    184184                return err;
     
    191191int fdt_del_mem_rsv(void *fdt, int n)
    192192{
    193         struct fdt_reserve_entry *re = _fdt_mem_rsv_w(fdt, n);
     193        struct fdt_reserve_entry *re = fdt_mem_rsv_w_(fdt, n);
    194194
    195195        FDT_RW_CHECK_HEADER(fdt);
     
    198198                return -FDT_ERR_NOTFOUND;
    199199
    200         return _fdt_splice_mem_rsv(fdt, re, 1, 0);
    201 }
    202 
    203 static int _fdt_resize_property(void *fdt, int nodeoffset, const char *name,
     200        return fdt_splice_mem_rsv_(fdt, re, 1, 0);
     201}
     202
     203static int fdt_resize_property_(void *fdt, int nodeoffset, const char *name,
    204204                                int len, struct fdt_property **prop)
    205205{
     
    211211                return oldlen;
    212212
    213         if ((err = _fdt_splice_struct(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
     213        if ((err = fdt_splice_struct_(fdt, (*prop)->data, FDT_TAGALIGN(oldlen),
    214214                                      FDT_TAGALIGN(len))))
    215215                return err;
     
    219219}
    220220
    221 static int _fdt_add_property(void *fdt, int nodeoffset, const char *name,
     221static int fdt_add_property_(void *fdt, int nodeoffset, const char *name,
    222222                             int len, struct fdt_property **prop)
    223223{
     
    227227        int err;
    228228
    229         if ((nextoffset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
     229        if ((nextoffset = fdt_check_node_offset_(fdt, nodeoffset)) < 0)
    230230                return nextoffset;
    231231
    232         namestroff = _fdt_find_add_string(fdt, name);
     232        namestroff = fdt_find_add_string_(fdt, name);
    233233        if (namestroff < 0)
    234234                return namestroff;
    235235
    236         *prop = _fdt_offset_ptr_w(fdt, nextoffset);
     236        *prop = fdt_offset_ptr_w_(fdt, nextoffset);
    237237        proplen = sizeof(**prop) + FDT_TAGALIGN(len);
    238238
    239         err = _fdt_splice_struct(fdt, *prop, 0, proplen);
     239        err = fdt_splice_struct_(fdt, *prop, 0, proplen);
    240240        if (err)
    241241                return err;
     
    261261        newlen = strlen(name);
    262262
    263         err = _fdt_splice_struct(fdt, namep, FDT_TAGALIGN(oldlen+1),
     263        err = fdt_splice_struct_(fdt, namep, FDT_TAGALIGN(oldlen+1),
    264264                                 FDT_TAGALIGN(newlen+1));
    265265        if (err)
     
    278278        FDT_RW_CHECK_HEADER(fdt);
    279279
    280         err = _fdt_resize_property(fdt, nodeoffset, name, len, &prop);
     280        err = fdt_resize_property_(fdt, nodeoffset, name, len, &prop);
    281281        if (err == -FDT_ERR_NOTFOUND)
    282                 err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
     282                err = fdt_add_property_(fdt, nodeoffset, name, len, &prop);
    283283        if (err)
    284284                return err;
     
    314314        if (prop) {
    315315                newlen = len + oldlen;
    316                 err = _fdt_splice_struct(fdt, prop->data,
     316                err = fdt_splice_struct_(fdt, prop->data,
    317317                                         FDT_TAGALIGN(oldlen),
    318318                                         FDT_TAGALIGN(newlen));
     
    322322                memcpy(prop->data + oldlen, val, len);
    323323        } else {
    324                 err = _fdt_add_property(fdt, nodeoffset, name, len, &prop);
     324                err = fdt_add_property_(fdt, nodeoffset, name, len, &prop);
    325325                if (err)
    326326                        return err;
     
    342342
    343343        proplen = sizeof(*prop) + FDT_TAGALIGN(len);
    344         return _fdt_splice_struct(fdt, prop, proplen, 0);
     344        return fdt_splice_struct_(fdt, prop, proplen, 0);
    345345}
    346346
     
    370370        } while ((tag == FDT_PROP) || (tag == FDT_NOP));
    371371
    372         nh = _fdt_offset_ptr_w(fdt, offset);
     372        nh = fdt_offset_ptr_w_(fdt, offset);
    373373        nodelen = sizeof(*nh) + FDT_TAGALIGN(namelen+1) + FDT_TAGSIZE;
    374374
    375         err = _fdt_splice_struct(fdt, nh, 0, nodelen);
     375        err = fdt_splice_struct_(fdt, nh, 0, nodelen);
    376376        if (err)
    377377                return err;
     
    397397        FDT_RW_CHECK_HEADER(fdt);
    398398
    399         endoffset = _fdt_node_end_offset(fdt, nodeoffset);
     399        endoffset = fdt_node_end_offset_(fdt, nodeoffset);
    400400        if (endoffset < 0)
    401401                return endoffset;
    402402
    403         return _fdt_splice_struct(fdt, _fdt_offset_ptr_w(fdt, nodeoffset),
     403        return fdt_splice_struct_(fdt, fdt_offset_ptr_w_(fdt, nodeoffset),
    404404                                  endoffset - nodeoffset, 0);
    405405}
    406406
    407 static void _fdt_packblocks(const char *old, char *new,
     407static void fdt_packblocks_(const char *old, char *new,
    408408                            int mem_rsv_size, int struct_size)
    409409{
     
    451451        }
    452452
    453         if (!_fdt_blocks_misordered(fdt, mem_rsv_size, struct_size)) {
     453        if (!fdt_blocks_misordered_(fdt, mem_rsv_size, struct_size)) {
    454454                /* no further work necessary */
    455455                err = fdt_move(fdt, buf, bufsize);
     
    479479        }
    480480
    481         _fdt_packblocks(fdt, tmp, mem_rsv_size, struct_size);
     481        fdt_packblocks_(fdt, tmp, mem_rsv_size, struct_size);
    482482        memmove(buf, tmp, newsize);
    483483
     
    499499        mem_rsv_size = (fdt_num_mem_rsv(fdt)+1)
    500500                * sizeof(struct fdt_reserve_entry);
    501         _fdt_packblocks(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
    502         fdt_set_totalsize(fdt, _fdt_data_size(fdt));
    503 
    504         return 0;
    505 }
     501        fdt_packblocks_(fdt, fdt, mem_rsv_size, fdt_size_dt_struct(fdt));
     502        fdt_set_totalsize(fdt, fdt_data_size_(fdt));
     503
     504        return 0;
     505}
  • cpukit/dtc/libfdt/fdt_sw.c

    rf5e879f r42f1b37  
    5656#include "libfdt_internal.h"
    5757
    58 static int _fdt_sw_check_header(void *fdt)
     58static int fdt_sw_check_header_(void *fdt)
    5959{
    6060        if (fdt_magic(fdt) != FDT_SW_MAGIC)
     
    6767        { \
    6868                int err; \
    69                 if ((err = _fdt_sw_check_header(fdt)) != 0) \
     69                if ((err = fdt_sw_check_header_(fdt)) != 0) \
    7070                        return err; \
    7171        }
    7272
    73 static void *_fdt_grab_space(void *fdt, size_t len)
     73static void *fdt_grab_space_(void *fdt, size_t len)
    7474{
    7575        int offset = fdt_size_dt_struct(fdt);
     
    8383
    8484        fdt_set_size_dt_struct(fdt, offset + len);
    85         return _fdt_offset_ptr_w(fdt, offset);
     85        return fdt_offset_ptr_w_(fdt, offset);
    8686}
    8787
     
    175175        FDT_SW_CHECK_HEADER(fdt);
    176176
    177         nh = _fdt_grab_space(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
     177        nh = fdt_grab_space_(fdt, sizeof(*nh) + FDT_TAGALIGN(namelen));
    178178        if (! nh)
    179179                return -FDT_ERR_NOSPACE;
     
    190190        FDT_SW_CHECK_HEADER(fdt);
    191191
    192         en = _fdt_grab_space(fdt, FDT_TAGSIZE);
     192        en = fdt_grab_space_(fdt, FDT_TAGSIZE);
    193193        if (! en)
    194194                return -FDT_ERR_NOSPACE;
     
    198198}
    199199
    200 static int _fdt_find_add_string(void *fdt, const char *s)
     200static int fdt_find_add_string_(void *fdt, const char *s)
    201201{
    202202        char *strtab = (char *)fdt + fdt_totalsize(fdt);
     
    206206        int struct_top, offset;
    207207
    208         p = _fdt_find_string(strtab - strtabsize, strtabsize, s);
     208        p = fdt_find_string_(strtab - strtabsize, strtabsize, s);
    209209        if (p)
    210210                return p - strtab;
     
    228228        FDT_SW_CHECK_HEADER(fdt);
    229229
    230         nameoff = _fdt_find_add_string(fdt, name);
     230        nameoff = fdt_find_add_string_(fdt, name);
    231231        if (nameoff == 0)
    232232                return -FDT_ERR_NOSPACE;
    233233
    234         prop = _fdt_grab_space(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
     234        prop = fdt_grab_space_(fdt, sizeof(*prop) + FDT_TAGALIGN(len));
    235235        if (! prop)
    236236                return -FDT_ERR_NOSPACE;
     
    266266
    267267        /* Add terminator */
    268         end = _fdt_grab_space(fdt, sizeof(*end));
     268        end = fdt_grab_space_(fdt, sizeof(*end));
    269269        if (! end)
    270270                return -FDT_ERR_NOSPACE;
     
    282282                if (tag == FDT_PROP) {
    283283                        struct fdt_property *prop =
    284                                 _fdt_offset_ptr_w(fdt, offset);
     284                                fdt_offset_ptr_w_(fdt, offset);
    285285                        int nameoff;
    286286
  • cpukit/dtc/libfdt/fdt_wip.c

    rf5e879f r42f1b37  
    9494}
    9595
    96 static void _fdt_nop_region(void *start, int len)
     96static void fdt_nop_region_(void *start, int len)
    9797{
    9898        fdt32_t *p;
     
    111111                return len;
    112112
    113         _fdt_nop_region(prop, len + sizeof(*prop));
     113        fdt_nop_region_(prop, len + sizeof(*prop));
    114114
    115115        return 0;
    116116}
    117117
    118 int _fdt_node_end_offset(void *fdt, int offset)
     118int fdt_node_end_offset_(void *fdt, int offset)
    119119{
    120120        int depth = 0;
     
    130130        int endoffset;
    131131
    132         endoffset = _fdt_node_end_offset(fdt, nodeoffset);
     132        endoffset = fdt_node_end_offset_(fdt, nodeoffset);
    133133        if (endoffset < 0)
    134134                return endoffset;
    135135
    136         _fdt_nop_region(fdt_offset_ptr_w(fdt, nodeoffset, 0),
     136        fdt_nop_region_(fdt_offset_ptr_w(fdt, nodeoffset, 0),
    137137                        endoffset - nodeoffset);
    138138        return 0;
  • cpukit/dtc/libfdt/libfdt_internal.h

    rf5e879f r42f1b37  
    1 #ifndef _LIBFDT_INTERNAL_H
    2 #define _LIBFDT_INTERNAL_H
     1#ifndef LIBFDT_INTERNAL_H
     2#define LIBFDT_INTERNAL_H
    33/*
    44 * libfdt - Flat Device Tree manipulation
     
    5858#define FDT_CHECK_HEADER(fdt) \
    5959        { \
    60                 int __err; \
    61                 if ((__err = fdt_check_header(fdt)) != 0) \
    62                         return __err; \
     60                int err_; \
     61                if ((err_ = fdt_check_header(fdt)) != 0) \
     62                        return err_; \
    6363        }
    6464
    65 int _fdt_check_node_offset(const void *fdt, int offset);
    66 int _fdt_check_prop_offset(const void *fdt, int offset);
    67 const char *_fdt_find_string(const char *strtab, int tabsize, const char *s);
    68 int _fdt_node_end_offset(void *fdt, int nodeoffset);
     65int fdt_check_node_offset_(const void *fdt, int offset);
     66int fdt_check_prop_offset_(const void *fdt, int offset);
     67const char *fdt_find_string_(const char *strtab, int tabsize, const char *s);
     68int fdt_node_end_offset_(void *fdt, int nodeoffset);
    6969
    70 static inline const void *_fdt_offset_ptr(const void *fdt, int offset)
     70static inline const void *fdt_offset_ptr_(const void *fdt, int offset)
    7171{
    7272        return (const char *)fdt + fdt_off_dt_struct(fdt) + offset;
    7373}
    7474
    75 static inline void *_fdt_offset_ptr_w(void *fdt, int offset)
     75static inline void *fdt_offset_ptr_w_(void *fdt, int offset)
    7676{
    77         return (void *)(uintptr_t)_fdt_offset_ptr(fdt, offset);
     77        return (void *)(uintptr_t)fdt_offset_ptr_(fdt, offset);
    7878}
    7979
    80 static inline const struct fdt_reserve_entry *_fdt_mem_rsv(const void *fdt, int n)
     80static inline const struct fdt_reserve_entry *fdt_mem_rsv_(const void *fdt, int n)
    8181{
    8282        const struct fdt_reserve_entry *rsv_table =
     
    8686        return rsv_table + n;
    8787}
    88 static inline struct fdt_reserve_entry *_fdt_mem_rsv_w(void *fdt, int n)
     88static inline struct fdt_reserve_entry *fdt_mem_rsv_w_(void *fdt, int n)
    8989{
    90         return (void *)(uintptr_t)_fdt_mem_rsv(fdt, n);
     90        return (void *)(uintptr_t)fdt_mem_rsv_(fdt, n);
    9191}
    9292
    9393#define FDT_SW_MAGIC            (~FDT_MAGIC)
    9494
    95 #endif /* _LIBFDT_INTERNAL_H */
     95#endif /* LIBFDT_INTERNAL_H */
Note: See TracChangeset for help on using the changeset viewer.