hc
2024-08-09 d3d58fa5ee2428cd2dde78fd8eeeeabe916b3835
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
// SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause)
/*
 * libfdt - Flat Device Tree manipulation
 * Copyright (C) 2006 David Gibson, IBM Corporation.
 */
#include "libfdt_env.h"
 
#include <fdt.h>
#include <libfdt.h>
 
#include "libfdt_internal.h"
 
int fdt_setprop_inplace_namelen_partial(void *fdt, int nodeoffset,
                   const char *name, int namelen,
                   uint32_t idx, const void *val,
                   int len)
{
   void *propval;
   int proplen;
 
   propval = fdt_getprop_namelen_w(fdt, nodeoffset, name, namelen,
                   &proplen);
   if (!propval)
       return proplen;
 
   if ((unsigned)proplen < (len + idx))
       return -FDT_ERR_NOSPACE;
 
   memcpy((char *)propval + idx, val, len);
   return 0;
}
 
int fdt_setprop_inplace(void *fdt, int nodeoffset, const char *name,
           const void *val, int len)
{
   const void *propval;
   int proplen;
 
   propval = fdt_getprop(fdt, nodeoffset, name, &proplen);
   if (!propval)
       return proplen;
 
   if (proplen != len)
       return -FDT_ERR_NOSPACE;
 
   return fdt_setprop_inplace_namelen_partial(fdt, nodeoffset, name,
                          strlen(name), 0,
                          val, len);
}
 
static void fdt_nop_region_(void *start, int len)
{
   fdt32_t *p;
 
   for (p = start; (char *)p < ((char *)start + len); p++)
       *p = cpu_to_fdt32(FDT_NOP);
}
 
int fdt_nop_property(void *fdt, int nodeoffset, const char *name)
{
   struct fdt_property *prop;
   int len;
 
   prop = fdt_get_property_w(fdt, nodeoffset, name, &len);
   if (!prop)
       return len;
 
   fdt_nop_region_(prop, len + sizeof(*prop));
 
   return 0;
}
 
int fdt_node_end_offset_(void *fdt, int offset)
{
   int depth = 0;
 
   while ((offset >= 0) && (depth >= 0))
       offset = fdt_next_node(fdt, offset, &depth);
 
   return offset;
}
 
int fdt_nop_node(void *fdt, int nodeoffset)
{
   int endoffset;
 
   endoffset = fdt_node_end_offset_(fdt, nodeoffset);
   if (endoffset < 0)
       return endoffset;
 
   fdt_nop_region_(fdt_offset_ptr_w(fdt, nodeoffset, 0),
           endoffset - nodeoffset);
   return 0;
}