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