xref: /freebsd/sys/dev/ofw/openfirm.c (revision 7661de35d15f582ab33e3bd6b8d909601557e436)
1 /*	$NetBSD: Locore.c,v 1.7 2000/08/20 07:04:59 tsubai Exp $	*/
2 
3 /*-
4  * Copyright (C) 1995, 1996 Wolfgang Solfrank.
5  * Copyright (C) 1995, 1996 TooLs GmbH.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by TooLs GmbH.
19  * 4. The name of TooLs GmbH may not be used to endorse or promote products
20  *    derived from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
28  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 /*-
34  * Copyright (C) 2000 Benno Rice.
35  * All rights reserved.
36  *
37  * Redistribution and use in source and binary forms, with or without
38  * modification, are permitted provided that the following conditions
39  * are met:
40  * 1. Redistributions of source code must retain the above copyright
41  *    notice, this list of conditions and the following disclaimer.
42  * 2. Redistributions in binary form must reproduce the above copyright
43  *    notice, this list of conditions and the following disclaimer in the
44  *    documentation and/or other materials provided with the distribution.
45  *
46  * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR
47  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
48  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
49  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
51  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
52  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
53  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
54  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
55  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56  */
57 
58 #include <sys/cdefs.h>
59 __FBSDID("$FreeBSD$");
60 
61 #include "opt_platform.h"
62 
63 #include <sys/param.h>
64 #include <sys/kernel.h>
65 #include <sys/malloc.h>
66 #include <sys/systm.h>
67 #include <sys/endian.h>
68 
69 #include <machine/stdarg.h>
70 
71 #include <dev/ofw/ofwvar.h>
72 #include <dev/ofw/openfirm.h>
73 
74 #include "ofw_if.h"
75 
76 static void OF_putchar(int c, void *arg);
77 
78 MALLOC_DEFINE(M_OFWPROP, "openfirm", "Open Firmware properties");
79 
80 static ihandle_t stdout;
81 
82 static ofw_def_t	*ofw_def_impl = NULL;
83 static ofw_t		ofw_obj;
84 static struct ofw_kobj	ofw_kernel_obj;
85 static struct kobj_ops	ofw_kernel_kops;
86 
87 /*
88  * OFW install routines.  Highest priority wins, equal priority also
89  * overrides allowing last-set to win.
90  */
91 SET_DECLARE(ofw_set, ofw_def_t);
92 
93 boolean_t
94 OF_install(char *name, int prio)
95 {
96 	ofw_def_t *ofwp, **ofwpp;
97 	static int curr_prio = 0;
98 
99 	/*
100 	 * Try and locate the OFW kobj corresponding to the name.
101 	 */
102 	SET_FOREACH(ofwpp, ofw_set) {
103 		ofwp = *ofwpp;
104 
105 		if (ofwp->name &&
106 		    !strcmp(ofwp->name, name) &&
107 		    prio >= curr_prio) {
108 			curr_prio = prio;
109 			ofw_def_impl = ofwp;
110 			return (TRUE);
111 		}
112 	}
113 
114 	return (FALSE);
115 }
116 
117 /* Initializer */
118 int
119 OF_init(void *cookie)
120 {
121 	phandle_t chosen;
122 	int rv;
123 
124 	if (ofw_def_impl == NULL)
125 		return (-1);
126 
127 	ofw_obj = &ofw_kernel_obj;
128 	/*
129 	 * Take care of compiling the selected class, and
130 	 * then statically initialize the OFW object.
131 	 */
132 	kobj_class_compile_static(ofw_def_impl, &ofw_kernel_kops);
133 	kobj_init_static((kobj_t)ofw_obj, ofw_def_impl);
134 
135 	rv = OFW_INIT(ofw_obj, cookie);
136 
137 	if ((chosen = OF_finddevice("/chosen")) != -1)
138 		if (OF_getencprop(chosen, "stdout", &stdout,
139 		    sizeof(stdout)) == -1)
140 			stdout = -1;
141 
142 	return (rv);
143 }
144 
145 static void
146 OF_putchar(int c, void *arg __unused)
147 {
148 	char cbuf;
149 
150 	if (c == '\n') {
151 		cbuf = '\r';
152 		OF_write(stdout, &cbuf, 1);
153 	}
154 
155 	cbuf = c;
156 	OF_write(stdout, &cbuf, 1);
157 }
158 
159 void
160 OF_printf(const char *fmt, ...)
161 {
162 	va_list	va;
163 
164 	va_start(va, fmt);
165 	(void)kvprintf(fmt, OF_putchar, NULL, 10, va);
166 	va_end(va);
167 }
168 
169 /*
170  * Generic functions
171  */
172 
173 /* Test to see if a service exists. */
174 int
175 OF_test(const char *name)
176 {
177 
178 	if (ofw_def_impl == NULL)
179 		return (-1);
180 
181 	return (OFW_TEST(ofw_obj, name));
182 }
183 
184 int
185 OF_interpret(const char *cmd, int nreturns, ...)
186 {
187 	va_list ap;
188 	cell_t slots[16];
189 	int i = 0;
190 	int status;
191 
192 	if (ofw_def_impl == NULL)
193 		return (-1);
194 
195 	status = OFW_INTERPRET(ofw_obj, cmd, nreturns, slots);
196 	if (status == -1)
197 		return (status);
198 
199 	va_start(ap, nreturns);
200 	while (i < nreturns)
201 		*va_arg(ap, cell_t *) = slots[i++];
202 	va_end(ap);
203 
204 	return (status);
205 }
206 
207 /*
208  * Device tree functions
209  */
210 
211 /* Return the next sibling of this node or 0. */
212 phandle_t
213 OF_peer(phandle_t node)
214 {
215 
216 	if (ofw_def_impl == NULL)
217 		return (0);
218 
219 	return (OFW_PEER(ofw_obj, node));
220 }
221 
222 /* Return the first child of this node or 0. */
223 phandle_t
224 OF_child(phandle_t node)
225 {
226 
227 	if (ofw_def_impl == NULL)
228 		return (0);
229 
230 	return (OFW_CHILD(ofw_obj, node));
231 }
232 
233 /* Return the parent of this node or 0. */
234 phandle_t
235 OF_parent(phandle_t node)
236 {
237 
238 	if (ofw_def_impl == NULL)
239 		return (0);
240 
241 	return (OFW_PARENT(ofw_obj, node));
242 }
243 
244 /* Return the package handle that corresponds to an instance handle. */
245 phandle_t
246 OF_instance_to_package(ihandle_t instance)
247 {
248 
249 	if (ofw_def_impl == NULL)
250 		return (-1);
251 
252 	return (OFW_INSTANCE_TO_PACKAGE(ofw_obj, instance));
253 }
254 
255 /* Get the length of a property of a package. */
256 ssize_t
257 OF_getproplen(phandle_t package, const char *propname)
258 {
259 
260 	if (ofw_def_impl == NULL)
261 		return (-1);
262 
263 	return (OFW_GETPROPLEN(ofw_obj, package, propname));
264 }
265 
266 /* Check existence of a property of a package. */
267 int
268 OF_hasprop(phandle_t package, const char *propname)
269 {
270 
271 	return (OF_getproplen(package, propname) >= 0 ? 1 : 0);
272 }
273 
274 /* Get the value of a property of a package. */
275 ssize_t
276 OF_getprop(phandle_t package, const char *propname, void *buf, size_t buflen)
277 {
278 
279 	if (ofw_def_impl == NULL)
280 		return (-1);
281 
282 	return (OFW_GETPROP(ofw_obj, package, propname, buf, buflen));
283 }
284 
285 ssize_t
286 OF_getencprop(phandle_t node, const char *propname, pcell_t *buf, size_t len)
287 {
288 	ssize_t retval;
289 	int i;
290 
291 	KASSERT(len % 4 == 0, ("Need a multiple of 4 bytes"));
292 
293 	retval = OF_getprop(node, propname, buf, len);
294 	for (i = 0; i < len/4; i++)
295 		buf[i] = be32toh(buf[i]);
296 
297 	return (retval);
298 }
299 
300 /*
301  * Recursively search the node and its parent for the given property, working
302  * downward from the node to the device tree root.  Returns the value of the
303  * first match.
304  */
305 ssize_t
306 OF_searchprop(phandle_t node, const char *propname, void *buf, size_t len)
307 {
308 	ssize_t rv;
309 
310 	for (; node != 0; node = OF_parent(node))
311 		if ((rv = OF_getprop(node, propname, buf, len)) != -1)
312 			return (rv);
313 	return (-1);
314 }
315 
316 ssize_t
317 OF_searchencprop(phandle_t node, const char *propname, void *buf, size_t len)
318 {
319 	ssize_t rv;
320 
321 	for (; node != 0; node = OF_parent(node))
322 		if ((rv = OF_getencprop(node, propname, buf, len)) != -1)
323 			return (rv);
324 	return (-1);
325 }
326 
327 /*
328  * Store the value of a property of a package into newly allocated memory
329  * (using the M_OFWPROP malloc pool and M_WAITOK).  elsz is the size of a
330  * single element, the number of elements is return in number.
331  */
332 ssize_t
333 OF_getprop_alloc(phandle_t package, const char *propname, int elsz, void **buf)
334 {
335 	int len;
336 
337 	*buf = NULL;
338 	if ((len = OF_getproplen(package, propname)) == -1 ||
339 	    len % elsz != 0)
340 		return (-1);
341 
342 	*buf = malloc(len, M_OFWPROP, M_WAITOK);
343 	if (OF_getprop(package, propname, *buf, len) == -1) {
344 		free(*buf, M_OFWPROP);
345 		*buf = NULL;
346 		return (-1);
347 	}
348 	return (len / elsz);
349 }
350 
351 ssize_t
352 OF_getencprop_alloc(phandle_t package, const char *name, int elsz, void **buf)
353 {
354 	ssize_t retval;
355 	pcell_t *cell;
356 	int i;
357 
358 	retval = OF_getprop_alloc(package, name, elsz, buf);
359 	if (retval == -1 || retval*elsz % 4 != 0)
360 		return (-1);
361 
362 	cell = *buf;
363 	for (i = 0; i < retval*elsz/4; i++)
364 		cell[i] = be32toh(cell[i]);
365 
366 	return (retval);
367 }
368 
369 /* Get the next property of a package. */
370 int
371 OF_nextprop(phandle_t package, const char *previous, char *buf, size_t size)
372 {
373 
374 	if (ofw_def_impl == NULL)
375 		return (-1);
376 
377 	return (OFW_NEXTPROP(ofw_obj, package, previous, buf, size));
378 }
379 
380 /* Set the value of a property of a package. */
381 int
382 OF_setprop(phandle_t package, const char *propname, const void *buf, size_t len)
383 {
384 
385 	if (ofw_def_impl == NULL)
386 		return (-1);
387 
388 	return (OFW_SETPROP(ofw_obj, package, propname, buf,len));
389 }
390 
391 /* Convert a device specifier to a fully qualified pathname. */
392 ssize_t
393 OF_canon(const char *device, char *buf, size_t len)
394 {
395 
396 	if (ofw_def_impl == NULL)
397 		return (-1);
398 
399 	return (OFW_CANON(ofw_obj, device, buf, len));
400 }
401 
402 /* Return a package handle for the specified device. */
403 phandle_t
404 OF_finddevice(const char *device)
405 {
406 
407 	if (ofw_def_impl == NULL)
408 		return (-1);
409 
410 	return (OFW_FINDDEVICE(ofw_obj, device));
411 }
412 
413 /* Return the fully qualified pathname corresponding to an instance. */
414 ssize_t
415 OF_instance_to_path(ihandle_t instance, char *buf, size_t len)
416 {
417 
418 	if (ofw_def_impl == NULL)
419 		return (-1);
420 
421 	return (OFW_INSTANCE_TO_PATH(ofw_obj, instance, buf, len));
422 }
423 
424 /* Return the fully qualified pathname corresponding to a package. */
425 ssize_t
426 OF_package_to_path(phandle_t package, char *buf, size_t len)
427 {
428 
429 	if (ofw_def_impl == NULL)
430 		return (-1);
431 
432 	return (OFW_PACKAGE_TO_PATH(ofw_obj, package, buf, len));
433 }
434 
435 /* Look up effective phandle (see FDT/PAPR spec) */
436 static phandle_t
437 OF_child_xref_phandle(phandle_t parent, phandle_t xref)
438 {
439 	phandle_t child, rxref;
440 
441 	/*
442 	 * Recursively descend from parent, looking for a node with a property
443 	 * named either "phandle", "ibm,phandle", or "linux,phandle" that
444 	 * matches the xref we are looking for.
445 	 */
446 
447 	for (child = OF_child(parent); child != 0; child = OF_peer(child)) {
448 		rxref = OF_child_xref_phandle(child, xref);
449 		if (rxref != -1)
450 			return (rxref);
451 
452 		if (OF_getencprop(child, "phandle", &rxref, sizeof(rxref)) ==
453 		    -1 && OF_getencprop(child, "ibm,phandle", &rxref,
454 		    sizeof(rxref)) == -1 && OF_getencprop(child,
455 		    "linux,phandle", &rxref, sizeof(rxref)) == -1)
456 			continue;
457 
458 		if (rxref == xref)
459 			return (child);
460 	}
461 
462 	return (-1);
463 }
464 
465 phandle_t
466 OF_xref_phandle(phandle_t xref)
467 {
468 	phandle_t node;
469 
470 	node = OF_child_xref_phandle(OF_peer(0), xref);
471 	if (node == -1)
472 		return (xref);
473 
474 	return (node);
475 }
476 
477 /*  Call the method in the scope of a given instance. */
478 int
479 OF_call_method(const char *method, ihandle_t instance, int nargs, int nreturns,
480     ...)
481 {
482 	va_list ap;
483 	cell_t args_n_results[12];
484 	int n, status;
485 
486 	if (nargs > 6 || ofw_def_impl == NULL)
487 		return (-1);
488 	va_start(ap, nreturns);
489 	for (n = 0; n < nargs; n++)
490 		args_n_results[n] = va_arg(ap, cell_t);
491 
492 	status = OFW_CALL_METHOD(ofw_obj, instance, method, nargs, nreturns,
493 	    args_n_results);
494 	if (status != 0)
495 		return (status);
496 
497 	for (; n < nargs + nreturns; n++)
498 		*va_arg(ap, cell_t *) = args_n_results[n];
499 	va_end(ap);
500 	return (0);
501 }
502 
503 /*
504  * Device I/O functions
505  */
506 
507 /* Open an instance for a device. */
508 ihandle_t
509 OF_open(const char *device)
510 {
511 
512 	if (ofw_def_impl == NULL)
513 		return (0);
514 
515 	return (OFW_OPEN(ofw_obj, device));
516 }
517 
518 /* Close an instance. */
519 void
520 OF_close(ihandle_t instance)
521 {
522 
523 	if (ofw_def_impl == NULL)
524 		return;
525 
526 	OFW_CLOSE(ofw_obj, instance);
527 }
528 
529 /* Read from an instance. */
530 ssize_t
531 OF_read(ihandle_t instance, void *addr, size_t len)
532 {
533 
534 	if (ofw_def_impl == NULL)
535 		return (-1);
536 
537 	return (OFW_READ(ofw_obj, instance, addr, len));
538 }
539 
540 /* Write to an instance. */
541 ssize_t
542 OF_write(ihandle_t instance, const void *addr, size_t len)
543 {
544 
545 	if (ofw_def_impl == NULL)
546 		return (-1);
547 
548 	return (OFW_WRITE(ofw_obj, instance, addr, len));
549 }
550 
551 /* Seek to a position. */
552 int
553 OF_seek(ihandle_t instance, uint64_t pos)
554 {
555 
556 	if (ofw_def_impl == NULL)
557 		return (-1);
558 
559 	return (OFW_SEEK(ofw_obj, instance, pos));
560 }
561 
562 /*
563  * Memory functions
564  */
565 
566 /* Claim an area of memory. */
567 void *
568 OF_claim(void *virt, size_t size, u_int align)
569 {
570 
571 	if (ofw_def_impl == NULL)
572 		return ((void *)-1);
573 
574 	return (OFW_CLAIM(ofw_obj, virt, size, align));
575 }
576 
577 /* Release an area of memory. */
578 void
579 OF_release(void *virt, size_t size)
580 {
581 
582 	if (ofw_def_impl == NULL)
583 		return;
584 
585 	OFW_RELEASE(ofw_obj, virt, size);
586 }
587 
588 /*
589  * Control transfer functions
590  */
591 
592 /* Suspend and drop back to the Open Firmware interface. */
593 void
594 OF_enter()
595 {
596 
597 	if (ofw_def_impl == NULL)
598 		return;
599 
600 	OFW_ENTER(ofw_obj);
601 }
602 
603 /* Shut down and drop back to the Open Firmware interface. */
604 void
605 OF_exit()
606 {
607 
608 	if (ofw_def_impl == NULL)
609 		panic("OF_exit: Open Firmware not available");
610 
611 	/* Should not return */
612 	OFW_EXIT(ofw_obj);
613 
614 	for (;;)			/* just in case */
615 		;
616 }
617