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 2000-2003 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <sys/systeminfo.h>
34 #include <sys/utsname.h>
35 #include <sys/openpromio.h>
36 #include <libdevinfo.h>
37 
38 #include "pdevinfo.h"
39 #include "pdevinfo_sun4u.h"
40 #include "display.h"
41 #include "display_sun4u.h"
42 #include "libprtdiag.h"
43 
44 /*
45  * This file contains the functions that are to be called when
46  * a platform wants to use libdevinfo for it's device information
47  * instead of OBP. This will allow prtdiag to support hot-plug
48  * events on platforms whose OBP doesn't get updated to reflect
49  * the hot-plug changes to the system.
50  */
51 
52 int	do_devinfo(int syserrlog, char *pgname, int log_flag,
53 		    int prt_flag);
54 static void 	dump_di_node(Prom_node *pnode, di_node_t di_node);
55 static Prom_node *walk_di_tree(Sys_tree *tree, Prom_node *root,
56 		    di_node_t di_node);
57 static int match_compatible_name(char *, int, char *);
58 
59 /*
60  * Global variables
61  */
62 di_prom_handle_t	ph;	/* Handle for using di_prom interface */
63 extern  char		*progname;
64 
65 
66 
67 /*
68  * Used instead of the walk() function when a platform wants to
69  * walk libdevinfo's device tree instead of walking OBP's
70  * device tree.
71  */
72 static Prom_node*
walk_di_tree(Sys_tree * tree,Prom_node * root,di_node_t di_node)73 walk_di_tree(Sys_tree *tree, Prom_node *root, di_node_t di_node)
74 {
75 	di_node_t	curnode;
76 	Prom_node	*pnode;
77 	char		*name, *type, *model, *compatible_array;
78 	int		board_node = 0;
79 	int		*int_val;
80 	int		portid;
81 	int		is_schizo = 0, n_names;
82 
83 	/* allocate a node for this level */
84 	if ((pnode = (Prom_node *) malloc(sizeof (struct prom_node))) ==
85 	    NULL) {
86 		perror("malloc");
87 		exit(2);
88 	}
89 
90 	/* assign parent Prom_node */
91 	pnode->parent = root;
92 	pnode->sibling = NULL;
93 	pnode->child = NULL;
94 
95 	/* read properties for this node */
96 	dump_di_node(pnode, di_node);
97 
98 	name = get_node_name(pnode);
99 	type = get_node_type(pnode);
100 	if (type == NULL)
101 		type = "";
102 	model = (char *)get_prop_val(find_prop(pnode, "model"));
103 	if (model == NULL)
104 		model = "";
105 
106 	/*
107 	 * For identifying Schizo nodes we need to check if the
108 	 * compatible property contains the string 'pci108e,8001'.
109 	 * This property contains an array of strings so we need
110 	 * search all strings.
111 	 */
112 	if ((n_names = di_compatible_names(di_node, &compatible_array)) > 0) {
113 		if (match_compatible_name(compatible_array, n_names,
114 		    "pci108e,8001"))
115 			is_schizo = 1;
116 	}
117 
118 	if (int_val = (int *)get_prop_val(find_prop(pnode, "portid")))
119 		portid = *int_val;
120 	else if ((strcmp(type, "cpu") == 0) &&
121 	    (int_val = (int *)get_prop_val(find_prop(pnode->parent, "portid"))))
122 		portid = *int_val;
123 	else
124 		portid = -1;
125 
126 #ifdef DEBUG
127 	if (name != NULL)
128 		printf("name=%s\n", name);
129 	if (type != NULL)
130 		printf("type=%s\n", type);
131 	if (model != NULL)
132 		printf("model=%s\n", model);
133 	printf("portid=%d\n", portid);
134 #endif
135 
136 	if (name != NULL) {
137 		if (has_board_num(pnode)) {
138 			add_node(tree, pnode);
139 			board_node = 1;
140 			D_PRINTF("\n---\nnodename = %s [ %s ] \n",
141 			    di_node_name(di_node), di_devfs_path(di_node));
142 			D_PRINTF("ADDED BOARD name=%s type=%s model=%s "
143 			    "portid =%d\n", name, type, model, portid);
144 		} else if ((strcmp(name, FFB_NAME) == 0) ||
145 		    (strcmp(type, "cpu") == 0) ||
146 
147 		    ((strcmp(type, "memory-controller") == 0) &&
148 		    (strcmp(name, "ac") != 0)) ||
149 
150 		    ((strcmp(name, "pci") == 0) &&
151 		    (strcmp(model, "SUNW,psycho") == 0)) ||
152 
153 		    ((strcmp(name, "pci") == 0) &&
154 		    (strcmp(model, "SUNW,sabre") == 0)) ||
155 
156 		    ((strcmp(name, "pci") == 0) && (is_schizo)) ||
157 
158 		    (strcmp(name, "counter-timer") == 0) ||
159 		    (strcmp(name, "sbus") == 0)) {
160 			add_node(tree, pnode);
161 			board_node = 1;
162 			D_PRINTF("\n---\nnodename = %s [ %s ] \n",
163 			    di_node_name(di_node), di_devfs_path(di_node));
164 			D_PRINTF("ADDED BOARD name=%s type=%s model=%s\n",
165 			    name, type, model);
166 		}
167 	} else {
168 		D_PRINTF("node not added: type=%s portid =%d\n", type, portid);
169 	}
170 
171 	if (curnode = di_child_node(di_node)) {
172 		pnode->child = walk_di_tree(tree, pnode, curnode);
173 	}
174 
175 	if (curnode = di_sibling_node(di_node)) {
176 		if (board_node) {
177 			return (walk_di_tree(tree, root, curnode));
178 		} else {
179 			pnode->sibling = walk_di_tree(tree, root, curnode);
180 		}
181 	}
182 
183 	/*
184 	 * This check is needed in case the "board node" occurs at the
185 	 * end of the sibling chain as opposed to the middle or front.
186 	 */
187 	if (board_node)
188 	    return (NULL);
189 
190 	return (pnode);
191 }
192 
193 /*
194  * Dump all the devinfo properties and then the obp properties for
195  * the specified devinfo node into the Prom_node structure.
196  */
197 static void
dump_di_node(Prom_node * pnode,di_node_t di_node)198 dump_di_node(Prom_node *pnode, di_node_t di_node)
199 {
200 	Prop *prop = NULL;	/* tail of properties list */
201 
202 	Prop 		*temp;	/* newly allocated property */
203 	di_prop_t	di_prop;
204 	di_prom_prop_t	p_prop;
205 	int		retval = 0;
206 	int		i;
207 
208 	/* clear out pointers in pnode */
209 	pnode->props = NULL;
210 
211 	D_PRINTF("\n\n ------- Dumping devinfo properties for node ------\n");
212 
213 	/*
214 	 * get all the devinfo properties first
215 	 */
216 	for (di_prop = di_prop_next(di_node, DI_PROP_NIL);
217 	    di_prop != DI_PROP_NIL;
218 	    di_prop = di_prop_next(di_node, di_prop)) {
219 
220 		char		*di_name;
221 		void		*di_data;
222 		int		di_ptype;
223 
224 		di_name = di_prop_name(di_prop);
225 		if (di_name == (char *)NULL)
226 			continue;
227 
228 		di_ptype = di_prop_type(di_prop);
229 		D_PRINTF("DEVINFO Properties  %s: ", di_name);
230 
231 		switch (di_ptype) {
232 			int	*int_val;
233 			char	*char_val;
234 		case DI_PROP_TYPE_INT:
235 			retval = di_prop_lookup_ints(DDI_DEV_T_ANY,
236 				di_node, di_name, (int **)&di_data);
237 			if (retval > 0) {
238 				int_val = (int *)di_data;
239 				D_PRINTF("0x%x\n", *int_val);
240 			}
241 			break;
242 		case DI_PROP_TYPE_STRING:
243 			retval = di_prop_lookup_strings(DDI_DEV_T_ANY,
244 				di_node, di_name, (char **)&di_data);
245 			if (retval > 0) {
246 				char_val = (char *)di_data;
247 				D_PRINTF("%s\n", char_val);
248 			}
249 			break;
250 		case DI_PROP_TYPE_BYTE:
251 			retval = di_prop_lookup_bytes(DDI_DEV_T_ANY,
252 				di_node, di_name, (uchar_t **)&di_data);
253 			if (retval > 0) {
254 				char_val = (char *)di_data;
255 				D_PRINTF("%s\n", char_val);
256 			}
257 			break;
258 		case DI_PROP_TYPE_UNKNOWN:
259 			retval = di_prop_lookup_bytes(DDI_DEV_T_ANY,
260 				di_node, di_name, (uchar_t **)&di_data);
261 			if (retval > 0) {
262 				char_val = (char *)di_data;
263 				D_PRINTF("%s\n", char_val);
264 			}
265 			break;
266 		case DI_PROP_TYPE_BOOLEAN:
267 			di_data = NULL;
268 			retval = 1;
269 			break;
270 		default:
271 			D_PRINTF(" Skipping property\n");
272 			retval = -1;
273 		}
274 
275 		if (retval <= 0)
276 			continue;
277 
278 		/* allocate space for the property */
279 		if ((temp = (Prop *) malloc(sizeof (Prop))) == NULL) {
280 			perror("malloc");
281 			exit(1);
282 		}
283 
284 		/*
285 		 * Given that we're using libdevinfo rather than OBP,
286 		 * the chances are that future accesses to di_name and
287 		 * di_data will be via temp->name.val_ptr and
288 		 * temp->value.val_ptr respectively. However, this may
289 		 * not be the case, so we have to suitably fill in
290 		 * temp->name.opp and temp->value.opp.
291 		 *
292 		 * di_name is char * and non-NULL if we've made it to
293 		 * here, so we can simply point
294 		 * temp->name.opp.oprom_array to temp->name.val_ptr.
295 		 *
296 		 * di_data could be NULL, char * or int * at this point.
297 		 * If it's non-NULL, a 1st char of '\0' indicates int *.
298 		 * We thus set temp->value.opp.oprom_node[] (although
299 		 * interest in any element other than 0 is rare, all
300 		 * elements must be set to ensure compatibility with
301 		 * OBP), and holds_array is set to 0.
302 		 *
303 		 * If di_data is NULL, or the 1st char is not '\0', we set
304 		 * temp->value.opp.oprom_array. If di_ptype is
305 		 * DI_PROP_TYPE_BOOLEAN, holds_array is set to 0, else it
306 		 * is set to 1.
307 		 */
308 		temp->name.val_ptr = (void *)di_name;
309 		temp->name.opp.oprom_array = temp->name.val_ptr;
310 		temp->name.opp.holds_array = 1;
311 
312 		temp->value.val_ptr = (void *)di_data;
313 		if ((di_data != NULL) && (*((char *)di_data) == '\0')) {
314 		    for (i = 0; i < OPROM_NODE_SIZE; i++)
315 			temp->value.opp.oprom_node[i] = *((int *)di_data+i);
316 
317 		    temp->value.opp.holds_array = 0;
318 		} else {
319 		    temp->value.opp.oprom_array = temp->value.val_ptr;
320 		    if (di_ptype == DI_PROP_TYPE_BOOLEAN)
321 			temp->value.opp.holds_array = 0;
322 		    else
323 			temp->value.opp.holds_array = 1;
324 		}
325 
326 		temp->size = retval;
327 
328 		/* everything worked so link the property list */
329 		if (pnode->props == NULL)
330 			pnode->props = temp;
331 		else if (prop != NULL)
332 			prop->next = temp;
333 		prop = temp;
334 		prop->next = NULL;
335 	}
336 
337 	/*
338 	 * Then get all the OBP properties.
339 	 */
340 	for (p_prop = di_prom_prop_next(ph, di_node, DI_PROM_PROP_NIL);
341 	    p_prop != DI_PROM_PROP_NIL;
342 	    p_prop = di_prom_prop_next(ph, di_node, p_prop)) {
343 
344 		char		*p_name;
345 		unsigned char	*p_data;
346 
347 		p_name = di_prom_prop_name(p_prop);
348 		if (p_name == (char *)NULL)
349 			retval = -1;
350 		else
351 			retval = di_prom_prop_data(p_prop, &p_data);
352 
353 		if (retval <= 0)
354 			continue;
355 
356 		/* allocate space for the property */
357 		if ((temp = (Prop *) malloc(sizeof (Prop))) == NULL) {
358 			perror("malloc");
359 			exit(1);
360 		}
361 
362 		/*
363 		 * As above, p_name is char * and non-NULL if we've made
364 		 * it to here, so we can simply point
365 		 * temp->name.opp.oprom_array to temp->name.val_ptr.
366 		 *
367 		 * p_data could be NULL, a character or a number at this
368 		 * point. If it's non-NULL, a 1st char of '\0' indicates a
369 		 * number, so we set temp->value.opp.oprom_node[] (again
370 		 * setting every element to ensure OBP compatibility).
371 		 * These assignments create a lint error, hence the LINTED
372 		 * comment.
373 		 *
374 		 * If p_data is NULL, or the 1st char is not '\0', we set
375 		 * temp->value.opp.oprom_array.
376 		 */
377 		temp->name.val_ptr = (void *)p_name;
378 		temp->name.opp.oprom_array = temp->name.val_ptr;
379 		temp->name.opp.holds_array = 1;
380 
381 		temp->value.val_ptr = (void *)p_data;
382 		if ((p_data != NULL) && (*p_data == '\0')) {
383 		    for (i = 0; i < OPROM_NODE_SIZE; i++)
384 			/* LINTED */
385 			temp->value.opp.oprom_node[i] = *((int *)p_data+i);
386 
387 		    temp->value.opp.holds_array = 0;
388 		} else {
389 		    temp->value.opp.oprom_array = temp->value.val_ptr;
390 		    temp->value.opp.holds_array = 1;
391 		}
392 
393 		temp->size = retval;
394 
395 		/* everything worked so link the property list */
396 		if (pnode->props == NULL) {
397 			pnode->props = temp;
398 		} else if (prop != NULL) {
399 			prop->next = temp;
400 		}
401 		prop = temp;
402 		prop->next = NULL;
403 	}
404 }
405 
406 /*
407  * Used in place of do_prominfo() when a platform wants to use
408  * libdevinfo for getting the device tree instead of OBP.
409  */
410 int
do_devinfo(int syserrlog,char * pgname,int log_flag,int prt_flag)411 do_devinfo(int syserrlog, char *pgname, int log_flag, int prt_flag)
412 {
413 	Sys_tree sys_tree;		/* system information */
414 	Prom_node *root_node;		/* root node of OBP device tree */
415 	di_node_t di_root_node;		/* root of the devinfo tree */
416 	struct system_kstat_data sys_kstat; /* kstats for non-OBP data */
417 	int retval = -1;
418 
419 	/* set the global flags */
420 	progname = pgname;
421 	logging = log_flag;
422 	print_flag = prt_flag;
423 
424 	/* set the the system tree fields */
425 	sys_tree.sys_mem = NULL;
426 	sys_tree.boards = NULL;
427 	sys_tree.bd_list = NULL;
428 	sys_tree.board_cnt = 0;
429 
430 	/*
431 	 * create a snapshot of the kernel device tree
432 	 * and return a handle to it.
433 	 */
434 	if ((di_root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
435 		exit(_error("di_init() failed"));
436 	}
437 
438 	/*
439 	 * create a handle to the PROM device tree.
440 	 */
441 	if ((ph = di_prom_init()) == NULL) {
442 		exit(_error("di_prom_init() failed"));
443 	}
444 
445 	/*
446 	 * walk the devinfo tree and build up a list of all
447 	 * nodes and properties.
448 	 */
449 	root_node = walk_di_tree(&sys_tree, NULL, di_root_node);
450 
451 	/* resolve the board types now */
452 	resolve_board_types(&sys_tree);
453 
454 	read_sun4u_kstats(&sys_tree, &sys_kstat);
455 	retval = display(&sys_tree, root_node, &sys_kstat, syserrlog);
456 
457 	di_fini(di_root_node);
458 	di_prom_fini(ph);
459 	return (retval);
460 }
461 
462 /*
463  * check to see if the name shows up in the compatible array
464  */
465 static int
match_compatible_name(char * compatible_array,int n_names,char * name)466 match_compatible_name(char *compatible_array, int n_names, char *name)
467 {
468 	int 	i, ret = 0;
469 
470 	/* parse the compatible list */
471 	for (i = 0; i < n_names; i++) {
472 		if (strcmp(compatible_array, name) == 0) {
473 			ret = 1;
474 			break;
475 		}
476 		compatible_array += strlen(compatible_array) + 1;
477 	}
478 	return (ret);
479 }
480