1 /* prom_common.c: OF device tree support common code. 2 * 3 * Paul Mackerras August 1996. 4 * Copyright (C) 1996-2005 Paul Mackerras. 5 * 6 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 7 * {engebret|bergner}@us.ibm.com 8 * 9 * Adapted for sparc by David S. Miller davem@davemloft.net 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 */ 16 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/errno.h> 20 #include <linux/mutex.h> 21 #include <linux/slab.h> 22 #include <linux/of.h> 23 #include <linux/of_pdt.h> 24 #include <asm/prom.h> 25 #include <asm/oplib.h> 26 #include <asm/leon.h> 27 28 #include "prom.h" 29 30 struct device_node *of_console_device; 31 EXPORT_SYMBOL(of_console_device); 32 33 char *of_console_path; 34 EXPORT_SYMBOL(of_console_path); 35 36 char *of_console_options; 37 EXPORT_SYMBOL(of_console_options); 38 39 int of_getintprop_default(struct device_node *np, const char *name, int def) 40 { 41 struct property *prop; 42 int len; 43 44 prop = of_find_property(np, name, &len); 45 if (!prop || len != 4) 46 return def; 47 48 return *(int *) prop->value; 49 } 50 EXPORT_SYMBOL(of_getintprop_default); 51 52 DEFINE_MUTEX(of_set_property_mutex); 53 EXPORT_SYMBOL(of_set_property_mutex); 54 55 int of_set_property(struct device_node *dp, const char *name, void *val, int len) 56 { 57 struct property **prevp; 58 void *new_val; 59 int err; 60 61 new_val = kmalloc(len, GFP_KERNEL); 62 if (!new_val) 63 return -ENOMEM; 64 65 memcpy(new_val, val, len); 66 67 err = -ENODEV; 68 69 mutex_lock(&of_set_property_mutex); 70 write_lock(&devtree_lock); 71 prevp = &dp->properties; 72 while (*prevp) { 73 struct property *prop = *prevp; 74 75 if (!strcasecmp(prop->name, name)) { 76 void *old_val = prop->value; 77 int ret; 78 79 ret = prom_setprop(dp->phandle, name, val, len); 80 81 err = -EINVAL; 82 if (ret >= 0) { 83 prop->value = new_val; 84 prop->length = len; 85 86 if (OF_IS_DYNAMIC(prop)) 87 kfree(old_val); 88 89 OF_MARK_DYNAMIC(prop); 90 91 err = 0; 92 } 93 break; 94 } 95 prevp = &(*prevp)->next; 96 } 97 write_unlock(&devtree_lock); 98 mutex_unlock(&of_set_property_mutex); 99 100 /* XXX Upate procfs if necessary... */ 101 102 return err; 103 } 104 EXPORT_SYMBOL(of_set_property); 105 106 int of_find_in_proplist(const char *list, const char *match, int len) 107 { 108 while (len > 0) { 109 int l; 110 111 if (!strcmp(list, match)) 112 return 1; 113 l = strlen(list) + 1; 114 list += l; 115 len -= l; 116 } 117 return 0; 118 } 119 EXPORT_SYMBOL(of_find_in_proplist); 120 121 /* 122 * SPARC32 and SPARC64's prom_nextprop() do things differently 123 * here, despite sharing the same interface. SPARC32 doesn't fill in 'buf', 124 * returning NULL on an error. SPARC64 fills in 'buf', but sets it to an 125 * empty string upon error. 126 */ 127 static int __init handle_nextprop_quirks(char *buf, const char *name) 128 { 129 if (!name || strlen(name) == 0) 130 return -1; 131 132 #ifdef CONFIG_SPARC32 133 strcpy(buf, name); 134 #endif 135 return 0; 136 } 137 138 static int __init prom_common_nextprop(phandle node, char *prev, char *buf) 139 { 140 const char *name; 141 142 buf[0] = '\0'; 143 name = prom_nextprop(node, prev, buf); 144 return handle_nextprop_quirks(buf, name); 145 } 146 147 unsigned int prom_early_allocated __initdata; 148 149 static struct of_pdt_ops prom_sparc_ops __initdata = { 150 .nextprop = prom_common_nextprop, 151 .getproplen = prom_getproplen, 152 .getproperty = prom_getproperty, 153 .getchild = prom_getchild, 154 .getsibling = prom_getsibling, 155 }; 156 157 void __init prom_build_devicetree(void) 158 { 159 of_pdt_build_devicetree(prom_root_node, &prom_sparc_ops); 160 of_console_init(); 161 162 pr_info("PROM: Built device tree with %u bytes of memory.\n", 163 prom_early_allocated); 164 } 165