usr/src/lib/libprtdiag/inc/pdevinfo.h

   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 */