xref: /titanic_41/usr/src/lib/fm/topo/modules/i86pc/chip/chip_label.c (revision 64d1d4ab72834b7483c7962efc738b568ca8792e)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <string.h>
31 #include <strings.h>
32 #include <libnvpair.h>
33 #include <kstat.h>
34 #include <unistd.h>
35 #include <sys/types.h>
36 #include <fm/topo_mod.h>
37 #include <sys/devfm.h>
38 #include <fm/fmd_agent.h>
39 
40 #define	BUFSZ	128
41 
42 char *
get_fmtstr(topo_mod_t * mod,nvlist_t * in)43 get_fmtstr(topo_mod_t *mod, nvlist_t *in)
44 {
45 	char *fmtstr;
46 	nvlist_t *args;
47 	int ret;
48 
49 	topo_mod_dprintf(mod, "get_fmtstr() called\n");
50 
51 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
52 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
53 		    strerror(ret));
54 		(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
55 		return (NULL);
56 	}
57 	if ((ret = nvlist_lookup_string(args, "format", &fmtstr)) != 0) {
58 		topo_mod_dprintf(mod, "Failed to lookup 'format' arg (%s)\n",
59 		    strerror(ret));
60 		(void) topo_mod_seterrno(mod, EMOD_NVL_INVAL);
61 		return (NULL);
62 	}
63 	return (fmtstr);
64 }
65 
66 int
store_prop_val(topo_mod_t * mod,char * buf,char * propname,nvlist_t ** out)67 store_prop_val(topo_mod_t *mod, char *buf, char *propname, nvlist_t **out)
68 {
69 	if (topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) != 0) {
70 		topo_mod_dprintf(mod, "Failed to allocate 'out' nvlist\n");
71 		return (topo_mod_seterrno(mod, EMOD_NOMEM));
72 	}
73 	if (nvlist_add_string(*out, TOPO_PROP_VAL_NAME, propname) != 0) {
74 		topo_mod_dprintf(mod, "Failed to set '%s'\n",
75 		    TOPO_PROP_VAL_NAME);
76 		nvlist_free(*out);
77 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
78 	}
79 	if (nvlist_add_uint32(*out, TOPO_PROP_VAL_TYPE, TOPO_TYPE_STRING)
80 	    != 0) {
81 		topo_mod_dprintf(mod, "Failed to set '%s'\n",
82 		    TOPO_PROP_VAL_TYPE);
83 		nvlist_free(*out);
84 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
85 	}
86 	if (nvlist_add_string(*out, TOPO_PROP_VAL_VAL, buf) != 0) {
87 		topo_mod_dprintf(mod, "Failed to set '%s'\n",
88 		    TOPO_PROP_VAL_VAL);
89 		nvlist_free(*out);
90 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
91 	}
92 	return (0);
93 }
94 
95 /*
96  * This is a somewhat generic property method for labelling the dimm slots on
97  * uni-socket x86/x64 platforms.  This method assumes a direct linear
98  * correlation between the dimm topo node instance number and the dimm slot
99  * label number.  It takes the following two arguments:
100  *
101  * format:	a string containing a printf-like format with a single %d token
102  *              which this method computes
103  *
104  *              i.e.: DIMM %d
105  *
106  * offset:      a numeric offset that we'll number the dimms from.  This is to
107  *              allow for the fact that some systems number the dimm slots
108  *              from zero and others start from one (like the Ultra 20)
109  */
110 /* ARGSUSED */
111 int
simple_dimm_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)112 simple_dimm_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
113     nvlist_t *in, nvlist_t **out)
114 {
115 	char *fmtstr, buf[BUFSZ];
116 	int ret;
117 	uint32_t offset;
118 	nvlist_t *args;
119 
120 	topo_mod_dprintf(mod, "simple_dimm_label() called\n");
121 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
122 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
123 		    strerror(ret));
124 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
125 	}
126 	if ((ret = nvlist_lookup_uint32(args, "offset", &offset)) != 0) {
127 		topo_mod_dprintf(mod, "Failed to lookup 'offset' arg (%s)\n",
128 		    strerror(ret));
129 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
130 	}
131 
132 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
133 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
134 		/* topo errno already set */
135 		return (-1);
136 	}
137 
138 	/* LINTED: E_SEC_PRINTF_VAR_FMT */
139 	(void) snprintf(buf, BUFSZ, fmtstr,
140 	    (topo_node_instance(node) + offset));
141 
142 	if (store_prop_val(mod, buf, "label", out) != 0) {
143 		topo_mod_dprintf(mod, "Failed to set label\n");
144 		/* topo errno already set */
145 		return (-1);
146 	}
147 
148 	return (0);
149 }
150 
151 
152 /*
153  * This is a somewhat generic property method for labelling the dimm slots on
154  * multi-socket x86/x64 platforms.  It takes the following two arguments:
155  *
156  * format:	a string containing a printf-like format with a two %d tokens
157  *              for the cpu and dimm slot label numbers, which this method
158  *              computes
159  *
160  *              i.e.: CPU %d DIMM %d
161  *
162  * offset:      a numeric offset that we'll number the dimms from.  This is to
163  *              allow for the fact that some systems number the dimm slots
164  *              from zero while others may start from one
165  *
166  * order:	"reverse" or "forward" - sets the direction of the correlation
167  *              between dimm topo node instance number and DIMM slot number
168  *
169  * dimms_per_chip:  the number of DIMM slots per chip
170  */
171 /* ARGSUSED */
172 int
simple_dimm_label_mp(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)173 simple_dimm_label_mp(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
174     nvlist_t *in, nvlist_t **out)
175 {
176 	char *fmtstr, *order, buf[BUFSZ];
177 	tnode_t *chip;
178 	int ret;
179 	uint32_t offset, dimms_per_chip;
180 	nvlist_t *args;
181 
182 	topo_mod_dprintf(mod, "simple_dimm_label_mp() called\n");
183 
184 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
185 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
186 		    strerror(ret));
187 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
188 	}
189 	if ((ret = nvlist_lookup_uint32(args, "offset", &offset)) != 0) {
190 		topo_mod_dprintf(mod, "Failed to lookup 'offset' arg (%s)\n",
191 		    strerror(ret));
192 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
193 	}
194 	if ((ret = nvlist_lookup_uint32(args, "dimms_per_chip",
195 	    &dimms_per_chip)) != 0) {
196 		topo_mod_dprintf(mod, "Failed to lookup 'dimms_per_chip' arg "
197 		    "(%s)\n", strerror(ret));
198 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
199 	}
200 	if ((ret = nvlist_lookup_string(args, "order", &order)) != 0) {
201 		topo_mod_dprintf(mod, "Failed to lookup 'order' arg (%s)\n",
202 		    strerror(ret));
203 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
204 	}
205 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
206 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
207 		topo_mod_free(mod, order, BUFSZ);
208 		/* topo errno already set */
209 		return (-1);
210 	}
211 
212 	chip = topo_node_parent(topo_node_parent(node));
213 
214 	if (strcasecmp(order, "forward") == 0)
215 		/* LINTED: E_SEC_PRINTF_VAR_FMT */
216 		(void) snprintf(buf, BUFSZ, fmtstr, topo_node_instance(chip),
217 		    (topo_node_instance(node) + offset));
218 	else if (strcasecmp(order, "reverse") == 0)
219 		/* LINTED: E_SEC_PRINTF_VAR_FMT */
220 		(void) snprintf(buf, BUFSZ, fmtstr, topo_node_instance(chip),
221 		    (((topo_node_instance(chip) + 1) * dimms_per_chip)
222 		    - (topo_node_instance(node)) - 1 + offset));
223 	else {
224 		topo_mod_dprintf(mod, "Invalid value for order arg\n");
225 		topo_mod_free(mod, order, BUFSZ);
226 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
227 	}
228 
229 	if (store_prop_val(mod, buf, "label", out) != 0) {
230 		topo_mod_dprintf(mod, "Failed to set label\n");
231 		topo_mod_free(mod, order, BUFSZ);
232 		/* topo errno already set */
233 		return (-1);
234 	}
235 
236 	return (0);
237 }
238 
239 /*
240  * This method assumes a correspondence between the dimm topo node instance
241  * number and the dimm slot label number, but unlike simple_chip_label_mp, the
242  * slot numbers aren't reused between CPU's.  This method assumes there
243  * are 4 DIMM slots per chip.  It takes the following two arguments:
244  *
245  * format:	a string containing a printf-like format with a single %d token
246  *              which this method computes
247  *
248  *              i.e.: DIMM %d
249  *
250  * offset:      a numeric offset that we'll number the dimms from.  This is to
251  *              allow for the fact that some systems number the dimm slots
252  *              from zero and others may start from one
253  *
254  * order:	"reverse" or "forward" - sets the direction of the correlation
255  *              between dimm topo node instance number and DIMM slot number
256  */
257 /* ARGSUSED */
258 int
seq_dimm_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)259 seq_dimm_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
260     nvlist_t *in, nvlist_t **out)
261 {
262 	char *fmtstr, *order, buf[BUFSZ];
263 	int ret;
264 	uint32_t offset;
265 	nvlist_t *args;
266 	tnode_t *chip;
267 
268 	topo_mod_dprintf(mod, "seq_dimm_label() called\n");
269 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
270 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
271 		    strerror(ret));
272 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
273 	}
274 	if ((ret = nvlist_lookup_uint32(args, "offset", &offset)) != 0) {
275 		topo_mod_dprintf(mod, "Failed to lookup 'offset' arg (%s)\n",
276 		    strerror(ret));
277 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
278 	}
279 	if ((ret = nvlist_lookup_string(args, "order", &order)) != 0) {
280 		topo_mod_dprintf(mod, "Failed to lookup 'order' arg (%s)\n",
281 		    strerror(ret));
282 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
283 	}
284 
285 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
286 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
287 		topo_mod_free(mod, order, BUFSZ);
288 		/* topo errno already set */
289 		return (-1);
290 	}
291 
292 	chip = topo_node_parent(topo_node_parent(node));
293 
294 	if (strcasecmp(order, "forward") == 0)
295 		/* LINTED: E_SEC_PRINTF_VAR_FMT */
296 		(void) snprintf(buf, BUFSZ, fmtstr, ((topo_node_instance(node))
297 		    + (topo_node_instance(chip) * 4) + offset));
298 	else if (strcasecmp(order, "reverse") == 0)
299 		/* LINTED: E_SEC_PRINTF_VAR_FMT */
300 		(void) snprintf(buf, BUFSZ, fmtstr,
301 		    (((topo_node_instance(chip) + 1) * 4)
302 		    - (topo_node_instance(node)) - 1 + offset));
303 	else {
304 		topo_mod_dprintf(mod, "Invalid value for order arg\n");
305 		topo_mod_free(mod, order, BUFSZ);
306 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
307 	}
308 
309 	if (store_prop_val(mod, buf, "label", out) != 0) {
310 		topo_mod_dprintf(mod, "Failed to set label\n");
311 		topo_mod_free(mod, order, BUFSZ);
312 		/* topo errno already set */
313 		return (-1);
314 	}
315 
316 	return (0);
317 }
318 
319 
320 /*
321  * This is a somewhat generic property method for labelling the CPU sockets on
322  * x86/x64 platforms.  This method assumes a correspondence between
323  * the chip topo node instance number and the CPU socket label number.  It takes
324  * the following two arguments:
325  *
326  * format:	a string containing a printf-like format with a single %d token
327  *              which this method computes
328  *
329  *              i.e.: CPU %d
330  *
331  * offset:      a numeric offset that we'll number the CPU's from.  This is to
332  *              allow for the fact that some systems number the CPU sockets
333  *              from zero and others start from one (like the X4X00-M2 systems)
334  */
335 /* ARGSUSED */
336 int
simple_chip_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)337 simple_chip_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
338     nvlist_t *in, nvlist_t **out)
339 {
340 	char *fmtstr, buf[BUFSZ];
341 	int ret;
342 	uint32_t offset;
343 	nvlist_t *args;
344 
345 	topo_mod_dprintf(mod, "simple_chip_label() called\n");
346 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
347 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
348 		    strerror(ret));
349 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
350 	}
351 	if ((ret = nvlist_lookup_uint32(args, "offset", &offset)) != 0) {
352 		topo_mod_dprintf(mod, "Failed to lookup 'offset' arg (%s)\n",
353 		    strerror(ret));
354 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
355 	}
356 
357 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
358 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
359 		/* topo errno already set */
360 		return (-1);
361 	}
362 
363 	/* LINTED: E_SEC_PRINTF_VAR_FMT */
364 	(void) snprintf(buf, BUFSZ, fmtstr,
365 	    (topo_node_instance(node) + offset));
366 
367 	if (store_prop_val(mod, buf, "label", out) != 0) {
368 		topo_mod_dprintf(mod, "Failed to set label\n");
369 		/* topo errno already set */
370 		return (-1);
371 	}
372 
373 	return (0);
374 }
375 
376 
377 /*
378  * This is a somewhat generic property method for labelling the CPU sockets on
379  * x86/x64 platforms.  This method assumes a correspondence between
380  * the chip topo node instance number and the CPU socket label number.  It takes
381  * the following argument:
382  *
383  * format:	a string containing a printf-like format with a single %d token
384  *              which this method computes
385  *
386  *              i.e.: CPU %d
387  *
388  * offset:      a numeric offset that we'll number the CPU's from.  This is to
389  *              allow for the fact that some systems number the CPU sockets
390  *              from zero and others start from one (like the X8450 systems)
391  */
392 /* ARGSUSED */
393 int
fsb2_chip_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)394 fsb2_chip_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
395     nvlist_t *in, nvlist_t **out)
396 {
397 	char *fmtstr, buf[BUFSZ];
398 	int ret;
399 	uint32_t offset;
400 	nvlist_t *args;
401 
402 	topo_mod_dprintf(mod, "fsb2_chip_label() called\n");
403 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
404 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
405 		    strerror(ret));
406 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
407 	}
408 	if ((ret = nvlist_lookup_uint32(args, "offset", &offset)) != 0) {
409 		topo_mod_dprintf(mod, "Failed to lookup 'offset' arg (%s)\n",
410 		    strerror(ret));
411 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
412 	}
413 
414 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
415 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
416 		/* topo errno already set */
417 		return (-1);
418 	}
419 
420 	/* LINTED: E_SEC_PRINTF_VAR_FMT */
421 	(void) snprintf(buf, BUFSZ, fmtstr,
422 	    ((topo_node_instance(node) / 2) + offset));
423 
424 	if (store_prop_val(mod, buf, "label", out) != 0) {
425 		topo_mod_dprintf(mod, "Failed to set label\n");
426 		/* topo errno already set */
427 		return (-1);
428 	}
429 
430 	return (0);
431 }
432 
433 
434 /*
435  * This is a custom property method for generating the CPU slot label for the
436  * Galaxy 4E/4F platforms.
437  *
438  * format:	a string containing a printf-like format with a single %c token
439  *              which this method computes
440  *
441  *              i.e.: CPU %c
442  */
443 /* ARGSUSED */
444 int
g4_chip_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)445 g4_chip_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
446     nvlist_t *in, nvlist_t **out)
447 {
448 	char *fmtstr, buf[BUFSZ], slot_id;
449 	int err, htid, mapidx;
450 	uint32_t num_nodes;
451 	/*
452 	 * G4 HT node ID to FRU label translation.  The g4map array
453 	 * is indexed by (number of coherent nodes) / 2 - 1.
454 	 * The value for a given number of nodes is a char array
455 	 * indexed by node ID.
456 	 */
457 	const char *g4map[] = {
458 	    "AB",	/* 2 nodes */
459 	    "ADEH",	/* 4 nodes */
460 	    "ABDEFH",	/* 6 nodes */
461 	    "ACBDEFGH"	/* 8 nodes */
462 	};
463 
464 	topo_mod_dprintf(mod, "g4_chip_label() called\n");
465 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
466 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
467 		/* topo errno already set */
468 		return (-1);
469 	}
470 	/*
471 	 * The chip-properties property will not exist if this platform has
472 	 * AMD family 0x10 modules.  In that case we don't want to treat it as a
473 	 * fatal error as that will cause calls like topo_prop_getprops to fail
474 	 * to return any properties on this node.  Therefore, if the topo errno
475 	 * is set to ETOPO_PROP_NOENT, then we'll just set an empty label
476 	 * and return 0.  If the topo errno is set to anything else we'll
477 	 * return -1.
478 	 */
479 	if (topo_prop_get_uint32(node, "chip-properties", "CoherentNodes",
480 	    &num_nodes, &err) != 0) {
481 		if (err == ETOPO_PROP_NOENT) {
482 			if (store_prop_val(mod, "", "label", out) != 0) {
483 				topo_mod_dprintf(mod, "Failed to set label\n");
484 				/* topo errno already set */
485 				return (-1);
486 			}
487 			return (0);
488 		} else {
489 			topo_mod_dprintf(mod, "Failed to lookup 'CoherentNodes'"
490 			    "property\n");
491 			return (topo_mod_seterrno(mod, err));
492 		}
493 	}
494 
495 	mapidx = num_nodes / 2 - 1;
496 	htid = topo_node_instance(node);
497 
498 	/* HT nodes must number 0 .. num_nodes - 1 */
499 	if (htid >= num_nodes) {
500 		topo_mod_dprintf(mod, "chip node instance range check failed:"
501 		    "num_nodes=%d, instance=%d\n", num_nodes, htid);
502 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
503 	}
504 
505 	switch (num_nodes) {
506 		case (2):
507 		case (4):
508 		case (6):
509 		case (8):
510 			/* htid is already range-checked */
511 			mapidx = num_nodes / 2 - 1;
512 			slot_id = g4map[mapidx][htid];
513 			break;
514 		default:
515 			topo_mod_dprintf(mod, "Invalid number of CoherentNodes:"
516 			    " %d\n", num_nodes);
517 			return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
518 	}
519 
520 	/* LINTED: E_SEC_PRINTF_VAR_FMT */
521 	(void) snprintf(buf, BUFSZ, fmtstr, slot_id);
522 
523 	if (store_prop_val(mod, buf, "label", out) != 0) {
524 		topo_mod_dprintf(mod, "Failed to set label\n");
525 		/* topo errno already set */
526 		return (-1);
527 	}
528 
529 	return (0);
530 }
531 
532 /*
533  * Utility function used by a4fplus_chip_label to determine the number of chips
534  * (as opposed to processors) that are installed in the system by counting
535  * the unique chipids.
536  */
537 static int
get_num_chips(topo_mod_t * mod)538 get_num_chips(topo_mod_t *mod)
539 {
540 	fmd_agent_hdl_t *hdl;
541 	nvlist_t **cpus;
542 	uint_t ncpu;
543 	int i, nchip = 0;
544 	int32_t chipid;
545 	uint64_t bitmap = 0;
546 
547 	if ((hdl = fmd_agent_open(FMD_AGENT_VERSION)) == NULL)
548 		return (-1);
549 	if (fmd_agent_physcpu_info(hdl, &cpus, &ncpu) == -1) {
550 		topo_mod_dprintf(mod, "get physcpu info failed:%s\n",
551 		    fmd_agent_errmsg(hdl));
552 		fmd_agent_close(hdl);
553 		return (-1);
554 	}
555 	fmd_agent_close(hdl);
556 
557 	for (i = 0; i < ncpu; i++) {
558 		if (nvlist_lookup_int32(cpus[i], FM_PHYSCPU_INFO_CHIP_ID,
559 		    &chipid) != 0 || chipid >= 64) {
560 			topo_mod_dprintf(mod, "lookup chipid failed\n");
561 			nchip = -1;
562 			break;
563 		}
564 		if ((bitmap & (1 << chipid)) != 0) {
565 			bitmap |= (1 << chipid);
566 			nchip++;
567 		}
568 	}
569 
570 	for (i = 0; i < ncpu; i++)
571 		nvlist_free(cpus[i]);
572 	umem_free(cpus, sizeof (nvlist_t *) * ncpu);
573 
574 	return (nchip);
575 }
576 
577 /*
578  * This is a custom property method for generating the CPU slot label for the
579  * Andromeda Fplus platforms.
580  *
581  * format:	a string containing a printf-like format with a single %d token
582  *              which this method computes
583  *
584  *              i.e.: CPU %d
585  */
586 /* ARGSUSED */
587 int
a4fplus_chip_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)588 a4fplus_chip_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
589     nvlist_t *in, nvlist_t **out)
590 {
591 	char *fmtstr, buf[BUFSZ];
592 	int num_nodes;
593 
594 	topo_mod_dprintf(mod, "a4fplus_chip_label() called\n");
595 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
596 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
597 		/* topo errno already set */
598 		return (-1);
599 	}
600 
601 	/*
602 	 * Normally we'd figure out the total number of chip nodes by looking
603 	 * at the CoherentNodes property.  However, due to the lack of a memory
604 	 * controller driver for family 0x10, this property wont exist on the
605 	 * chip nodes on A4Fplus.
606 	 */
607 	if ((num_nodes = get_num_chips(mod)) < 0) {
608 		topo_mod_dprintf(mod, "Failed to determine number of chip "
609 		    "nodes\n");
610 		return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
611 	}
612 	switch (num_nodes) {
613 		case (2):
614 			/* LINTED: E_SEC_PRINTF_VAR_FMT */
615 			(void) snprintf(buf, BUFSZ, fmtstr,
616 			    topo_node_instance(node) + 2);
617 			break;
618 		case (4):
619 			/* LINTED: E_SEC_PRINTF_VAR_FMT */
620 			(void) snprintf(buf, BUFSZ, fmtstr,
621 			    topo_node_instance(node));
622 			break;
623 		default:
624 			topo_mod_dprintf(mod, "Invalid number of chip nodes:"
625 			    " %d\n", num_nodes);
626 			return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
627 	}
628 
629 
630 	if (store_prop_val(mod, buf, "label", out) != 0) {
631 		topo_mod_dprintf(mod, "Failed to set label\n");
632 		/* topo errno already set */
633 		return (-1);
634 	}
635 
636 	return (0);
637 }
638 
639 /*
640  * This is a somewhat generic property method for labelling the chip-select
641  * nodes on multi-socket AMD family 0x10 platforms.  This is necessary because
642  * these platforms are not supported by the current AMD memory controller driver
643  * and therefore we're not able to discover the memory topology on AMD family
644  * 0x10 systems.  As a result, instead of enumerating the installed dimms and
645  * their ranks, the chip enumerator generically enumerates all of the possible
646  * chip-selects beneath each dram channel.
647  *
648  * When we diagnose a dimm fault, the FRU fmri will be for the chip-select node,
649  * so we need to attach FRU labels to the chip-select nodes.
650  *
651  * format:	a string containing a printf-like format with a two %d tokens
652  *              for the cpu and dimm slot label numbers, which this method
653  *              computes
654  *
655  *              i.e.: CPU %d DIMM %d
656  *
657  * offset:      a numeric offset that we'll number the dimms from.  This is to
658  *              allow for the fact that some systems may number the dimm slots
659  *              from zero while others may start from one
660  *
661  * This function computes the DIMM slot number using the following formula:
662  *
663  * 	slot = cs - (cs % 2) + channel + offset
664  */
665 /* ARGSUSED */
666 int
simple_cs_label_mp(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)667 simple_cs_label_mp(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
668     nvlist_t *in, nvlist_t **out)
669 {
670 	char *fmtstr, buf[BUFSZ];
671 	tnode_t *chip, *chan;
672 	int dimm_num, ret;
673 	uint32_t offset;
674 	nvlist_t *args;
675 
676 	topo_mod_dprintf(mod, "simple_cs_label_mp() called\n");
677 
678 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
679 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
680 		    strerror(ret));
681 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
682 	}
683 	if ((ret = nvlist_lookup_uint32(args, "offset", &offset)) != 0) {
684 		topo_mod_dprintf(mod, "Failed to lookup 'offset' arg (%s)\n",
685 		    strerror(ret));
686 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
687 	}
688 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
689 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
690 		/* topo errno already set */
691 		return (-1);
692 	}
693 
694 	chip = topo_node_parent(topo_node_parent(topo_node_parent(node)));
695 	chan = topo_node_parent(node);
696 
697 	dimm_num = topo_node_instance(node) - (topo_node_instance(node) % 2)
698 	    + topo_node_instance(chan) + offset;
699 	/* LINTED: E_SEC_PRINTF_VAR_FMT */
700 	(void) snprintf(buf, BUFSZ, fmtstr, topo_node_instance(chip),
701 	    dimm_num);
702 
703 	if (store_prop_val(mod, buf, "label", out) != 0) {
704 		topo_mod_dprintf(mod, "Failed to set label\n");
705 		/* topo errno already set */
706 		return (-1);
707 	}
708 
709 	return (0);
710 }
711 
712 /* ARGSUSED */
713 int
g4_dimm_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)714 g4_dimm_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
715     nvlist_t *in, nvlist_t **out)
716 {
717 	char *fmtstr, *chip_lbl, buf[BUFSZ];
718 	tnode_t *chip;
719 	int ret, err = 0;
720 	uint32_t offset;
721 	nvlist_t *args;
722 
723 	topo_mod_dprintf(mod, "g4_dimm_label() called\n");
724 
725 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
726 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
727 		    strerror(ret));
728 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
729 	}
730 	if ((ret = nvlist_lookup_uint32(args, "offset", &offset)) != 0) {
731 		topo_mod_dprintf(mod, "Failed to lookup 'offset' arg (%s)\n",
732 		    strerror(ret));
733 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
734 	}
735 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
736 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
737 		/* topo errno already set */
738 		return (-1);
739 	}
740 
741 	/*
742 	 * The 4600/4600M2 have a weird way of labeling the chip nodes, so
743 	 * instead of trying to recompute it, we'll simply look it up and
744 	 * prepend it to our dimm label.
745 	 */
746 	chip = topo_node_parent(topo_node_parent(node));
747 	if (topo_prop_get_string(chip, TOPO_PGROUP_PROTOCOL, "label", &chip_lbl,
748 	    &err) != 0) {
749 		topo_mod_dprintf(mod, "Failed to lookup label prop on %s=%d\n",
750 		    topo_node_name(chip), topo_node_instance(chip),
751 		    topo_strerror(err));
752 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
753 	}
754 
755 	/* LINTED: E_SEC_PRINTF_VAR_FMT */
756 	(void) snprintf(buf, BUFSZ, fmtstr, chip_lbl,
757 	    (topo_node_instance(node) + offset));
758 
759 	topo_mod_strfree(mod, chip_lbl);
760 
761 	if (store_prop_val(mod, buf, "label", out) != 0) {
762 		topo_mod_dprintf(mod, "Failed to set label\n");
763 		/* topo errno already set */
764 		return (-1);
765 	}
766 
767 	return (0);
768 }
769 
770 /*
771  * This method is used to compute the labels for DIMM slots on the Galaxy 1F and
772  * 2F platforms.  It results in following dimm node label assignments:
773  *
774  * chip/dimm instances      label
775  * -------------------      -----
776  * chip=0/dimm=0            CPU 1 DIMM A0
777  * chip=0/dimm=1            CPU 1 DIMM B0
778  * chip=0/dimm=2            CPU 1 DIMM A1
779  * chip=0/dimm=3            CPU 1 DIMM B1
780  *
781  * chip=1/dimm=0            CPU 2 DIMM A0
782  * chip=1/dimm=1            CPU 2 DIMM B0
783  * chip=1/dimm=2            CPU 2 DIMM A1
784  * chip=1/dimm=3            CPU 2 DIMM B1
785  */
786 /* ARGSUSED */
787 int
g12f_dimm_label(topo_mod_t * mod,tnode_t * node,topo_version_t vers,nvlist_t * in,nvlist_t ** out)788 g12f_dimm_label(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
789     nvlist_t *in, nvlist_t **out)
790 {
791 	char *fmtstr, buf[BUFSZ], chan;
792 	tnode_t *chip;
793 	int ret, dimm_inst, slot_num;
794 	nvlist_t *args;
795 
796 	topo_mod_dprintf(mod, "g12f_dimm_label() called\n");
797 
798 	if ((ret = nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args)) != 0) {
799 		topo_mod_dprintf(mod, "Failed to lookup 'args' list (%s)\n",
800 		    strerror(ret));
801 		return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
802 	}
803 	if ((fmtstr = get_fmtstr(mod, in)) == NULL) {
804 		topo_mod_dprintf(mod, "Failed to retrieve 'format' arg\n");
805 		/* topo errno already set */
806 		return (-1);
807 	}
808 
809 	chip = topo_node_parent(topo_node_parent(node));
810 	dimm_inst = topo_node_instance(node);
811 	chan = dimm_inst == 0 || dimm_inst == 2 ? 'A': 'B';
812 	slot_num = (dimm_inst <= 1 ? 0 : 1);
813 
814 	/* LINTED: E_SEC_PRINTF_VAR_FMT */
815 	(void) snprintf(buf, BUFSZ, fmtstr, topo_node_instance(chip) + 1, chan,
816 	    slot_num);
817 
818 	if (store_prop_val(mod, buf, "label", out) != 0) {
819 		topo_mod_dprintf(mod, "Failed to set label\n");
820 		/* topo errno already set */
821 		return (-1);
822 	}
823 
824 	return (0);
825 }
826