fdt: rework fdt_fixup_ethernet() to use env instead of bd_t
[platform/kernel/u-boot.git] / common / fdt_support.c
1 /*
2  * (C) Copyright 2007
3  * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program 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
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <common.h>
25 #include <linux/ctype.h>
26 #include <linux/types.h>
27 #include <asm/global_data.h>
28 #include <fdt.h>
29 #include <libfdt.h>
30 #include <fdt_support.h>
31 #include <exports.h>
32
33 /*
34  * Global data (for the gd->bd)
35  */
36 DECLARE_GLOBAL_DATA_PTR;
37
38
39 /**
40  * fdt_find_and_setprop: Find a node and set it's property
41  *
42  * @fdt: ptr to device tree
43  * @node: path of node
44  * @prop: property name
45  * @val: ptr to new value
46  * @len: length of new property value
47  * @create: flag to create the property if it doesn't exist
48  *
49  * Convenience function to directly set a property given the path to the node.
50  */
51 int fdt_find_and_setprop(void *fdt, const char *node, const char *prop,
52                          const void *val, int len, int create)
53 {
54         int nodeoff = fdt_path_offset(fdt, node);
55
56         if (nodeoff < 0)
57                 return nodeoff;
58
59         if ((!create) && (fdt_get_property(fdt, nodeoff, prop, 0) == NULL))
60                 return 0; /* create flag not set; so exit quietly */
61
62         return fdt_setprop(fdt, nodeoff, prop, val, len);
63 }
64
65 #ifdef CONFIG_OF_STDOUT_VIA_ALIAS
66 static int fdt_fixup_stdout(void *fdt, int chosenoff)
67 {
68         int err = 0;
69 #ifdef CONFIG_CONS_INDEX
70         int node;
71         char sername[9] = { 0 };
72         const char *path;
73
74         sprintf(sername, "serial%d", CONFIG_CONS_INDEX - 1);
75
76         err = node = fdt_path_offset(fdt, "/aliases");
77         if (node >= 0) {
78                 int len;
79                 path = fdt_getprop(fdt, node, sername, &len);
80                 if (path) {
81                         char *p = malloc(len);
82                         err = -FDT_ERR_NOSPACE;
83                         if (p) {
84                                 memcpy(p, path, len);
85                                 err = fdt_setprop(fdt, chosenoff,
86                                         "linux,stdout-path", p, len);
87                                 free(p);
88                         }
89                 } else {
90                         err = len;
91                 }
92         }
93 #endif
94         if (err < 0)
95                 printf("WARNING: could not set linux,stdout-path %s.\n",
96                                 fdt_strerror(err));
97
98         return err;
99 }
100 #endif
101
102 int fdt_chosen(void *fdt, ulong initrd_start, ulong initrd_end, int force)
103 {
104         int   nodeoffset;
105         int   err;
106         u32   tmp;              /* used to set 32 bit integer properties */
107         char  *str;             /* used to set string properties */
108         const char *path;
109
110         err = fdt_check_header(fdt);
111         if (err < 0) {
112                 printf("fdt_chosen: %s\n", fdt_strerror(err));
113                 return err;
114         }
115
116         if (initrd_start && initrd_end) {
117                 uint64_t addr, size;
118                 int  total = fdt_num_mem_rsv(fdt);
119                 int  j;
120
121                 /*
122                  * Look for an existing entry and update it.  If we don't find
123                  * the entry, we will j be the next available slot.
124                  */
125                 for (j = 0; j < total; j++) {
126                         err = fdt_get_mem_rsv(fdt, j, &addr, &size);
127                         if (addr == initrd_start) {
128                                 fdt_del_mem_rsv(fdt, j);
129                                 break;
130                         }
131                 }
132
133                 err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start + 1);
134                 if (err < 0) {
135                         printf("fdt_chosen: %s\n", fdt_strerror(err));
136                         return err;
137                 }
138         }
139
140         /*
141          * Find the "chosen" node.
142          */
143         nodeoffset = fdt_path_offset (fdt, "/chosen");
144
145         /*
146          * If there is no "chosen" node in the blob, create it.
147          */
148         if (nodeoffset < 0) {
149                 /*
150                  * Create a new node "/chosen" (offset 0 is root level)
151                  */
152                 nodeoffset = fdt_add_subnode(fdt, 0, "chosen");
153                 if (nodeoffset < 0) {
154                         printf("WARNING: could not create /chosen %s.\n",
155                                 fdt_strerror(nodeoffset));
156                         return nodeoffset;
157                 }
158         }
159
160         /*
161          * Create /chosen properites that don't exist in the fdt.
162          * If the property exists, update it only if the "force" parameter
163          * is true.
164          */
165         str = getenv("bootargs");
166         if (str != NULL) {
167                 path = fdt_getprop(fdt, nodeoffset, "bootargs", NULL);
168                 if ((path == NULL) || force) {
169                         err = fdt_setprop(fdt, nodeoffset,
170                                 "bootargs", str, strlen(str)+1);
171                         if (err < 0)
172                                 printf("WARNING: could not set bootargs %s.\n",
173                                         fdt_strerror(err));
174                 }
175         }
176         if (initrd_start && initrd_end) {
177                 path = fdt_getprop(fdt, nodeoffset, "linux,initrd-start", NULL);
178                 if ((path == NULL) || force) {
179                         tmp = __cpu_to_be32(initrd_start);
180                         err = fdt_setprop(fdt, nodeoffset,
181                                 "linux,initrd-start", &tmp, sizeof(tmp));
182                         if (err < 0)
183                                 printf("WARNING: "
184                                         "could not set linux,initrd-start %s.\n",
185                                         fdt_strerror(err));
186                         tmp = __cpu_to_be32(initrd_end);
187                         err = fdt_setprop(fdt, nodeoffset,
188                                 "linux,initrd-end", &tmp, sizeof(tmp));
189                         if (err < 0)
190                                 printf("WARNING: could not set linux,initrd-end %s.\n",
191                                         fdt_strerror(err));
192                 }
193         }
194
195 #ifdef CONFIG_OF_STDOUT_VIA_ALIAS
196         path = fdt_getprop(fdt, nodeoffset, "linux,stdout-path", NULL);
197         if ((path == NULL) || force)
198                 err = fdt_fixup_stdout(fdt, nodeoffset);
199 #endif
200
201 #ifdef OF_STDOUT_PATH
202         path = fdt_getprop(fdt, nodeoffset, "linux,stdout-path", NULL);
203         if ((path == NULL) || force) {
204                 err = fdt_setprop(fdt, nodeoffset,
205                         "linux,stdout-path", OF_STDOUT_PATH, strlen(OF_STDOUT_PATH)+1);
206                 if (err < 0)
207                         printf("WARNING: could not set linux,stdout-path %s.\n",
208                                 fdt_strerror(err));
209         }
210 #endif
211
212         return err;
213 }
214
215 void do_fixup_by_path(void *fdt, const char *path, const char *prop,
216                       const void *val, int len, int create)
217 {
218 #if defined(DEBUG)
219         int i;
220         debug("Updating property '%s/%s' = ", path, prop);
221         for (i = 0; i < len; i++)
222                 debug(" %.2x", *(u8*)(val+i));
223         debug("\n");
224 #endif
225         int rc = fdt_find_and_setprop(fdt, path, prop, val, len, create);
226         if (rc)
227                 printf("Unable to update property %s:%s, err=%s\n",
228                         path, prop, fdt_strerror(rc));
229 }
230
231 void do_fixup_by_path_u32(void *fdt, const char *path, const char *prop,
232                           u32 val, int create)
233 {
234         val = cpu_to_fdt32(val);
235         do_fixup_by_path(fdt, path, prop, &val, sizeof(val), create);
236 }
237
238 void do_fixup_by_prop(void *fdt,
239                       const char *pname, const void *pval, int plen,
240                       const char *prop, const void *val, int len,
241                       int create)
242 {
243         int off;
244 #if defined(DEBUG)
245         int i;
246         debug("Updating property '%s' = ", prop);
247         for (i = 0; i < len; i++)
248                 debug(" %.2x", *(u8*)(val+i));
249         debug("\n");
250 #endif
251         off = fdt_node_offset_by_prop_value(fdt, -1, pname, pval, plen);
252         while (off != -FDT_ERR_NOTFOUND) {
253                 if (create || (fdt_get_property(fdt, off, prop, 0) != NULL))
254                         fdt_setprop(fdt, off, prop, val, len);
255                 off = fdt_node_offset_by_prop_value(fdt, off, pname, pval, plen);
256         }
257 }
258
259 void do_fixup_by_prop_u32(void *fdt,
260                           const char *pname, const void *pval, int plen,
261                           const char *prop, u32 val, int create)
262 {
263         val = cpu_to_fdt32(val);
264         do_fixup_by_prop(fdt, pname, pval, plen, prop, &val, 4, create);
265 }
266
267 void do_fixup_by_compat(void *fdt, const char *compat,
268                         const char *prop, const void *val, int len, int create)
269 {
270         int off = -1;
271 #if defined(DEBUG)
272         int i;
273         debug("Updating property '%s' = ", prop);
274         for (i = 0; i < len; i++)
275                 debug(" %.2x", *(u8*)(val+i));
276         debug("\n");
277 #endif
278         off = fdt_node_offset_by_compatible(fdt, -1, compat);
279         while (off != -FDT_ERR_NOTFOUND) {
280                 if (create || (fdt_get_property(fdt, off, prop, 0) != NULL))
281                         fdt_setprop(fdt, off, prop, val, len);
282                 off = fdt_node_offset_by_compatible(fdt, off, compat);
283         }
284 }
285
286 void do_fixup_by_compat_u32(void *fdt, const char *compat,
287                             const char *prop, u32 val, int create)
288 {
289         val = cpu_to_fdt32(val);
290         do_fixup_by_compat(fdt, compat, prop, &val, 4, create);
291 }
292
293 int fdt_fixup_memory(void *blob, u64 start, u64 size)
294 {
295         int err, nodeoffset, len = 0;
296         u8 tmp[16];
297         const u32 *addrcell, *sizecell;
298
299         err = fdt_check_header(blob);
300         if (err < 0) {
301                 printf("%s: %s\n", __FUNCTION__, fdt_strerror(err));
302                 return err;
303         }
304
305         /* update, or add and update /memory node */
306         nodeoffset = fdt_path_offset(blob, "/memory");
307         if (nodeoffset < 0) {
308                 nodeoffset = fdt_add_subnode(blob, 0, "memory");
309                 if (nodeoffset < 0)
310                         printf("WARNING: could not create /memory: %s.\n",
311                                         fdt_strerror(nodeoffset));
312                 return nodeoffset;
313         }
314         err = fdt_setprop(blob, nodeoffset, "device_type", "memory",
315                         sizeof("memory"));
316         if (err < 0) {
317                 printf("WARNING: could not set %s %s.\n", "device_type",
318                                 fdt_strerror(err));
319                 return err;
320         }
321
322         addrcell = fdt_getprop(blob, 0, "#address-cells", NULL);
323         /* use shifts and mask to ensure endianness */
324         if ((addrcell) && (*addrcell == 2)) {
325                 tmp[0] = (start >> 56) & 0xff;
326                 tmp[1] = (start >> 48) & 0xff;
327                 tmp[2] = (start >> 40) & 0xff;
328                 tmp[3] = (start >> 32) & 0xff;
329                 tmp[4] = (start >> 24) & 0xff;
330                 tmp[5] = (start >> 16) & 0xff;
331                 tmp[6] = (start >>  8) & 0xff;
332                 tmp[7] = (start      ) & 0xff;
333                 len = 8;
334         } else {
335                 tmp[0] = (start >> 24) & 0xff;
336                 tmp[1] = (start >> 16) & 0xff;
337                 tmp[2] = (start >>  8) & 0xff;
338                 tmp[3] = (start      ) & 0xff;
339                 len = 4;
340         }
341
342         sizecell = fdt_getprop(blob, 0, "#size-cells", NULL);
343         /* use shifts and mask to ensure endianness */
344         if ((sizecell) && (*sizecell == 2)) {
345                 tmp[0+len] = (size >> 56) & 0xff;
346                 tmp[1+len] = (size >> 48) & 0xff;
347                 tmp[2+len] = (size >> 40) & 0xff;
348                 tmp[3+len] = (size >> 32) & 0xff;
349                 tmp[4+len] = (size >> 24) & 0xff;
350                 tmp[5+len] = (size >> 16) & 0xff;
351                 tmp[6+len] = (size >>  8) & 0xff;
352                 tmp[7+len] = (size      ) & 0xff;
353                 len += 8;
354         } else {
355                 tmp[0+len] = (size >> 24) & 0xff;
356                 tmp[1+len] = (size >> 16) & 0xff;
357                 tmp[2+len] = (size >>  8) & 0xff;
358                 tmp[3+len] = (size      ) & 0xff;
359                 len += 4;
360         }
361
362         err = fdt_setprop(blob, nodeoffset, "reg", tmp, len);
363         if (err < 0) {
364                 printf("WARNING: could not set %s %s.\n",
365                                 "reg", fdt_strerror(err));
366                 return err;
367         }
368         return 0;
369 }
370
371 void fdt_fixup_ethernet(void *fdt)
372 {
373         int node, i, j;
374         char enet[16], *tmp, *end;
375         char mac[16] = "ethaddr";
376         const char *path;
377         unsigned char mac_addr[6];
378
379         node = fdt_path_offset(fdt, "/aliases");
380         if (node < 0)
381                 return;
382
383         i = 0;
384         while ((tmp = getenv(mac)) != NULL) {
385                 sprintf(enet, "ethernet%d", i);
386                 path = fdt_getprop(fdt, node, enet, NULL);
387                 if (!path) {
388                         debug("No alias for %s\n", enet);
389                         sprintf(mac, "eth%daddr", ++i);
390                         continue;
391                 }
392
393                 for (j = 0; j < 6; j++) {
394                         mac_addr[j] = tmp ? simple_strtoul(tmp, &end, 16) : 0;
395                         if (tmp)
396                                 tmp = (*end) ? end+1 : end;
397                 }
398
399                 do_fixup_by_path(fdt, path, "mac-address", &mac_addr, 6, 0);
400                 do_fixup_by_path(fdt, path, "local-mac-address",
401                                 &mac_addr, 6, 1);
402
403                 sprintf(mac, "eth%daddr", ++i);
404         }
405 }
406
407 #ifdef CONFIG_HAS_FSL_DR_USB
408 void fdt_fixup_dr_usb(void *blob, bd_t *bd)
409 {
410         char *mode;
411         const char *compat = "fsl-usb2-dr";
412         const char *prop = "dr_mode";
413         int node_offset;
414         int err;
415
416         mode = getenv("usb_dr_mode");
417         if (!mode)
418                 return;
419
420         node_offset = fdt_node_offset_by_compatible(blob, 0, compat);
421         if (node_offset < 0)
422                 printf("WARNING: could not find compatible node %s: %s.\n",
423                         compat, fdt_strerror(node_offset));
424
425         err = fdt_setprop(blob, node_offset, prop, mode, strlen(mode) + 1);
426         if (err < 0)
427                 printf("WARNING: could not set %s for %s: %s.\n",
428                        prop, compat, fdt_strerror(err));
429 }
430 #endif /* CONFIG_HAS_FSL_DR_USB */
431
432 #if defined(CONFIG_MPC83XX) || defined(CONFIG_MPC85xx)
433 /*
434  * update crypto node properties to a specified revision of the SEC
435  * called with sec_rev == 0 if not on an mpc8xxxE processor
436  */
437 void fdt_fixup_crypto_node(void *blob, int sec_rev)
438 {
439         const struct sec_rev_prop {
440                 u32 sec_rev;
441                 u32 num_channels;
442                 u32 channel_fifo_len;
443                 u32 exec_units_mask;
444                 u32 descriptor_types_mask;
445         } sec_rev_prop_list [] = {
446                 { 0x0200, 4, 24, 0x07e, 0x01010ebf }, /* SEC 2.0 */
447                 { 0x0201, 4, 24, 0x0fe, 0x012b0ebf }, /* SEC 2.1 */
448                 { 0x0202, 1, 24, 0x04c, 0x0122003f }, /* SEC 2.2 */
449                 { 0x0204, 4, 24, 0x07e, 0x012b0ebf }, /* SEC 2.4 */
450                 { 0x0300, 4, 24, 0x9fe, 0x03ab0ebf }, /* SEC 3.0 */
451                 { 0x0303, 4, 24, 0x97c, 0x03ab0abf }, /* SEC 3.3 */
452         };
453         char compat_strlist[ARRAY_SIZE(sec_rev_prop_list) *
454                             sizeof("fsl,secX.Y")];
455         int crypto_node, sec_idx, err;
456         char *p;
457         u32 val;
458
459         /* locate crypto node based on lowest common compatible */
460         crypto_node = fdt_node_offset_by_compatible(blob, -1, "fsl,sec2.0");
461         if (crypto_node == -FDT_ERR_NOTFOUND)
462                 return;
463
464         /* delete it if not on an E-processor */
465         if (crypto_node > 0 && !sec_rev) {
466                 fdt_del_node(blob, crypto_node);
467                 return;
468         }
469
470         /* else we got called for possible uprev */
471         for (sec_idx = 0; sec_idx < ARRAY_SIZE(sec_rev_prop_list); sec_idx++)
472                 if (sec_rev_prop_list[sec_idx].sec_rev == sec_rev)
473                         break;
474
475         if (sec_idx == ARRAY_SIZE(sec_rev_prop_list)) {
476                 puts("warning: unknown SEC revision number\n");
477                 return;
478         }
479
480         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].num_channels);
481         err = fdt_setprop(blob, crypto_node, "fsl,num-channels", &val, 4);
482         if (err < 0)
483                 printf("WARNING: could not set crypto property: %s\n",
484                        fdt_strerror(err));
485
486         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].descriptor_types_mask);
487         err = fdt_setprop(blob, crypto_node, "fsl,descriptor-types-mask", &val, 4);
488         if (err < 0)
489                 printf("WARNING: could not set crypto property: %s\n",
490                        fdt_strerror(err));
491
492         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].exec_units_mask);
493         err = fdt_setprop(blob, crypto_node, "fsl,exec-units-mask", &val, 4);
494         if (err < 0)
495                 printf("WARNING: could not set crypto property: %s\n",
496                        fdt_strerror(err));
497
498         val = cpu_to_fdt32(sec_rev_prop_list[sec_idx].channel_fifo_len);
499         err = fdt_setprop(blob, crypto_node, "fsl,channel-fifo-len", &val, 4);
500         if (err < 0)
501                 printf("WARNING: could not set crypto property: %s\n",
502                        fdt_strerror(err));
503
504         val = 0;
505         while (sec_idx >= 0) {
506                 p = compat_strlist + val;
507                 val += sprintf(p, "fsl,sec%d.%d",
508                         (sec_rev_prop_list[sec_idx].sec_rev & 0xff00) >> 8,
509                         sec_rev_prop_list[sec_idx].sec_rev & 0x00ff) + 1;
510                 sec_idx--;
511         }
512         err = fdt_setprop(blob, crypto_node, "compatible", &compat_strlist, val);
513         if (err < 0)
514                 printf("WARNING: could not set crypto property: %s\n",
515                        fdt_strerror(err));
516 }
517 #endif /* defined(CONFIG_MPC83XX) || defined(CONFIG_MPC85xx) */