1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License").  You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22/*
23 * Copyright 1999-2003 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27#ifndef	_PDEVINFO_H
28#define	_PDEVINFO_H
29
30#pragma ident	"%Z%%M%	%I%	%E% SMI"
31
32#ifdef	__cplusplus
33extern "C" {
34#endif
35
36/* structures necessary to hold Openprom data */
37
38/*
39 * 128 is the size of the largest (currently) property name
40 * 4096 - MAXPROPSIZE - sizeof (int) is the size of the largest
41 * (currently) property value that is allowed.
42 * the sizeof (u_int) is from struct openpromio
43 */
44#define	MAXPROPSIZE	128
45#define	MAXVALSIZE	(4096 - MAXPROPSIZE - sizeof (uint_t))
46#define	BUFSIZE		(MAXPROPSIZE + MAXVALSIZE + sizeof (uint_t))
47typedef union {
48	char buf[BUFSIZE];
49	struct openpromio opp;
50	void	*val_ptr;
51} Oppbuf;
52
53/*
54 * The prop structures associated with a Prom_node were formerly statically
55 * sized - via the buf element of the Oppbuf union. This was highly memory
56 * inefficient, so dynamic sizing capabilities have been introduced.
57 *
58 * This has been achieved via the creation of dynopenpromio and dynOppbuf
59 * structs, and altering the prop structure. The prop structure's name and value
60 * elements are now typed as dynOppbuf instead of Oppbuf.
61 *
62 * For legacy purposes, static_prop has been created. It is essentially the same
63 * as the former prop structure, but the *next element now points to a
64 * static_prop structure instead of a prop structure.
65 */
66typedef struct static_prop StaticProp;
67struct static_prop {
68	StaticProp *next;
69	Oppbuf name;
70	Oppbuf value;
71	int size;	/* size of data in bytes */
72};
73
74/*
75 * dynopenpromio structs are similar to openpromio structs, but with 2 major
76 * differences. The first is that the opio_u.b element is char * instead of
77 * char [], which allows for dynamic sizing.
78 *
79 * The second regards opio_u.i, which was an int, but is now int []. In almost
80 * all cases, only opio_u.i (opio_u.i[0]) will be referenced. However, certain
81 * platforms rely on the fact that Prop structures formerly contained Oppbuf
82 * unions, the buf element of which was statically sized at 4k. In theory, this
83 * enabled those platforms to validly reference any part of the union up to 4k
84 * from the start. In reality, no element greater than opio_u.i[4] is currently
85 * referenced, hence OPROM_NODE_SIZE (named because opio_u.i is usually
86 * referenced as oprom_node) being set to 5.
87 *
88 * A minor difference is that the holds_array element has been added, which
89 * affords an easy way to determine whether opio_u contains char * or int.
90 */
91#define	OPROM_NODE_SIZE		5
92struct dynopenpromio {
93	uint_t oprom_size;
94	union {
95		char *b;
96		int i[OPROM_NODE_SIZE];
97	} opio_u;
98	uint_t holds_array;
99};
100
101/*
102 * dynOppbuf structs are a dynamic alternative to Oppbuf unions. The statically
103 * sized Oppbuf.buf element has been removed, and the opp element common to both
104 * is of type struct dynopenpromio instead of struct openpromio. This allows us
105 * to take advantage of dynopenpromio's dynamic sizing capabilities.
106 */
107typedef struct dynoppbuf dynOppbuf;
108struct dynoppbuf {
109	struct dynopenpromio opp;
110	char *val_ptr;
111};
112
113typedef struct prop Prop;
114struct prop {
115	Prop *next;
116	dynOppbuf name;
117	dynOppbuf value;
118	int size;	/* size of data in bytes */
119};
120
121typedef struct prom_node Prom_node;
122struct prom_node {
123	Prom_node *parent;	/* points to parent node */
124	Prom_node *child;	/* points to child PROM node */
125	Prom_node *sibling;	/* point to next sibling */
126	Prop *props;		/* points to list of properties */
127};
128
129/*
130 * Defines for board types.
131 */
132
133typedef struct board_node Board_node;
134struct board_node {
135	int node_id;
136	int board_num;
137	int board_type;
138	Prom_node *nodes;
139	Board_node *next;  /* link for list */
140};
141
142typedef struct system_tree Sys_tree;
143struct system_tree {
144	Prom_node *sys_mem;	/* System memory node */
145	Prom_node *boards;	/* boards node holds bif info if present */
146	Board_node *bd_list;	/* node holds list of boards */
147	int board_cnt;		/* number of boards in the system */
148};
149
150int do_prominfo(int, char *, int, int);
151int is_openprom(void);
152void promclose(void);
153int promopen(int);
154extern char *badarchmsg;
155int _error(char *fmt, ...);
156
157/* Functions for building the user copy of the device tree. */
158Board_node *find_board(Sys_tree *, int);
159Board_node *insert_board(Sys_tree *, int);
160
161/* functions for searching for Prom nodes */
162char *get_node_name(Prom_node *);
163char *get_node_type(Prom_node *);
164Prom_node *dev_find_node(Prom_node *, char *);
165Prom_node *dev_next_node(Prom_node *, char *);
166Prom_node *dev_find_node_by_type(Prom_node *root, char *type, char *property);
167Prom_node *dev_next_node_by_type(Prom_node *root, char *type, char *property);
168Prom_node *dev_find_type(Prom_node *, char *);
169Prom_node *dev_next_type(Prom_node *, char *);
170Prom_node *sys_find_node(Sys_tree *, int, char *);
171Prom_node *find_failed_node(Prom_node *);
172Prom_node *next_failed_node(Prom_node *);
173Prom_node *dev_find_node_by_compatible(Prom_node *root, char *compat);
174Prom_node *dev_next_node_by_compatible(Prom_node *root, char *compat);
175int node_failed(Prom_node *);
176int node_status(Prom_node *node, char *status);
177void dump_node(Prom_node *);
178int next(int);
179int has_board_num(Prom_node *);
180int get_board_num(Prom_node *);
181int child(int);
182
183/* functions for searching for properties, extracting data from them */
184void *get_prop_val(Prop *);
185void getpropval(struct openpromio *);
186Prop *find_prop(Prom_node *, char *);
187
188#ifdef	__cplusplus
189}
190#endif
191
192#endif	/* _PDEVINFO_H */
193