xref: /titanic_51/usr/src/lib/libprtdiag/inc/pdevinfo.h (revision e71ca95ca6de23d33b54cb55cefdef30bc7c969b)
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
33 extern "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))
47 typedef 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  */
66 typedef struct static_prop StaticProp;
67 struct 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
92 struct 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  */
107 typedef struct dynoppbuf dynOppbuf;
108 struct dynoppbuf {
109 	struct dynopenpromio opp;
110 	char *val_ptr;
111 };
112 
113 typedef struct prop Prop;
114 struct prop {
115 	Prop *next;
116 	dynOppbuf name;
117 	dynOppbuf value;
118 	int size;	/* size of data in bytes */
119 };
120 
121 typedef struct prom_node Prom_node;
122 struct 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 
133 typedef struct board_node Board_node;
134 struct 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 
142 typedef struct system_tree Sys_tree;
143 struct 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 
150 int do_prominfo(int, char *, int, int);
151 int is_openprom(void);
152 void promclose(void);
153 int promopen(int);
154 extern char *badarchmsg;
155 int _error(char *fmt, ...);
156 
157 /* Functions for building the user copy of the device tree. */
158 Board_node *find_board(Sys_tree *, int);
159 Board_node *insert_board(Sys_tree *, int);
160 
161 /* functions for searching for Prom nodes */
162 char *get_node_name(Prom_node *);
163 char *get_node_type(Prom_node *);
164 Prom_node *dev_find_node(Prom_node *, char *);
165 Prom_node *dev_next_node(Prom_node *, char *);
166 Prom_node *dev_find_node_by_type(Prom_node *root, char *type, char *property);
167 Prom_node *dev_next_node_by_type(Prom_node *root, char *type, char *property);
168 Prom_node *dev_find_type(Prom_node *, char *);
169 Prom_node *dev_next_type(Prom_node *, char *);
170 Prom_node *sys_find_node(Sys_tree *, int, char *);
171 Prom_node *find_failed_node(Prom_node *);
172 Prom_node *next_failed_node(Prom_node *);
173 Prom_node *dev_find_node_by_compatible(Prom_node *root, char *compat);
174 Prom_node *dev_next_node_by_compatible(Prom_node *root, char *compat);
175 int node_failed(Prom_node *);
176 int node_status(Prom_node *node, char *status);
177 void dump_node(Prom_node *);
178 int next(int);
179 int has_board_num(Prom_node *);
180 int get_board_num(Prom_node *);
181 int child(int);
182 
183 /* functions for searching for properties, extracting data from them */
184 void *get_prop_val(Prop *);
185 void getpropval(struct openpromio *);
186 Prop *find_prop(Prom_node *, char *);
187 
188 #ifdef	__cplusplus
189 }
190 #endif
191 
192 #endif	/* _PDEVINFO_H */
193