Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/arch/x86/platform/olpc/olpc_dt.c

  1 /*
  2  * OLPC-specific OFW device tree support code.
  3  *
  4  * Paul Mackerras       August 1996.
  5  * Copyright (C) 1996-2005 Paul Mackerras.
  6  *
  7  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
  8  *    {engebret|bergner}@us.ibm.com
  9  *
 10  *  Adapted for sparc by David S. Miller davem@davemloft.net
 11  *  Adapted for x86/OLPC by Andres Salomon <dilinger@queued.net>
 12  *
 13  *      This program is free software; you can redistribute it and/or
 14  *      modify it under the terms of the GNU General Public License
 15  *      as published by the Free Software Foundation; either version
 16  *      2 of the License, or (at your option) any later version.
 17  */
 18 
 19 #include <linux/kernel.h>
 20 #include <linux/bootmem.h>
 21 #include <linux/of.h>
 22 #include <linux/of_platform.h>
 23 #include <linux/of_pdt.h>
 24 #include <asm/olpc.h>
 25 #include <asm/olpc_ofw.h>
 26 
 27 static phandle __init olpc_dt_getsibling(phandle node)
 28 {
 29         const void *args[] = { (void *)node };
 30         void *res[] = { &node };
 31 
 32         if ((s32)node == -1)
 33                 return 0;
 34 
 35         if (olpc_ofw("peer", args, res) || (s32)node == -1)
 36                 return 0;
 37 
 38         return node;
 39 }
 40 
 41 static phandle __init olpc_dt_getchild(phandle node)
 42 {
 43         const void *args[] = { (void *)node };
 44         void *res[] = { &node };
 45 
 46         if ((s32)node == -1)
 47                 return 0;
 48 
 49         if (olpc_ofw("child", args, res) || (s32)node == -1) {
 50                 pr_err("PROM: %s: fetching child failed!\n", __func__);
 51                 return 0;
 52         }
 53 
 54         return node;
 55 }
 56 
 57 static int __init olpc_dt_getproplen(phandle node, const char *prop)
 58 {
 59         const void *args[] = { (void *)node, prop };
 60         int len;
 61         void *res[] = { &len };
 62 
 63         if ((s32)node == -1)
 64                 return -1;
 65 
 66         if (olpc_ofw("getproplen", args, res)) {
 67                 pr_err("PROM: %s: getproplen failed!\n", __func__);
 68                 return -1;
 69         }
 70 
 71         return len;
 72 }
 73 
 74 static int __init olpc_dt_getproperty(phandle node, const char *prop,
 75                 char *buf, int bufsize)
 76 {
 77         int plen;
 78 
 79         plen = olpc_dt_getproplen(node, prop);
 80         if (plen > bufsize || plen < 1) {
 81                 return -1;
 82         } else {
 83                 const void *args[] = { (void *)node, prop, buf, (void *)plen };
 84                 void *res[] = { &plen };
 85 
 86                 if (olpc_ofw("getprop", args, res)) {
 87                         pr_err("PROM: %s: getprop failed!\n", __func__);
 88                         return -1;
 89                 }
 90         }
 91 
 92         return plen;
 93 }
 94 
 95 static int __init olpc_dt_nextprop(phandle node, char *prev, char *buf)
 96 {
 97         const void *args[] = { (void *)node, prev, buf };
 98         int success;
 99         void *res[] = { &success };
100 
101         buf[0] = '\0';
102 
103         if ((s32)node == -1)
104                 return -1;
105 
106         if (olpc_ofw("nextprop", args, res) || success != 1)
107                 return -1;
108 
109         return 0;
110 }
111 
112 static int __init olpc_dt_pkg2path(phandle node, char *buf,
113                 const int buflen, int *len)
114 {
115         const void *args[] = { (void *)node, buf, (void *)buflen };
116         void *res[] = { len };
117 
118         if ((s32)node == -1)
119                 return -1;
120 
121         if (olpc_ofw("package-to-path", args, res) || *len < 1)
122                 return -1;
123 
124         return 0;
125 }
126 
127 static unsigned int prom_early_allocated __initdata;
128 
129 void * __init prom_early_alloc(unsigned long size)
130 {
131         static u8 *mem;
132         static size_t free_mem;
133         void *res;
134 
135         if (free_mem < size) {
136                 const size_t chunk_size = max(PAGE_SIZE, size);
137 
138                 /*
139                  * To mimimize the number of allocations, grab at least
140                  * PAGE_SIZE of memory (that's an arbitrary choice that's
141                  * fast enough on the platforms we care about while minimizing
142                  * wasted bootmem) and hand off chunks of it to callers.
143                  */
144                 res = alloc_bootmem(chunk_size);
145                 BUG_ON(!res);
146                 prom_early_allocated += chunk_size;
147                 memset(res, 0, chunk_size);
148                 free_mem = chunk_size;
149                 mem = res;
150         }
151 
152         /* allocate from the local cache */
153         free_mem -= size;
154         res = mem;
155         mem += size;
156         return res;
157 }
158 
159 static struct of_pdt_ops prom_olpc_ops __initdata = {
160         .nextprop = olpc_dt_nextprop,
161         .getproplen = olpc_dt_getproplen,
162         .getproperty = olpc_dt_getproperty,
163         .getchild = olpc_dt_getchild,
164         .getsibling = olpc_dt_getsibling,
165         .pkg2path = olpc_dt_pkg2path,
166 };
167 
168 static phandle __init olpc_dt_finddevice(const char *path)
169 {
170         phandle node;
171         const void *args[] = { path };
172         void *res[] = { &node };
173 
174         if (olpc_ofw("finddevice", args, res)) {
175                 pr_err("olpc_dt: finddevice failed!\n");
176                 return 0;
177         }
178 
179         if ((s32) node == -1)
180                 return 0;
181 
182         return node;
183 }
184 
185 static int __init olpc_dt_interpret(const char *words)
186 {
187         int result;
188         const void *args[] = { words };
189         void *res[] = { &result };
190 
191         if (olpc_ofw("interpret", args, res)) {
192                 pr_err("olpc_dt: interpret failed!\n");
193                 return -1;
194         }
195 
196         return result;
197 }
198 
199 /*
200  * Extract board revision directly from OFW device tree.
201  * We can't use olpc_platform_info because that hasn't been set up yet.
202  */
203 static u32 __init olpc_dt_get_board_revision(void)
204 {
205         phandle node;
206         __be32 rev;
207         int r;
208 
209         node = olpc_dt_finddevice("/");
210         if (!node)
211                 return 0;
212 
213         r = olpc_dt_getproperty(node, "board-revision-int",
214                                 (char *) &rev, sizeof(rev));
215         if (r < 0)
216                 return 0;
217 
218         return be32_to_cpu(rev);
219 }
220 
221 void __init olpc_dt_fixup(void)
222 {
223         int r;
224         char buf[64];
225         phandle node;
226         u32 board_rev;
227 
228         node = olpc_dt_finddevice("/battery@0");
229         if (!node)
230                 return;
231 
232         /*
233          * If the battery node has a compatible property, we are running a new
234          * enough firmware and don't have fixups to make.
235          */
236         r = olpc_dt_getproperty(node, "compatible", buf, sizeof(buf));
237         if (r > 0)
238                 return;
239 
240         pr_info("PROM DT: Old firmware detected, applying fixes\n");
241 
242         /* Add olpc,xo1-battery compatible marker to battery node */
243         olpc_dt_interpret("\" /battery@0\" find-device"
244                 " \" olpc,xo1-battery\" +compatible"
245                 " device-end");
246 
247         board_rev = olpc_dt_get_board_revision();
248         if (!board_rev)
249                 return;
250 
251         if (board_rev >= olpc_board_pre(0xd0)) {
252                 /* XO-1.5: add dcon device */
253                 olpc_dt_interpret("\" /pci/display@1\" find-device"
254                         " new-device"
255                         " \" dcon\" device-name \" olpc,xo1-dcon\" +compatible"
256                         " finish-device device-end");
257         } else {
258                 /* XO-1: add dcon device, mark RTC as olpc,xo1-rtc */
259                 olpc_dt_interpret("\" /pci/display@1,1\" find-device"
260                         " new-device"
261                         " \" dcon\" device-name \" olpc,xo1-dcon\" +compatible"
262                         " finish-device device-end"
263                         " \" /rtc\" find-device"
264                         " \" olpc,xo1-rtc\" +compatible"
265                         " device-end");
266         }
267 }
268 
269 void __init olpc_dt_build_devicetree(void)
270 {
271         phandle root;
272 
273         if (!olpc_ofw_is_installed())
274                 return;
275 
276         olpc_dt_fixup();
277 
278         root = olpc_dt_getsibling(0);
279         if (!root) {
280                 pr_err("PROM: unable to get root node from OFW!\n");
281                 return;
282         }
283         of_pdt_build_devicetree(root, &prom_olpc_ops);
284 
285         pr_info("PROM DT: Built device tree with %u bytes of memory.\n",
286                         prom_early_allocated);
287 }
288 
289 /* A list of DT node/bus matches that we want to expose as platform devices */
290 static struct of_device_id __initdata of_ids[] = {
291         { .compatible = "olpc,xo1-battery" },
292         { .compatible = "olpc,xo1-dcon" },
293         { .compatible = "olpc,xo1-rtc" },
294         {},
295 };
296 
297 static int __init olpc_create_platform_devices(void)
298 {
299         if (machine_is_olpc())
300                 return of_platform_bus_probe(NULL, of_ids, NULL);
301         else
302                 return 0;
303 }
304 device_initcall(olpc_create_platform_devices);
305 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us