1 /* 2 * This file does the necessary interface mapping between the bootwrapper 3 * device tree operations and the interface provided by shared source 4 * files flatdevicetree.[ch]. 5 * 6 * Copyright 2007 David Gibson, IBM Corporation. 7 * 8 * This library is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of the 11 * License, or (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this library; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 21 * 02110-1301 USA 22 */ 23 24 #include <stddef.h> 25 #include <stdio.h> 26 #include <page.h> 27 #include <libfdt.h> 28 #include "ops.h" 29 30 #define DEBUG 0 31 #define BAD_ERROR(err) (((err) < 0) \ 32 && ((err) != -FDT_ERR_NOTFOUND) \ 33 && ((err) != -FDT_ERR_EXISTS)) 34 35 #define check_err(err) \ 36 ({ \ 37 if (BAD_ERROR(err) || ((err < 0) && DEBUG)) \ 38 printf("%s():%d %s\n\r", __func__, __LINE__, \ 39 fdt_strerror(err)); \ 40 if (BAD_ERROR(err)) \ 41 exit(); \ 42 (err < 0) ? -1 : 0; \ 43 }) 44 45 #define offset_devp(off) \ 46 ({ \ 47 int _offset = (off); \ 48 check_err(_offset) ? NULL : (void *)(_offset+1); \ 49 }) 50 51 #define devp_offset_find(devp) (((int)(devp))-1) 52 #define devp_offset(devp) (devp ? ((int)(devp))-1 : 0) 53 54 static void *fdt; 55 static void *buf; /* = NULL */ 56 57 #define EXPAND_GRANULARITY 1024 58 59 static void expand_buf(int minexpand) 60 { 61 int size = fdt_totalsize(fdt); 62 int rc; 63 64 size = _ALIGN(size + minexpand, EXPAND_GRANULARITY); 65 buf = platform_ops.realloc(buf, size); 66 if (!buf) 67 fatal("Couldn't find %d bytes to expand device tree\n\r", size); 68 rc = fdt_open_into(fdt, buf, size); 69 if (rc != 0) 70 fatal("Couldn't expand fdt into new buffer: %s\n\r", 71 fdt_strerror(rc)); 72 73 fdt = buf; 74 } 75 76 static void *fdt_wrapper_finddevice(const char *path) 77 { 78 return offset_devp(fdt_path_offset(fdt, path)); 79 } 80 81 static int fdt_wrapper_getprop(const void *devp, const char *name, 82 void *buf, const int buflen) 83 { 84 const void *p; 85 int len; 86 87 p = fdt_getprop(fdt, devp_offset(devp), name, &len); 88 if (!p) 89 return check_err(len); 90 memcpy(buf, p, min(len, buflen)); 91 return len; 92 } 93 94 static int fdt_wrapper_setprop(const void *devp, const char *name, 95 const void *buf, const int len) 96 { 97 int rc; 98 99 rc = fdt_setprop(fdt, devp_offset(devp), name, buf, len); 100 if (rc == -FDT_ERR_NOSPACE) { 101 expand_buf(len + 16); 102 rc = fdt_setprop(fdt, devp_offset(devp), name, buf, len); 103 } 104 105 return check_err(rc); 106 } 107 108 static int fdt_wrapper_del_node(const void *devp) 109 { 110 return fdt_del_node(fdt, devp_offset(devp)); 111 } 112 113 static void *fdt_wrapper_get_parent(const void *devp) 114 { 115 return offset_devp(fdt_parent_offset(fdt, devp_offset(devp))); 116 } 117 118 static void *fdt_wrapper_create_node(const void *devp, const char *name) 119 { 120 int offset; 121 122 offset = fdt_add_subnode(fdt, devp_offset(devp), name); 123 if (offset == -FDT_ERR_NOSPACE) { 124 expand_buf(strlen(name) + 16); 125 offset = fdt_add_subnode(fdt, devp_offset(devp), name); 126 } 127 128 return offset_devp(offset); 129 } 130 131 static void *fdt_wrapper_find_node_by_prop_value(const void *prev, 132 const char *name, 133 const char *val, 134 int len) 135 { 136 int offset = fdt_node_offset_by_prop_value(fdt, devp_offset_find(prev), 137 name, val, len); 138 return offset_devp(offset); 139 } 140 141 static void *fdt_wrapper_find_node_by_compatible(const void *prev, 142 const char *val) 143 { 144 int offset = fdt_node_offset_by_compatible(fdt, devp_offset_find(prev), 145 val); 146 return offset_devp(offset); 147 } 148 149 static char *fdt_wrapper_get_path(const void *devp, char *buf, int len) 150 { 151 int rc; 152 153 rc = fdt_get_path(fdt, devp_offset(devp), buf, len); 154 if (check_err(rc)) 155 return NULL; 156 return buf; 157 } 158 159 static unsigned long fdt_wrapper_finalize(void) 160 { 161 int rc; 162 163 rc = fdt_pack(fdt); 164 if (rc != 0) 165 fatal("Couldn't pack flat tree: %s\n\r", 166 fdt_strerror(rc)); 167 return (unsigned long)fdt; 168 } 169 170 void fdt_init(void *blob) 171 { 172 int err; 173 int bufsize; 174 175 dt_ops.finddevice = fdt_wrapper_finddevice; 176 dt_ops.getprop = fdt_wrapper_getprop; 177 dt_ops.setprop = fdt_wrapper_setprop; 178 dt_ops.get_parent = fdt_wrapper_get_parent; 179 dt_ops.create_node = fdt_wrapper_create_node; 180 dt_ops.find_node_by_prop_value = fdt_wrapper_find_node_by_prop_value; 181 dt_ops.find_node_by_compatible = fdt_wrapper_find_node_by_compatible; 182 dt_ops.del_node = fdt_wrapper_del_node; 183 dt_ops.get_path = fdt_wrapper_get_path; 184 dt_ops.finalize = fdt_wrapper_finalize; 185 186 /* Make sure the dt blob is the right version and so forth */ 187 fdt = blob; 188 bufsize = fdt_totalsize(fdt) + EXPAND_GRANULARITY; 189 buf = malloc(bufsize); 190 if(!buf) 191 fatal("malloc failed. can't relocate the device tree\n\r"); 192 193 err = fdt_open_into(fdt, buf, bufsize); 194 195 if (err != 0) 196 fatal("fdt_init(): %s\n\r", fdt_strerror(err)); 197 198 fdt = buf; 199 } 200