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 2006 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  *	Plugin Library for PCI Hot-Plug Controller
29  */
30 
31 #include <stddef.h>
32 #include <locale.h>
33 #include <ctype.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <fcntl.h>
38 #include <unistd.h>
39 #include <errno.h>
40 #include <locale.h>
41 #include <langinfo.h>
42 #include <time.h>
43 #include <sys/param.h>
44 #include <stdarg.h>
45 #include <libdevinfo.h>
46 #include <libdevice.h>
47 
48 #define	CFGA_PLUGIN_LIB
49 
50 #include <config_admin.h>
51 
52 #include <sys/types.h>
53 #include <sys/stat.h>
54 #include <sys/ioctl.h>
55 #include <sys/dditypes.h>
56 #include <sys/devctl.h>
57 #include <sys/modctl.h>
58 #include <sys/hotplug/hpctrl.h>
59 #include <sys/pci.h>
60 #include <libintl.h>
61 
62 #include <dirent.h>
63 #include <limits.h>
64 #include <sys/mkdev.h>
65 #include <librcm.h>
66 #include "../../../../common/pci/pci_strings.h"
67 
68 extern const struct pci_class_strings_s class_pci[];
69 extern int class_pci_items;
70 
71 /*
72  * Set the version number
73  */
74 int cfga_version = CFGA_HSL_V2;
75 
76 #ifdef	DEBUG
77 #define	PCIHP_DBG	1
78 #endif
79 
80 #if !defined(TEXT_DOMAIN)
81 #define	TEXT_DOMAIN	"SYS_TEST"
82 #endif
83 
84 /*
85  *	DEBUGING LEVEL
86  *
87  * 	External routines:  1 - 2
88  *	Internal routines:  3 - 4
89  */
90 #ifdef	PCIHP_DBG
91 int	pcihp_debug = 1;
92 #define	DBG(level, args) \
93 	{ if (pcihp_debug >= (level)) printf args; }
94 #define	DBG_F(level, args) \
95 	{ if (pcihp_debug >= (level)) fprintf args; }
96 #else
97 #define	DBG(level, args)	/* nothing */
98 #define	DBG_F(level, args)	/* nothing */
99 #endif
100 
101 #define	CMD_ACQUIRE		0
102 #define	CMD_GETSTAT		1
103 #define	CMD_LIST		2
104 #define	CMD_SLOT_CONNECT	3
105 #define	CMD_SLOT_DISCONNECT	4
106 #define	CMD_SLOT_CONFIGURE	5
107 #define	CMD_SLOT_UNCONFIGURE	6
108 #define	CMD_SLOT_INSERT		7
109 #define	CMD_SLOT_REMOVE		8
110 #define	CMD_OPEN		9
111 #define	CMD_FSTAT		10
112 #define	ERR_CMD_INVAL		11
113 #define	ERR_AP_INVAL		12
114 #define	ERR_AP_ERR		13
115 #define	ERR_OPT_INVAL		14
116 
117 static char *
118 cfga_errstrs[] = {
119 	/* n */ "acquire ",
120 	/* n */ "get-status ",
121 	/* n */ "list ",
122 	/* n */ "connect ",
123 	/* n */ "disconnect ",
124 	/* n */ "configure ",
125 	/* n */ "unconfigure ",
126 	/* n */ "insert ",
127 	/* n */ "remove ",
128 	/* n */ "open ",
129 	/* n */ "fstat ",
130 	/* y */ "invalid command ",
131 	/* y */ "invalid attachment point ",
132 	/* y */ "invalid transition ",
133 	/* y */ "invalid option ",
134 		NULL
135 };
136 
137 #define	HELP_HEADER		1
138 #define	HELP_CONFIG		2
139 #define	HELP_ENABLE_SLOT	3
140 #define	HELP_DISABLE_SLOT	4
141 #define	HELP_ENABLE_AUTOCONF	5
142 #define	HELP_DISABLE_AUTOCONF	6
143 #define	HELP_LED_CNTRL		7
144 #define	HELP_UNKNOWN		8
145 #define	SUCCESS			9
146 #define	FAILED			10
147 #define	UNKNOWN			11
148 
149 #define	MAXLINE			256
150 
151 /* for type string assembly in get_type() */
152 #define	TPCT(s)	(void) strlcat(buf, (s), CFGA_TYPE_LEN)
153 
154 extern int errno;
155 
156 static void cfga_err(char **errstring, ...);
157 static cfga_err_t fix_ap_name(char *ap_log_id, const char *ap_id,
158     char *slot_name, char **errstring);
159 static void build_control_data(struct hpc_control_data *iocdata, uint_t cmd,
160     void *retdata);
161 static cfga_err_t check_options(const char *options);
162 static void cfga_msg(struct cfga_msg *msgp, const char *str);
163 static char *findlink(char *ap_phys_id);
164 
165 static char *
166 cfga_strs[] = {
167 NULL,
168 "\nPCI hotplug specific commands:",
169 "\t-c [connect|disconnect|configure|unconfigure|insert|remove] "
170 "ap_id [ap_id...]",
171 "\t-x enable_slot  ap_id [ap_id...]",
172 "\t-x disable_slot ap_id [ap_id...]",
173 "\t-x enable_autoconfig  ap_id [ap_id...]",
174 "\t-x disable_autoconfig ap_id [ap_id...]",
175 "\t-x led[=[fault|power|active|attn],mode=[on|off|blink]] ap_id [ap_id...]",
176 "\tunknown command or option: ",
177 "success   ",
178 "failed   ",
179 "unknown",
180 NULL
181 };
182 
183 #define	MAX_FORMAT 80
184 
185 #define	ENABLE_SLOT	0
186 #define	DISABLE_SLOT	1
187 #define	ENABLE_AUTOCNF	2
188 #define	DISABLE_AUTOCNF	3
189 #define	LED		4
190 #define	MODE		5
191 
192 /*
193  * Board Type
194  */
195 static char *
196 board_strs[] = {
197 	/* n */ "???",	/* HPC_BOARD_UNKNOWN */
198 	/* n */ "hp",	/* HPC_BOARD_PCI_HOTPLUG */
199 	/* n */ "nhs",	/* HPC_BOARD_CPCI_NON_HS */
200 	/* n */ "bhs",  /* HPC_BOARD_CPCI_BASIC_HS */
201 	/* n */ "fhs",	/* HPC_BOARD_CPCI_FULL_HS */
202 	/* n */ "hs",	/* HPC_BOARD_CPCI_HS */
203 	/* n */ NULL
204 };
205 
206 /*
207  * HW functions
208  */
209 static char *
210 func_strs[] = {
211 	/* n */ "enable_slot",
212 	/* n */ "disable_slot",
213 	/* n */ "enable_autoconfig",
214 	/* n */ "disable_autoconfig",
215 	/* n */ "led",
216 	/* n */ "mode",
217 	/* n */ NULL
218 };
219 
220 /*
221  * LED strings
222  */
223 static char *
224 led_strs[] = {
225 	/* n */ "fault",	/* HPC_FAULT_LED */
226 	/* n */ "power",	/* HPC_POWER_LED */
227 	/* n */ "attn",		/* HPC_ATTN_LED */
228 	/* n */ "active",	/* HPC_ACTIVE_LED */
229 	/* n */ NULL
230 };
231 
232 #define	FAULT	0
233 #define	POWER	1
234 #define	ATTN	2
235 #define	ACTIVE	3
236 
237 static char *
238 mode_strs[] = {
239 	/* n */ "off",		/* HPC_LED_OFF */
240 	/* n */ "on",		/* HPC_LED_ON */
241 	/* n */ "blink",	/* HPC_LED_BLINK */
242 	/* n */	NULL
243 };
244 
245 #define	OFF	0
246 #define	ON	1
247 #define	BLINK	2
248 
249 #define	cfga_errstrs(i)		cfga_errstrs[(i)]
250 
251 #define	cfga_eid(a, b)		(((a) << 8) + (b))
252 #define	MAXDEVS			32
253 
254 typedef enum {
255 	SOLARIS_SLT_NAME,
256 	PROM_SLT_NAME
257 } slt_name_src_t;
258 
259 struct searcharg {
260 	char	*devpath;
261 	char	slotnames[MAXDEVS][MAXNAMELEN];
262 	int	minor;
263 	di_prom_handle_t	promp;
264 	slt_name_src_t	slt_name_src;
265 };
266 
267 static void *private_check;
268 
269 static int
get_occupants(const char * ap_id,hpc_occupant_info_t * occupant)270 get_occupants(const char *ap_id, hpc_occupant_info_t *occupant)
271 {
272 	int rv;
273 	int fd;
274 	di_node_t ap_node;
275 	char *prop_data;
276 	char *tmp;
277 	char *ptr;
278 	struct stat statbuf;
279 	dev_t devt;
280 
281 	if ((fd = open(ap_id, O_RDWR)) == -1) {
282 		DBG(2, ("open = ap_id%s, fd%d\n", ap_id, fd));
283 		DBG_F(2, (stderr, "open on %s failed\n", ap_id));
284 		return (CFGA_ERROR);
285 	}
286 
287 	if (fstat(fd, &statbuf) == -1) {
288 		DBG(1, ("stat failed: %i\n", errno));
289 		(void) close(fd);
290 		return (CFGA_ERROR);
291 	}
292 	(void) close(fd);
293 
294 	devt = statbuf.st_rdev;
295 
296 	tmp = (char *)(ap_id + sizeof ("/devices") - 1);
297 	if ((ptr = strrchr(tmp, ':')) != NULL)
298 		*ptr = '\0';
299 
300 	ap_node = di_init(tmp, DINFOPROP | DINFOMINOR);
301 	if (ap_node == DI_NODE_NIL) {
302 		DBG(1, ("dead %i\n", errno));
303 		return (CFGA_ERROR);
304 	}
305 
306 #ifdef	PCIHP_DBG
307 	ptr = di_devfs_path(ap_node);
308 	DBG(1, ("get_occupants: %s\n", ptr));
309 	di_devfs_path_free(ptr);
310 #endif
311 
312 	if ((rv = di_prop_lookup_strings(devt, ap_node, "pci-occupant",
313 	    &prop_data)) == -1) {
314 		DBG(1, ("get_occupants: prop_lookup failed: %i\n", errno));
315 		di_fini(ap_node);
316 		return (CFGA_ERROR);
317 	}
318 
319 	if (prop_data && (strcmp(prop_data, "") == 0)) {
320 		di_fini(ap_node);
321 		occupant->i = 0;
322 		occupant->id[0] = NULL;
323 		return (CFGA_OK);
324 	}
325 
326 	DBG(1, ("get_occupants: %i devices found\n", rv));
327 	for (occupant->i = 0; occupant->i < rv; occupant->i++) {
328 		if (occupant->i >= (HPC_MAX_OCCUPANTS - 1)) {
329 			occupant->i--;
330 			break;
331 		}
332 		occupant->id[occupant->i] = (char *)malloc(
333 		    strlen(prop_data) + sizeof ("/devices"));
334 		(void) snprintf(occupant->id[occupant->i], strlen(prop_data) +
335 		    sizeof ("/devices"), "/devices%s", prop_data);
336 		DBG(1, ("%s\n", occupant->id[occupant->i]));
337 		prop_data += strlen(prop_data) + 1;
338 	}
339 	di_fini(ap_node);
340 
341 	occupant->id[occupant->i] = NULL;
342 
343 	return (CFGA_OK);
344 }
345 
346 /*
347  * let rcm know that the device has indeed been removed and clean
348  * up rcm data
349  */
350 static void
confirm_rcm(hpc_occupant_info_t * occupant,rcm_handle_t * rhandle)351 confirm_rcm(hpc_occupant_info_t *occupant, rcm_handle_t *rhandle)
352 {
353 	DBG(1, ("confirm_rcm\n"));
354 
355 	if (occupant->i == 0) /* nothing was found to ask rcm about */
356 		return;
357 
358 	(void) rcm_notify_remove_list(rhandle, occupant->id, 0, NULL);
359 	(void) rcm_free_handle(rhandle);
360 
361 	for (; occupant->i >= 0; occupant->i--)
362 		free(occupant->id[occupant->i]);
363 }
364 
365 static void
fail_rcm(hpc_occupant_info_t * occupant,rcm_handle_t * rhandle)366 fail_rcm(hpc_occupant_info_t *occupant, rcm_handle_t *rhandle)
367 {
368 	DBG(1, ("fail_rcm\n"));
369 
370 	if (occupant->i == 0) /* nothing was found to ask rcm about */
371 		return;
372 
373 	(void) rcm_notify_online_list(rhandle, occupant->id, 0, NULL);
374 	(void) rcm_free_handle(rhandle);
375 
376 	for (; occupant->i >= 0; occupant->i--)
377 		free(occupant->id[occupant->i]);
378 }
379 
380 /*
381  * copied from scsi_rcm_info_table
382  *
383  *      Takes an opaque rcm_info_t pointer and a character pointer, and appends
384  * the rcm_info_t data in the form of a table to the given character pointer.
385  */
386 static void
pci_rcm_info_table(rcm_info_t * rinfo,char ** table)387 pci_rcm_info_table(rcm_info_t *rinfo, char **table)
388 {
389 	int i;
390 	size_t w;
391 	size_t width = 0;
392 	size_t w_rsrc = 0;
393 	size_t w_info = 0;
394 	size_t table_size = 0;
395 	uint_t tuples = 0;
396 	rcm_info_tuple_t *tuple = NULL;
397 	char *rsrc;
398 	char *info;
399 	char *newtable;
400 	static char format[MAX_FORMAT];
401 	const char *infostr;
402 
403 	/* Protect against invalid arguments */
404 	if (rinfo == NULL || table == NULL)
405 		return;
406 
407 	/* Set localized table header strings */
408 	rsrc = dgettext(TEXT_DOMAIN, "Resource");
409 	info = dgettext(TEXT_DOMAIN, "Information");
410 
411 	/* A first pass, to size up the RCM information */
412 	while (tuple = rcm_info_next(rinfo, tuple)) {
413 		if ((infostr = rcm_info_info(tuple)) != NULL) {
414 			tuples++;
415 			if ((w = strlen(rcm_info_rsrc(tuple))) > w_rsrc)
416 				w_rsrc = w;
417 			if ((w = strlen(infostr)) > w_info)
418 				w_info = w;
419 		}
420 	}
421 
422 	/* If nothing was sized up above, stop early */
423 	if (tuples == 0)
424 		return;
425 
426 	/* Adjust column widths for column headings */
427 	if ((w = strlen(rsrc)) > w_rsrc)
428 		w_rsrc = w;
429 	else if ((w_rsrc - w) % 2)
430 		w_rsrc++;
431 	if ((w = strlen(info)) > w_info)
432 		w_info = w;
433 	else if ((w_info - w) % 2)
434 		w_info++;
435 
436 	/*
437 	 * Compute the total line width of each line,
438 	 * accounting for intercolumn spacing.
439 	 */
440 	width = w_info + w_rsrc + 4;
441 
442 	/* Allocate space for the table */
443 	table_size = (2 + tuples) * (width + 1) + 2;
444 	if (*table == NULL) {
445 		/* zero fill for the strcat() call below */
446 		*table = calloc(table_size, sizeof (char));
447 		if (*table == NULL)
448 			return;
449 	} else {
450 		newtable = realloc(*table, strlen(*table) + table_size);
451 		if (newtable == NULL)
452 			return;
453 		else
454 			*table = newtable;
455 	}
456 
457 	/* Place a table header into the string */
458 
459 	/* The resource header */
460 	(void) strcat(*table, "\n");
461 	w = strlen(rsrc);
462 	for (i = 0; i < ((w_rsrc - w) / 2); i++)
463 		(void) strcat(*table, " ");
464 	(void) strcat(*table, rsrc);
465 	for (i = 0; i < ((w_rsrc - w) / 2); i++)
466 		(void) strcat(*table, " ");
467 
468 	/* The information header */
469 	(void) strcat(*table, "  ");
470 	w = strlen(info);
471 	for (i = 0; i < ((w_info - w) / 2); i++)
472 		(void) strcat(*table, " ");
473 	(void) strcat(*table, info);
474 	for (i = 0; i < ((w_info - w) / 2); i++)
475 		(void) strcat(*table, " ");
476 	/* Underline the headers */
477 	(void) strcat(*table, "\n");
478 	for (i = 0; i < w_rsrc; i++)
479 		(void) strcat(*table, "-");
480 	(void) strcat(*table, "  ");
481 	for (i = 0; i < w_info; i++)
482 		(void) strcat(*table, "-");
483 
484 	/* Construct the format string */
485 	(void) snprintf(format, MAX_FORMAT, "%%-%ds  %%-%ds",
486 	    (int)w_rsrc, (int)w_info);
487 
488 	/* Add the tuples to the table string */
489 	tuple = NULL;
490 	while ((tuple = rcm_info_next(rinfo, tuple)) != NULL) {
491 		if ((infostr = rcm_info_info(tuple)) != NULL) {
492 			(void) strcat(*table, "\n");
493 			(void) sprintf(&((*table)[strlen(*table)]),
494 			    format, rcm_info_rsrc(tuple),
495 			    infostr);
496 		}
497 	}
498 }
499 
500 /*
501  * Figure out what device is about to be unconfigured or disconnected
502  * and make sure rcm is ok with it.
503  * hangs on to a list of handles so they can then be confirmed or denied
504  * if either getting the occupant list or talking to rcm fails
505  * return CFGA_ERROR so that things can go on without rcm
506  */
507 static int
check_rcm(const char * ap_id,hpc_occupant_info_t * occupant,rcm_handle_t ** rhandlep,char ** errstring,cfga_flags_t flags)508 check_rcm(const char *ap_id, hpc_occupant_info_t *occupant,
509     rcm_handle_t **rhandlep, char **errstring, cfga_flags_t flags)
510 {
511 	int rv;
512 	rcm_info_t *rinfo;
513 	rcm_handle_t *rhandle;
514 	uint_t rcmflags;
515 
516 	if (get_occupants(ap_id, occupant) != 0) {
517 		DBG(1, ("check_rcm: failed to get occupants\n"));
518 		return (CFGA_ERROR);
519 	}
520 
521 	if (occupant->i == 0) {
522 		DBG(1, ("check_rcm: no drivers attaching to occupants\n"));
523 		return (CFGA_OK);
524 	}
525 
526 	if (rcm_alloc_handle(NULL, 0, NULL, &rhandle)
527 	    != RCM_SUCCESS) {
528 		DBG(1, ("check_rcm: blocked by rcm failure\n"));
529 		return (CFGA_ERROR);
530 	}
531 
532 	rcmflags = (flags & CFGA_FLAG_FORCE) ? RCM_FORCE : 0;
533 	rv = rcm_request_offline_list(rhandle, occupant->id, rcmflags, &rinfo);
534 
535 	if (rv == RCM_FAILURE) {
536 		DBG(1, ("check_rcm: blocked by rcm failure 2\n"));
537 		pci_rcm_info_table(rinfo, errstring);
538 		rcm_free_info(rinfo);
539 		fail_rcm(occupant, rhandle);
540 		return (CFGA_BUSY);
541 	}
542 	if (rv == RCM_CONFLICT) {
543 		DBG(1, ("check_rcm: blocked by %i\n",
544 		    rcm_info_pid(rinfo)));
545 		pci_rcm_info_table(rinfo, errstring);
546 		rcm_free_info(rinfo);
547 		(void) rcm_free_handle(rhandle);
548 		for (; occupant->i >= 0; occupant->i--)
549 			free(occupant->id[occupant->i]);
550 		return (CFGA_BUSY);
551 	}
552 
553 	rcm_free_info(rinfo);
554 	*rhandlep = rhandle;
555 
556 	/* else */
557 	return (CFGA_OK);
558 }
559 
560 
561 /*
562  * Transitional Diagram:
563  *
564  *  empty		unconfigure
565  * (remove)	^|  (physically insert card)
566  *			|V
567  * disconnect	configure
568  * "-c DISCONNECT"	^|	"-c CONNECT"
569  *				|V	"-c CONFIGURE"
570  * connect	unconfigure	->	connect    configure
571  *						<-
572  *					"-c UNCONFIGURE"
573  *
574  */
575 /*ARGSUSED*/
576 cfga_err_t
cfga_change_state(cfga_cmd_t state_change_cmd,const char * ap_id,const char * options,struct cfga_confirm * confp,struct cfga_msg * msgp,char ** errstring,cfga_flags_t flags)577 cfga_change_state(cfga_cmd_t state_change_cmd, const char *ap_id,
578     const char *options, struct cfga_confirm *confp,
579     struct cfga_msg *msgp, char **errstring, cfga_flags_t flags)
580 {
581 	int rv;
582 	devctl_hdl_t		dcp;
583 	devctl_ap_state_t	state;
584 	ap_rstate_t		rs;
585 	ap_ostate_t		os;
586 	hpc_occupant_info_t occupants;
587 	rcm_handle_t *rhandle;
588 
589 	if ((rv = check_options(options)) != CFGA_OK) {
590 		return (rv);
591 	}
592 
593 	if (errstring != NULL)
594 		*errstring = NULL;
595 
596 	rv = CFGA_OK;
597 	DBG(1, ("cfga_change_state:(%s)\n", ap_id));
598 
599 	if ((dcp = devctl_ap_acquire((char *)ap_id, 0)) == NULL) {
600 		if (rv == EBUSY) {
601 			cfga_err(errstring, CMD_ACQUIRE, ap_id, 0);
602 			DBG(1, ("cfga_change_state: device is busy\n"));
603 			rv = CFGA_BUSY;
604 		} else
605 			rv = CFGA_ERROR;
606 		return (rv);
607 	}
608 
609 	if (devctl_ap_getstate(dcp, NULL, &state) == -1) {
610 		DBG(2, ("cfga_change_state: devctl ap getstate failed\n"));
611 		cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
612 		devctl_release((devctl_hdl_t)dcp);
613 		if (rv == EBUSY)
614 			rv = CFGA_BUSY;
615 		else
616 			rv = CFGA_ERROR;
617 		return (rv);
618 	}
619 
620 	rs = state.ap_rstate;
621 	os = state.ap_ostate;
622 
623 	DBG(1, ("cfga_change_state: rs is %d\n", state.ap_rstate));
624 	DBG(1, ("cfga_change_state: os is %d\n", state.ap_ostate));
625 	switch (state_change_cmd) {
626 	case CFGA_CMD_CONNECT:
627 		if ((rs == AP_RSTATE_EMPTY) ||
628 		    (rs == AP_RSTATE_CONNECTED) ||
629 		    (os == AP_OSTATE_CONFIGURED)) {
630 			cfga_err(errstring, ERR_AP_ERR, 0);
631 			rv = CFGA_INVAL;
632 		} else {
633 			/* Lets connect the slot */
634 			if (devctl_ap_connect(dcp, NULL) == -1) {
635 				rv = CFGA_ERROR;
636 				cfga_err(errstring,
637 				    CMD_SLOT_CONNECT, 0);
638 			}
639 		}
640 
641 		break;
642 
643 	case CFGA_CMD_DISCONNECT:
644 		DBG(1, ("disconnect\n"));
645 
646 		if (os == AP_OSTATE_CONFIGURED) {
647 			if ((rv = check_rcm(ap_id, &occupants, &rhandle,
648 			    errstring, flags)) == CFGA_BUSY) {
649 				break;
650 			} else if (rv == CFGA_OK) {
651 				if (devctl_ap_unconfigure(dcp, NULL) == -1) {
652 					if (errno == EBUSY)
653 						rv = CFGA_BUSY;
654 					else
655 						rv = CFGA_ERROR;
656 					cfga_err(errstring,
657 					    CMD_SLOT_DISCONNECT, 0);
658 					fail_rcm(&occupants, rhandle);
659 					break;
660 				} else {
661 					confirm_rcm(&occupants, rhandle);
662 				}
663 			} else { /* rv == CFGA_ERROR */
664 				if (devctl_ap_unconfigure(dcp, NULL) == -1) {
665 					if (errno == EBUSY)
666 						rv = CFGA_BUSY;
667 					else
668 						rv = CFGA_ERROR;
669 					break;
670 				} else {
671 					rv = CFGA_OK;
672 				}
673 			}
674 		}
675 
676 		if (rs == AP_RSTATE_CONNECTED) {
677 			if (devctl_ap_disconnect(dcp, NULL) == -1) {
678 				rv = CFGA_ERROR;
679 				cfga_err(errstring, CMD_SLOT_DISCONNECT, 0);
680 				break;
681 			}
682 		} else {
683 			cfga_err(errstring, ERR_AP_ERR, 0);
684 			rv = CFGA_INVAL;
685 		}
686 
687 		break;
688 
689 	case CFGA_CMD_CONFIGURE:
690 		if (rs == AP_RSTATE_DISCONNECTED) {
691 			if (devctl_ap_connect(dcp, NULL) == -1) {
692 				rv = CFGA_ERROR;
693 				cfga_err(errstring, CMD_SLOT_CONNECT, 0);
694 				break;
695 			}
696 		}
697 
698 		/*
699 		 * for multi-func device we allow multiple
700 		 * configure on the same slot because one
701 		 * func can be configured and other one won't
702 		 */
703 		if (devctl_ap_configure(dcp, NULL) == -1) {
704 			rv = CFGA_ERROR;
705 			cfga_err(errstring, CMD_SLOT_CONFIGURE, 0);
706 			if ((rs == AP_RSTATE_DISCONNECTED) &&
707 			    (devctl_ap_disconnect(dcp, NULL) == -1)) {
708 				rv = CFGA_ERROR;
709 				cfga_err(errstring,
710 				    CMD_SLOT_CONFIGURE, 0);
711 			}
712 			break;
713 		}
714 
715 		break;
716 
717 	case CFGA_CMD_UNCONFIGURE:
718 		DBG(1, ("unconfigure\n"));
719 
720 		if (os == AP_OSTATE_CONFIGURED) {
721 			if ((rv = check_rcm(ap_id, &occupants, &rhandle,
722 			    errstring, flags)) == CFGA_BUSY) {
723 				break;
724 			} else if (rv == CFGA_OK) {
725 				if (devctl_ap_unconfigure(dcp, NULL) == -1) {
726 					if (errno == EBUSY)
727 						rv = CFGA_BUSY;
728 					else {
729 						if (errno == ENOTSUP)
730 							rv = CFGA_OPNOTSUPP;
731 						else
732 							rv = CFGA_ERROR;
733 					}
734 					cfga_err(errstring,
735 					    CMD_SLOT_UNCONFIGURE, 0);
736 					fail_rcm(&occupants, rhandle);
737 				} else {
738 					confirm_rcm(&occupants, rhandle);
739 				}
740 			} else { /* rv == CFGA_ERROR */
741 				if (devctl_ap_unconfigure(dcp, NULL) == -1) {
742 					if (errno == EBUSY)
743 						rv = CFGA_BUSY;
744 					else {
745 						if (errno == ENOTSUP)
746 							rv = CFGA_OPNOTSUPP;
747 						else
748 							rv = CFGA_ERROR;
749 					}
750 					cfga_err(errstring,
751 					    CMD_SLOT_UNCONFIGURE, 0);
752 				} else {
753 					rv = CFGA_OK;
754 				}
755 			}
756 		} else {
757 			cfga_err(errstring, ERR_AP_ERR, 0);
758 			rv = CFGA_INVAL;
759 		}
760 
761 		DBG(1, ("uncofigure rv:(%i)\n", rv));
762 		break;
763 
764 	case CFGA_CMD_LOAD:
765 		if ((os == AP_OSTATE_UNCONFIGURED) &&
766 		    (rs == AP_RSTATE_DISCONNECTED)) {
767 			if (devctl_ap_insert(dcp, NULL) == -1) {
768 				rv = CFGA_ERROR;
769 				cfga_err(errstring, CMD_SLOT_INSERT, 0);
770 			}
771 		} else {
772 			cfga_err(errstring, ERR_AP_ERR, 0);
773 			rv = CFGA_INVAL;
774 		}
775 
776 		break;
777 
778 	case CFGA_CMD_UNLOAD:
779 		if ((os == AP_OSTATE_UNCONFIGURED) &&
780 		    (rs == AP_RSTATE_DISCONNECTED)) {
781 			if (devctl_ap_remove(dcp, NULL) == -1) {
782 				rv = CFGA_ERROR;
783 				cfga_err(errstring, CMD_SLOT_REMOVE, 0);
784 			}
785 		} else {
786 				cfga_err(errstring, ERR_AP_ERR, 0);
787 				rv = CFGA_INVAL;
788 			}
789 
790 		break;
791 
792 	default:
793 		rv = CFGA_OPNOTSUPP;
794 		break;
795 	}
796 
797 	devctl_release((devctl_hdl_t)dcp);
798 	return (rv);
799 }
800 
801 /*
802  * Building iocdatat to pass it to nexus
803  *
804  *	iocdata->cmd ==  HPC_CTRL_ENABLE_SLOT/HPC_CTRL_DISABLE_SLOT
805  *			HPC_CTRL_ENABLE_AUTOCFG/HPC_CTRL_DISABLE_AUTOCFG
806  *			HPC_CTRL_GET_LED_STATE/HPC_CTRL_SET_LED_STATE
807  *			HPC_CTRL_GET_SLOT_STATE/HPC_CTRL_GET_SLOT_INFO
808  *			HPC_CTRL_DEV_CONFIGURE/HPC_CTRL_DEV_UNCONFIGURE
809  *			HPC_CTRL_GET_BOARD_TYPE
810  *
811  */
812 static void
build_control_data(struct hpc_control_data * iocdata,uint_t cmd,void * retdata)813 build_control_data(struct hpc_control_data *iocdata, uint_t cmd,
814     void *retdata)
815 {
816 	iocdata->cmd = cmd;
817 	iocdata->data = retdata;
818 }
819 
820 /*
821  * building logical name from ap_id
822  */
823 /*ARGSUSED2*/
824 static void
get_logical_name(const char * ap_id,char * buf,dev_t rdev)825 get_logical_name(const char *ap_id, char *buf, dev_t rdev)
826 {
827 	char *bufptr, *bufptr2, *pci, *apid;
828 
829 	DBG(1, ("get_logical_name: %s\n", ap_id));
830 
831 	if ((apid = malloc(MAXPATHLEN)) == NULL) {
832 		DBG(1, ("malloc failed\n"));
833 		return;
834 	}
835 
836 	(void) memset(apid, 0, MAXPATHLEN);
837 	(void) strncpy(apid, ap_id, strlen(ap_id));
838 
839 	/* needs to look for last /, not first */
840 	bufptr = strrchr(apid, '/');
841 
842 	bufptr2 = strrchr(apid, ':');
843 	pci = ++bufptr;
844 	bufptr = strchr(pci, ',');
845 	if (bufptr != NULL) {
846 		*bufptr = '\0';
847 	}
848 
849 	bufptr = strchr(pci, '@');
850 	if (bufptr != NULL) {
851 		*bufptr = '\0';
852 		bufptr++;
853 	}
854 
855 	DBG(1, ("%s\n%s\n%s\n", pci, bufptr, bufptr2));
856 
857 	(void) strcat(buf, pci);
858 	(void) strcat(buf, bufptr);
859 	(void) strcat(buf, bufptr2);
860 	free(apid);
861 }
862 
863 static cfga_err_t
prt_led_mode(const char * ap_id,int repeat,char ** errstring,struct cfga_msg * msgp)864 prt_led_mode(const char *ap_id, int repeat, char **errstring,
865     struct cfga_msg *msgp)
866 {
867 	hpc_led_info_t	power_led_info = {HPC_POWER_LED, 0};
868 	hpc_led_info_t	fault_led_info = {HPC_FAULT_LED, 0};
869 	hpc_led_info_t	attn_led_info = {HPC_ATTN_LED, 0};
870 	hpc_led_info_t	active_led_info = {HPC_ACTIVE_LED, 0};
871 	struct hpc_control_data iocdata;
872 	struct stat	statbuf;
873 	char  *buff;
874 	int	fd;
875 	hpc_slot_info_t		slot_info;
876 	char *cp, line[MAXLINE];
877 	int len = MAXLINE;
878 
879 	DBG(1, ("prt_led_mod function\n"));
880 	if (!repeat)
881 		cfga_msg(msgp, "Ap_Id\t\t\tLed");
882 
883 	if ((fd = open(ap_id, O_RDWR)) == -1) {
884 		DBG(2, ("open = ap_id%s, fd%d\n", ap_id, fd));
885 		DBG_F(2, (stderr, "open on %s failed\n", ap_id));
886 		cfga_err(errstring, CMD_OPEN,  ap_id, 0);
887 		return (CFGA_ERROR);
888 	}
889 
890 	if (fstat(fd, &statbuf) == -1) {
891 		DBG(2, ("fstat = ap_id%s, fd%d\n", ap_id, fd));
892 		DBG_F(2, (stderr, "fstat on %s failed\n", ap_id));
893 		cfga_err(errstring, CMD_FSTAT, ap_id, 0);
894 		return (CFGA_ERROR);
895 	}
896 
897 	if ((buff = malloc(MAXPATHLEN)) == NULL) {
898 		cfga_err(errstring, "malloc ", 0);
899 		return (CFGA_ERROR);
900 	}
901 
902 	(void) memset(buff, 0, MAXPATHLEN);
903 
904 	DBG(1, ("ioctl boardtype\n"));
905 
906 	build_control_data(&iocdata, HPC_CTRL_GET_SLOT_INFO,
907 	    (void *)&slot_info);
908 
909 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
910 		get_logical_name(ap_id, slot_info.pci_slot_name, 0);
911 		DBG(1, ("ioctl failed slotinfo: %s\n",
912 		    slot_info.pci_slot_name));
913 	} else {
914 
915 		/*
916 		 * the driver will report back things like hpc0_slot0
917 		 * this needs to be changed to things like pci1:hpc0_slot0
918 		 */
919 		if (fix_ap_name(buff, ap_id, slot_info.pci_slot_name,
920 		    errstring) != CFGA_OK) {
921 			free(buff);
922 			(void) close(fd);
923 			return (CFGA_ERROR);
924 		}
925 		DBG(1, ("ioctl slotinfo: %s\n", buff));
926 	}
927 
928 	cp = line;
929 	(void) snprintf(cp, len, "%s\t\t", buff);
930 	len -= strlen(cp);
931 	cp += strlen(cp);
932 
933 	free(buff);
934 
935 	build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &power_led_info);
936 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
937 		(void) snprintf(cp, len, "%s=%s,",
938 		    led_strs[power_led_info.led], cfga_strs[UNKNOWN]);
939 		len -= strlen(cp);
940 		cp += strlen(cp);
941 	} else {
942 		(void) snprintf(cp, len, "%s=%s,", led_strs[power_led_info.led],
943 		    mode_strs[power_led_info.state]);
944 		len -= strlen(cp);
945 		cp += strlen(cp);
946 	}
947 
948 	DBG(1, ("%s:%d\n", led_strs[power_led_info.led], power_led_info.state));
949 
950 	build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &fault_led_info);
951 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
952 		(void) snprintf(cp, len, "%s=%s,",
953 		    led_strs[fault_led_info.led], cfga_strs[UNKNOWN]);
954 		len -= strlen(cp);
955 		cp += strlen(cp);
956 	} else {
957 		(void) snprintf(cp, len, "%s=%s,",
958 		    led_strs[fault_led_info.led],
959 		    mode_strs[fault_led_info.state]);
960 		len -= strlen(cp);
961 		cp += strlen(cp);
962 	}
963 	DBG(1, ("%s:%d\n", led_strs[fault_led_info.led], fault_led_info.state));
964 
965 	build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &attn_led_info);
966 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
967 		(void) snprintf(cp, len, "%s=%s,",
968 		    led_strs[attn_led_info.led], cfga_strs[UNKNOWN]);
969 		len -= strlen(cp);
970 		cp += strlen(cp);
971 	} else {
972 		(void) snprintf(cp, len, "%s=%s,",
973 		    led_strs[attn_led_info.led],
974 		    mode_strs[attn_led_info.state]);
975 		len -= strlen(cp);
976 		cp += strlen(cp);
977 	}
978 	DBG(1, ("%s:%d\n", led_strs[attn_led_info.led], attn_led_info.state));
979 
980 	build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &active_led_info);
981 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
982 		(void) snprintf(cp, len, "%s=%s", led_strs[active_led_info.led],
983 		    cfga_strs[UNKNOWN]);
984 	} else {
985 		(void) snprintf(cp, len, "%s=%s",
986 		    led_strs[active_led_info.led],
987 		    mode_strs[active_led_info.state]);
988 	}
989 	cfga_msg(msgp, line);	/* print the message */
990 	DBG(1, ("%s:%d\n", led_strs[active_led_info.led],
991 	    active_led_info.state));
992 
993 	(void) close(fd);
994 
995 	return (CFGA_OK);
996 }
997 
998 /*ARGSUSED*/
999 cfga_err_t
cfga_private_func(const char * function,const char * ap_id,const char * options,struct cfga_confirm * confp,struct cfga_msg * msgp,char ** errstring,cfga_flags_t flags)1000 cfga_private_func(const char *function, const char *ap_id,
1001     const char *options, struct cfga_confirm *confp,
1002     struct cfga_msg *msgp, char **errstring, cfga_flags_t flags)
1003 {
1004 	char *str;
1005 	int   len, fd, i = 0, repeat = 0;
1006 	char buf[MAXNAMELEN];
1007 	char ptr;
1008 	hpc_led_info_t	led_info;
1009 	struct hpc_control_data	iocdata;
1010 	cfga_err_t rv;
1011 
1012 	DBG(1, ("cfgadm_private_func: ap_id:%s\n", ap_id));
1013 	DBG(2, ("  options: %s\n", (options == NULL)?"null":options));
1014 	DBG(2, ("  confp: %x\n", confp));
1015 	DBG(2, ("  cfga_msg: %x\n", cfga_msg));
1016 	DBG(2, ("  flag: %d\n", flags));
1017 
1018 	if ((rv = check_options(options)) != CFGA_OK) {
1019 		return (rv);
1020 	}
1021 
1022 	if (private_check == confp)
1023 		repeat = 1;
1024 	else
1025 		private_check = (void*)confp;
1026 
1027 	/* XXX change const 6 to func_str[i] != NULL */
1028 	for (i = 0, str = func_strs[i], len = strlen(str); i < 6; i++) {
1029 		str = func_strs[i];
1030 		len = strlen(str);
1031 		if (strncmp(function, str, len) == 0)
1032 			break;
1033 	}
1034 
1035 	switch (i) {
1036 		case ENABLE_SLOT:
1037 			build_control_data(&iocdata,
1038 			    HPC_CTRL_ENABLE_SLOT, 0);
1039 			break;
1040 		case DISABLE_SLOT:
1041 			build_control_data(&iocdata,
1042 			    HPC_CTRL_DISABLE_SLOT, 0);
1043 			break;
1044 		case ENABLE_AUTOCNF:
1045 			build_control_data(&iocdata,
1046 			    HPC_CTRL_ENABLE_AUTOCFG, 0);
1047 			break;
1048 		case DISABLE_AUTOCNF:
1049 			build_control_data(&iocdata,
1050 			    HPC_CTRL_DISABLE_AUTOCFG, 0);
1051 			break;
1052 		case LED:
1053 			/* set mode */
1054 			ptr = function[len++];
1055 			if (ptr == '=') {
1056 				str = (char *)function;
1057 				for (str = (str+len++), i = 0; *str != ',';
1058 				    i++, str++) {
1059 					if (i == (MAXNAMELEN - 1))
1060 						break;
1061 
1062 					buf[i] = *str;
1063 					DBG_F(2, (stdout, "%c\n", buf[i]));
1064 				}
1065 				buf[i] = '\0'; str++;
1066 				DBG(2, ("buf = %s\n", buf));
1067 
1068 				/* ACTIVE=3,ATTN=2,POWER=1,FAULT=0 */
1069 				if (strcmp(buf, led_strs[POWER]) == 0)
1070 					led_info.led = HPC_POWER_LED;
1071 				else if (strcmp(buf, led_strs[FAULT]) == 0)
1072 					led_info.led = HPC_FAULT_LED;
1073 				else if (strcmp(buf, led_strs[ATTN]) == 0)
1074 					led_info.led = HPC_ATTN_LED;
1075 				else if (strcmp(buf, led_strs[ACTIVE]) == 0)
1076 					led_info.led = HPC_ACTIVE_LED;
1077 				else return (CFGA_INVAL);
1078 
1079 				len = strlen(func_strs[MODE]);
1080 				if ((strncmp(str, func_strs[MODE], len) == 0) &&
1081 				    (*(str+(len)) == '=')) {
1082 					for (str = (str+(++len)), i = 0;
1083 					    *str != '\0'; i++, str++) {
1084 						buf[i] = *str;
1085 					}
1086 				}
1087 				buf[i] = '\0';
1088 				DBG(2, ("buf_mode= %s\n", buf));
1089 
1090 				/* ON = 1, OFF = 0 */
1091 				if (strcmp(buf, mode_strs[ON]) == 0)
1092 					led_info.state = HPC_LED_ON;
1093 				else if (strcmp(buf, mode_strs[OFF]) == 0)
1094 					led_info.state = HPC_LED_OFF;
1095 				else if (strcmp(buf, mode_strs[BLINK]) == 0)
1096 					led_info.state = HPC_LED_BLINK;
1097 				else return (CFGA_INVAL);
1098 
1099 				/* sendin  */
1100 				build_control_data(&iocdata,
1101 				    HPC_CTRL_SET_LED_STATE,
1102 				    (void *)&led_info);
1103 				break;
1104 			} else if (ptr == '\0') {
1105 				/* print mode */
1106 				DBG(1, ("Print mode\n"));
1107 				return (prt_led_mode(ap_id, repeat, errstring,
1108 				    msgp));
1109 			}
1110 			/* FALLTHROUGH */
1111 		default:
1112 			DBG(1, ("default\n"));
1113 			errno = EINVAL;
1114 			return (CFGA_INVAL);
1115 	}
1116 
1117 	if ((fd = open(ap_id, O_RDWR)) == -1) {
1118 		DBG(1, ("open failed\n"));
1119 		return (CFGA_ERROR);
1120 	}
1121 
1122 	DBG(1, ("open = ap_id=%s, fd=%d\n", ap_id, fd));
1123 
1124 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
1125 		DBG(1, ("ioctl failed\n"));
1126 		(void) close(fd);
1127 		return (CFGA_ERROR);
1128 	}
1129 
1130 	(void) close(fd);
1131 
1132 	return (CFGA_OK);
1133 }
1134 
1135 /*ARGSUSED*/
cfga_test(const char * ap_id,const char * options,struct cfga_msg * msgp,char ** errstring,cfga_flags_t flags)1136 cfga_err_t cfga_test(const char *ap_id, const char *options,
1137     struct cfga_msg *msgp, char **errstring, cfga_flags_t flags)
1138 {
1139 	cfga_err_t rv;
1140 	if (errstring != NULL)
1141 		*errstring = NULL;
1142 
1143 	if ((rv = check_options(options)) != CFGA_OK) {
1144 		return (rv);
1145 	}
1146 
1147 	DBG(1, ("cfga_test:(%s)\n", ap_id));
1148 	/* will need to implement pci CTRL command */
1149 	return (CFGA_NOTSUPP);
1150 }
1151 
1152 static int
fixup_slotname(int rval,int * intp,struct searcharg * slotarg)1153 fixup_slotname(int rval, int *intp, struct searcharg *slotarg)
1154 {
1155 
1156 /*
1157  * The slot-names property describes the external labeling of add-in slots.
1158  * This property is an encoded array, an integer followed by a list of
1159  * strings. The return value from di_prop_lookup_ints for slot-names is -1.
1160  * The expected return value should be the number of elements.
1161  * Di_prop_decode_common does not decode encoded data from software,
1162  * such as the solaris device tree, unlike from the prom.
1163  * Di_prop_decode_common takes the size of the encoded data and mods
1164  * it with the size of int. The size of the encoded data for slot-names is 9
1165  * and the size of int is 4, yielding a non zero result. A value of -1 is used
1166  * to indicate that the number of elements can not be determined.
1167  * Di_prop_decode_common can be modified to decode encoded data from the solaris
1168  * device tree.
1169  */
1170 
1171 	if ((slotarg->slt_name_src == PROM_SLT_NAME) && (rval == -1)) {
1172 		return (DI_WALK_TERMINATE);
1173 	} else {
1174 		int i;
1175 		char *tmptr = (char *)(intp+1);
1176 		DBG(1, ("slot-bitmask: %x \n", *intp));
1177 
1178 		rval = (rval -1) * 4;
1179 
1180 		for (i = 0; i <= slotarg->minor; i++) {
1181 			DBG(2, ("curr slot-name: %s \n", tmptr));
1182 
1183 			if (i >= MAXDEVS)
1184 				return (DI_WALK_TERMINATE);
1185 
1186 			if ((*intp >> i) & 1) {
1187 				/* assign tmptr */
1188 				DBG(2, ("slot-name: %s \n", tmptr));
1189 				if (i == slotarg->minor)
1190 					(void) strcpy(slotarg->slotnames[i],
1191 					    tmptr);
1192 				/* wind tmptr to next \0 */
1193 				while (*tmptr != '\0') {
1194 					tmptr++;
1195 				}
1196 				tmptr++;
1197 			} else {
1198 				/* point at unknown string */
1199 				if (i == slotarg->minor)
1200 					(void) strcpy(slotarg->slotnames[i],
1201 					    "unknown");
1202 			}
1203 		}
1204 	}
1205 	return (DI_WALK_TERMINATE);
1206 }
1207 
1208 static int
find_slotname(di_node_t din,di_minor_t dim,void * arg)1209 find_slotname(di_node_t din, di_minor_t dim, void *arg)
1210 {
1211 	struct searcharg *slotarg = (struct searcharg *)arg;
1212 	di_prom_handle_t ph = (di_prom_handle_t)slotarg->promp;
1213 	di_prom_prop_t	prom_prop;
1214 	di_prop_t	solaris_prop;
1215 	int *intp, rval;
1216 	char *devname;
1217 	char fulldevname[MAXNAMELEN];
1218 
1219 	slotarg->minor = dim->dev_minor % 256;
1220 
1221 	DBG(2, ("minor number:(%i)\n", slotarg->minor));
1222 	DBG(2, ("hot plug slots found so far:(%i)\n", 0));
1223 
1224 	if ((devname = di_devfs_path(din)) != NULL) {
1225 		(void) snprintf(fulldevname, MAXNAMELEN,
1226 		    "/devices%s:%s", devname, di_minor_name(dim));
1227 		di_devfs_path_free(devname);
1228 	}
1229 
1230 	if (strcmp(fulldevname, slotarg->devpath) == 0) {
1231 
1232 		/*
1233 		 * Check the Solaris device tree first
1234 		 * in the case of a DR operation
1235 		 */
1236 		solaris_prop = di_prop_hw_next(din, DI_PROP_NIL);
1237 		while (solaris_prop != DI_PROP_NIL) {
1238 			if (strcmp("slot-names", di_prop_name(solaris_prop))
1239 			    == 0) {
1240 				rval = di_prop_lookup_ints(DDI_DEV_T_ANY,
1241 				    din, di_prop_name(solaris_prop), &intp);
1242 				slotarg->slt_name_src = SOLARIS_SLT_NAME;
1243 
1244 				return (fixup_slotname(rval, intp, slotarg));
1245 			}
1246 			solaris_prop = di_prop_hw_next(din, solaris_prop);
1247 		}
1248 
1249 		/*
1250 		 * Check the prom device tree which is populated at boot.
1251 		 * If this fails, give up and set the slot name to null.
1252 		 */
1253 		prom_prop = di_prom_prop_next(ph, din, DI_PROM_PROP_NIL);
1254 		while (prom_prop != DI_PROM_PROP_NIL) {
1255 			if (strcmp("slot-names", di_prom_prop_name(prom_prop))
1256 			    == 0) {
1257 				rval = di_prom_prop_lookup_ints(ph,
1258 				    din, di_prom_prop_name(prom_prop), &intp);
1259 				slotarg->slt_name_src = PROM_SLT_NAME;
1260 
1261 				return (fixup_slotname(rval, intp, slotarg));
1262 			}
1263 			prom_prop = di_prom_prop_next(ph, din, prom_prop);
1264 		}
1265 		*slotarg->slotnames[slotarg->minor] = '\0';
1266 		return (DI_WALK_TERMINATE);
1267 	} else
1268 		return (DI_WALK_CONTINUE);
1269 }
1270 
1271 static int
find_physical_slot_names(const char * devcomp,struct searcharg * slotarg)1272 find_physical_slot_names(const char *devcomp, struct searcharg *slotarg)
1273 {
1274 	di_node_t root_node;
1275 
1276 	DBG(1, ("find_physical_slot_names\n"));
1277 
1278 	if ((root_node = di_init("/", DINFOCPYALL|DINFOPATH)) == DI_NODE_NIL) {
1279 		DBG(1, ("di_init() failed\n"));
1280 		return (-1);
1281 	}
1282 
1283 	slotarg->devpath = (char *)devcomp;
1284 
1285 	if ((slotarg->promp = di_prom_init()) == DI_PROM_HANDLE_NIL) {
1286 		DBG(1, ("di_prom_init() failed\n"));
1287 		di_fini(root_node);
1288 		return (-1);
1289 	}
1290 
1291 	(void) di_walk_minor(root_node, "ddi_ctl:attachment_point:pci",
1292 	    0, (void *)slotarg, find_slotname);
1293 
1294 	di_prom_fini(slotarg->promp);
1295 	di_fini(root_node);
1296 	if (slotarg->slotnames[0] != NULL)
1297 		return (0);
1298 	else
1299 		return (-1);
1300 }
1301 
1302 static void
get_type(hpc_board_type_t boardtype,hpc_card_info_t cardinfo,char * buf)1303 get_type(hpc_board_type_t boardtype, hpc_card_info_t cardinfo, char *buf)
1304 {
1305 	int i;
1306 
1307 	DBG(1, ("class: %i\n", cardinfo.base_class));
1308 	DBG(1, ("subclass: %i\n", cardinfo.sub_class));
1309 
1310 	if (cardinfo.base_class == PCI_CLASS_NONE) {
1311 		TPCT("unknown");
1312 		return;
1313 	}
1314 
1315 	for (i = 0; i < class_pci_items; i++) {
1316 		if ((cardinfo.base_class == class_pci[i].base_class) &&
1317 		    (cardinfo.sub_class == class_pci[i].sub_class) &&
1318 		    (cardinfo.prog_class == class_pci[i].prog_class)) {
1319 			TPCT(class_pci[i].short_desc);
1320 			break;
1321 		}
1322 	}
1323 
1324 	if (i == class_pci_items)
1325 		TPCT("unknown");
1326 
1327 	TPCT("/");
1328 	switch (boardtype) {
1329 	case HPC_BOARD_PCI_HOTPLUG:
1330 	case HPC_BOARD_CPCI_NON_HS:
1331 	case HPC_BOARD_CPCI_BASIC_HS:
1332 	case HPC_BOARD_CPCI_FULL_HS:
1333 	case HPC_BOARD_CPCI_HS:
1334 		TPCT(board_strs[boardtype]);
1335 		break;
1336 	case HPC_BOARD_UNKNOWN:
1337 	default:
1338 		TPCT(board_strs[HPC_BOARD_UNKNOWN]);
1339 	}
1340 }
1341 
1342 /*
1343  * call-back function for di_devlink_walk
1344  * if the link lives in /dev/cfg copy its name
1345  */
1346 static int
found_devlink(di_devlink_t link,void * ap_log_id)1347 found_devlink(di_devlink_t link, void *ap_log_id)
1348 {
1349 	if (strncmp("/dev/cfg/", di_devlink_path(link), 9) == 0) {
1350 		/* copy everything but /dev/cfg/ */
1351 		(void) strcpy((char *)ap_log_id, di_devlink_path(link) + 9);
1352 		DBG(1, ("found_devlink: %s\n", (char *)ap_log_id));
1353 		return (DI_WALK_TERMINATE);
1354 	}
1355 	return (DI_WALK_CONTINUE);
1356 }
1357 
1358 /*
1359  * Walk throught the cached /dev link tree looking for links to the ap
1360  * if none are found return an error
1361  */
1362 static cfga_err_t
check_devlinks(char * ap_log_id,const char * ap_id)1363 check_devlinks(char *ap_log_id, const char *ap_id)
1364 {
1365 	di_devlink_handle_t hdl;
1366 
1367 	DBG(1, ("check_devlinks: %s\n", ap_id));
1368 
1369 	hdl = di_devlink_init(NULL, 0);
1370 
1371 	if (strncmp("/devices/", ap_id, 9) == 0) {
1372 		/* ap_id is a valid minor_path with /devices prepended */
1373 		(void) di_devlink_walk(hdl, NULL, ap_id + 8, DI_PRIMARY_LINK,
1374 		    (void *)ap_log_id, found_devlink);
1375 	} else {
1376 		DBG(1, ("check_devlinks: invalid ap_id: %s\n", ap_id));
1377 		return (CFGA_ERROR);
1378 	}
1379 
1380 	(void) di_devlink_fini(&hdl);
1381 
1382 	if (ap_log_id[0] != '\0')
1383 		return (CFGA_OK);
1384 	else
1385 		return (CFGA_ERROR);
1386 }
1387 
1388 /*
1389  * most of this is needed to compensate for
1390  * differences between various platforms
1391  */
1392 static cfga_err_t
fix_ap_name(char * ap_log_id,const char * ap_id,char * slot_name,char ** errstring)1393 fix_ap_name(char *ap_log_id, const char *ap_id, char *slot_name,
1394     char **errstring)
1395 {
1396 	char *buf;
1397 	char *tmp;
1398 	char *ptr;
1399 
1400 	di_node_t ap_node;
1401 
1402 	ap_log_id[0] = '\0';
1403 
1404 	if (check_devlinks(ap_log_id, ap_id) == CFGA_OK)
1405 		return (CFGA_OK);
1406 
1407 	DBG(1, ("fix_ap_name: %s\n", ap_id));
1408 
1409 	if ((buf = malloc(strlen(ap_id) + 1)) == NULL) {
1410 		DBG(1, ("malloc failed\n"));
1411 		return (CFGA_ERROR);
1412 	}
1413 	(void) strcpy(buf, ap_id);
1414 	tmp = buf + sizeof ("/devices") - 1;
1415 
1416 	ptr = strchr(tmp, ':');
1417 	ptr[0] = '\0';
1418 
1419 	DBG(1, ("fix_ap_name: %s\n", tmp));
1420 
1421 	ap_node = di_init(tmp, DINFOMINOR);
1422 	if (ap_node == DI_NODE_NIL) {
1423 		cfga_err(errstring, "di_init ", 0);
1424 		DBG(1, ("fix_ap_name: failed to snapshot node\n"));
1425 		return (CFGA_ERROR);
1426 	}
1427 
1428 	(void) snprintf(ap_log_id, strlen(ap_id) + 1, "%s%i:%s",
1429 	    di_driver_name(ap_node), di_instance(ap_node), slot_name);
1430 
1431 	DBG(1, ("fix_ap_name: %s\n", ap_log_id));
1432 
1433 	di_fini(ap_node);
1434 
1435 	free(buf);
1436 	return (CFGA_OK);
1437 }
1438 
1439 
1440 static int
findlink_cb(di_devlink_t devlink,void * arg)1441 findlink_cb(di_devlink_t devlink, void *arg)
1442 {
1443 	(*(char **)arg) = strdup(di_devlink_path(devlink));
1444 
1445 	return (DI_WALK_TERMINATE);
1446 }
1447 
1448 /*
1449  * returns an allocated string containing the full path to the devlink for
1450  * <ap_phys_id> in the devlink database; we expect only one devlink per
1451  * <ap_phys_id> so we return the first encountered
1452  */
1453 static char *
findlink(char * ap_phys_id)1454 findlink(char *ap_phys_id)
1455 {
1456 	di_devlink_handle_t hdl;
1457 	char *path = NULL;
1458 
1459 	hdl = di_devlink_init(NULL, 0);
1460 
1461 	if (strncmp("/devices/", ap_phys_id, 9) == 0)
1462 		ap_phys_id += 8;
1463 
1464 	(void) di_devlink_walk(hdl, "^cfg/.+$", ap_phys_id, DI_PRIMARY_LINK,
1465 	    (void *)&path, findlink_cb);
1466 
1467 	(void) di_devlink_fini(&hdl);
1468 	return (path);
1469 }
1470 
1471 
1472 /*
1473  * returns CFGA_OK if it can succesfully retrieve the devlink info associated
1474  * with devlink for <ap_phys_id> which will be returned through <ap_info>
1475  */
1476 cfga_err_t
get_dli(char * dlpath,char * ap_info,int ap_info_sz)1477 get_dli(char *dlpath, char *ap_info, int ap_info_sz)
1478 {
1479 	int fd;
1480 
1481 	fd = di_dli_openr(dlpath);
1482 	if (fd < 0)
1483 		return (CFGA_ERROR);
1484 
1485 	(void) read(fd, ap_info, ap_info_sz);
1486 	ap_info[ap_info_sz - 1] = '\0';
1487 
1488 	di_dli_close(fd);
1489 	return (CFGA_OK);
1490 }
1491 
1492 
1493 /*ARGSUSED*/
1494 cfga_err_t
cfga_list_ext(const char * ap_id,cfga_list_data_t ** cs,int * nlist,const char * options,const char * listopts,char ** errstring,cfga_flags_t flags)1495 cfga_list_ext(const char *ap_id, cfga_list_data_t **cs,
1496     int *nlist, const char *options, const char *listopts, char **errstring,
1497     cfga_flags_t flags)
1498 {
1499 	devctl_hdl_t		dcp;
1500 	struct hpc_control_data	iocdata;
1501 	devctl_ap_state_t	state;
1502 	hpc_board_type_t	boardtype;
1503 	hpc_card_info_t		cardinfo;
1504 	hpc_slot_info_t		slot_info;
1505 	struct	searcharg	slotname_arg;
1506 	int			fd;
1507 	int			rv = CFGA_OK;
1508 	char			*dlpath = NULL;
1509 
1510 	if ((rv = check_options(options)) != CFGA_OK) {
1511 		return (rv);
1512 	}
1513 
1514 	if (errstring != NULL)
1515 		*errstring = NULL;
1516 
1517 	(void) memset(&slot_info, 0, sizeof (hpc_slot_info_t));
1518 
1519 	DBG(1, ("cfga_list_ext:(%s)\n", ap_id));
1520 
1521 	if (cs == NULL || nlist == NULL) {
1522 		rv = CFGA_ERROR;
1523 		return (rv);
1524 	}
1525 
1526 	*nlist = 1;
1527 
1528 	if ((*cs = malloc(sizeof (cfga_list_data_t))) == NULL) {
1529 		cfga_err(errstring, "malloc ", 0);
1530 		DBG(1, ("malloc failed\n"));
1531 		rv = CFGA_ERROR;
1532 		return (rv);
1533 	}
1534 	(void) memset(*cs, 0, sizeof (cfga_list_data_t));
1535 
1536 	if ((dcp = devctl_ap_acquire((char *)ap_id, 0)) == NULL) {
1537 		cfga_err(errstring, CMD_GETSTAT, 0);
1538 		DBG(2, ("cfga_list_ext::(devctl_ap_acquire())\n"));
1539 		rv = CFGA_ERROR;
1540 		return (rv);
1541 	}
1542 
1543 	if (devctl_ap_getstate(dcp, NULL, &state) == -1) {
1544 		cfga_err(errstring, ERR_AP_ERR, ap_id, 0);
1545 		devctl_release((devctl_hdl_t)dcp);
1546 		DBG(2, ("cfga_list_ext::(devctl_ap_getstate())\n"));
1547 		rv = CFGA_ERROR;
1548 		return (rv);
1549 	}
1550 
1551 	switch (state.ap_rstate) {
1552 		case AP_RSTATE_EMPTY:
1553 			(*cs)->ap_r_state = CFGA_STAT_EMPTY;
1554 			DBG(2, ("ap_rstate = CFGA_STAT_EMPTY\n"));
1555 			break;
1556 		case AP_RSTATE_DISCONNECTED:
1557 			(*cs)->ap_r_state = CFGA_STAT_DISCONNECTED;
1558 			DBG(2, ("ap_rstate = CFGA_STAT_DISCONNECTED\n"));
1559 			break;
1560 		case AP_RSTATE_CONNECTED:
1561 			(*cs)->ap_r_state = CFGA_STAT_CONNECTED;
1562 			DBG(2, ("ap_rstate = CFGA_STAT_CONNECTED\n"));
1563 			break;
1564 	default:
1565 		cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
1566 		rv = CFGA_ERROR;
1567 		devctl_release((devctl_hdl_t)dcp);
1568 		return (rv);
1569 	}
1570 
1571 	switch (state.ap_ostate) {
1572 		case AP_OSTATE_CONFIGURED:
1573 			(*cs)->ap_o_state = CFGA_STAT_CONFIGURED;
1574 			DBG(2, ("ap_ostate = CFGA_STAT_CONFIGURED\n"));
1575 			break;
1576 		case AP_OSTATE_UNCONFIGURED:
1577 			(*cs)->ap_o_state = CFGA_STAT_UNCONFIGURED;
1578 			DBG(2, ("ap_ostate = CFGA_STAT_UNCONFIGURED\n"));
1579 			break;
1580 	default:
1581 		cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
1582 		rv = CFGA_ERROR;
1583 		devctl_release((devctl_hdl_t)dcp);
1584 		return (rv);
1585 	}
1586 
1587 	switch (state.ap_condition) {
1588 		case AP_COND_OK:
1589 			(*cs)->ap_cond = CFGA_COND_OK;
1590 			DBG(2, ("ap_cond = CFGA_COND_OK\n"));
1591 			break;
1592 		case AP_COND_FAILING:
1593 			(*cs)->ap_cond = CFGA_COND_FAILING;
1594 			DBG(2, ("ap_cond = CFGA_COND_FAILING\n"));
1595 			break;
1596 		case AP_COND_FAILED:
1597 			(*cs)->ap_cond = CFGA_COND_FAILED;
1598 			DBG(2, ("ap_cond = CFGA_COND_FAILED\n"));
1599 			break;
1600 		case AP_COND_UNUSABLE:
1601 			(*cs)->ap_cond = CFGA_COND_UNUSABLE;
1602 			DBG(2, ("ap_cond = CFGA_COND_UNUSABLE\n"));
1603 			break;
1604 		case AP_COND_UNKNOWN:
1605 			(*cs)->ap_cond = CFGA_COND_UNKNOWN;
1606 			DBG(2, ("ap_cond = CFGA_COND_UNKNOW\n"));
1607 			break;
1608 	default:
1609 		cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
1610 		rv = CFGA_ERROR;
1611 		devctl_release((devctl_hdl_t)dcp);
1612 		return (rv);
1613 	}
1614 	(*cs)->ap_busy = (int)state.ap_in_transition;
1615 
1616 	devctl_release((devctl_hdl_t)dcp);
1617 
1618 	if ((fd = open(ap_id, O_RDWR)) == -1) {
1619 		cfga_err(errstring, ERR_AP_ERR, ap_id, 0);
1620 		(*cs)->ap_status_time = 0;
1621 		boardtype = HPC_BOARD_UNKNOWN;
1622 		cardinfo.base_class = PCI_CLASS_NONE;
1623 		get_logical_name(ap_id, slot_info.pci_slot_name, 0);
1624 		DBG(2, ("open on %s failed\n", ap_id));
1625 		goto cont;
1626 	}
1627 	DBG(1, ("open = ap_id=%s, fd=%d\n", ap_id, fd));
1628 
1629 	(*cs)->ap_status_time = state.ap_last_change;
1630 
1631 	/* need board type and a way to get to hpc_slot_info */
1632 	build_control_data(&iocdata, HPC_CTRL_GET_BOARD_TYPE,
1633 	    (void *)&boardtype);
1634 
1635 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
1636 		boardtype = HPC_BOARD_UNKNOWN;
1637 	}
1638 	DBG(1, ("ioctl boardtype\n"));
1639 
1640 	build_control_data(&iocdata, HPC_CTRL_GET_SLOT_INFO,
1641 	    (void *)&slot_info);
1642 
1643 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
1644 		get_logical_name(ap_id, slot_info.pci_slot_name, 0);
1645 		DBG(1, ("ioctl failed slotinfo: %s\n",
1646 		    slot_info.pci_slot_name));
1647 	} else {
1648 
1649 		/*
1650 		 * the driver will report back things like hpc0_slot0
1651 		 * this needs to be changed to things like pci1:hpc0_slot0
1652 		 */
1653 		rv = fix_ap_name((*cs)->ap_log_id,
1654 		    ap_id, slot_info.pci_slot_name, errstring);
1655 		DBG(1, ("ioctl slotinfo: %s\n", (*cs)->ap_log_id));
1656 	}
1657 
1658 	build_control_data(&iocdata, HPC_CTRL_GET_CARD_INFO,
1659 	    (void *)&cardinfo);
1660 
1661 	if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
1662 		DBG(1, ("ioctl failed\n"));
1663 		cardinfo.base_class = PCI_CLASS_NONE;
1664 	}
1665 
1666 	DBG(1, ("ioctl cardinfo: %d\n", cardinfo.base_class));
1667 	DBG(1, ("ioctl subclass: %d\n", cardinfo.sub_class));
1668 	DBG(1, ("ioctl headertype: %d\n", cardinfo.header_type));
1669 
1670 	(void) close(fd);
1671 
1672 cont:
1673 	(void) strcpy((*cs)->ap_phys_id, ap_id);    /* physical path of AP */
1674 
1675 	dlpath = findlink((*cs)->ap_phys_id);
1676 	if (dlpath != NULL) {
1677 		if (get_dli(dlpath, (*cs)->ap_info,
1678 		    sizeof ((*cs)->ap_info)) != CFGA_OK)
1679 			(*cs)->ap_info[0] = '\0';
1680 		free(dlpath);
1681 	}
1682 
1683 	if ((*cs)->ap_log_id[0] == '\0')
1684 		(void) strcpy((*cs)->ap_log_id, slot_info.pci_slot_name);
1685 
1686 	if ((*cs)->ap_info[0] == '\0') {
1687 		/* slot_names of bus node  */
1688 		if (find_physical_slot_names(ap_id, &slotname_arg) != -1)
1689 			(void) strcpy((*cs)->ap_info,
1690 			    slotname_arg.slotnames[slotname_arg.minor]);
1691 	}
1692 
1693 	/* class_code/subclass/boardtype */
1694 	get_type(boardtype, cardinfo, (*cs)->ap_type);
1695 
1696 	DBG(1, ("cfga_list_ext return success\n"));
1697 	rv = CFGA_OK;
1698 
1699 	return (rv);
1700 }
1701 
1702 /*
1703  * This routine prints a single line of help message
1704  */
1705 static void
cfga_msg(struct cfga_msg * msgp,const char * str)1706 cfga_msg(struct cfga_msg *msgp, const char *str)
1707 {
1708 	DBG(2, ("<%s>", str));
1709 
1710 	if (msgp == NULL || msgp->message_routine == NULL)
1711 		return;
1712 
1713 	(*msgp->message_routine)(msgp->appdata_ptr, str);
1714 	(*msgp->message_routine)(msgp->appdata_ptr, "\n");
1715 }
1716 
1717 static cfga_err_t
check_options(const char * options)1718 check_options(const char *options)
1719 {
1720 	struct cfga_msg *msgp = NULL;
1721 
1722 	if (options) {
1723 		cfga_msg(msgp, dgettext(TEXT_DOMAIN, cfga_strs[HELP_UNKNOWN]));
1724 		cfga_msg(msgp, options);
1725 		return (CFGA_INVAL);
1726 	}
1727 	return (CFGA_OK);
1728 }
1729 
1730 /*ARGSUSED*/
1731 cfga_err_t
cfga_help(struct cfga_msg * msgp,const char * options,cfga_flags_t flags)1732 cfga_help(struct cfga_msg *msgp, const char *options, cfga_flags_t flags)
1733 {
1734 	if (options) {
1735 		cfga_msg(msgp, dgettext(TEXT_DOMAIN, cfga_strs[HELP_UNKNOWN]));
1736 		cfga_msg(msgp, options);
1737 	}
1738 	DBG(1, ("cfga_help\n"));
1739 
1740 	cfga_msg(msgp, dgettext(TEXT_DOMAIN, cfga_strs[HELP_HEADER]));
1741 	cfga_msg(msgp, cfga_strs[HELP_CONFIG]);
1742 	cfga_msg(msgp, cfga_strs[HELP_ENABLE_SLOT]);
1743 	cfga_msg(msgp, cfga_strs[HELP_DISABLE_SLOT]);
1744 	cfga_msg(msgp, cfga_strs[HELP_ENABLE_AUTOCONF]);
1745 	cfga_msg(msgp, cfga_strs[HELP_DISABLE_AUTOCONF]);
1746 	cfga_msg(msgp, cfga_strs[HELP_LED_CNTRL]);
1747 	return (CFGA_OK);
1748 }
1749 
1750 /*
1751  * cfga_err() accepts a variable number of message IDs and constructs
1752  * a corresponding error string which is returned via the errstring argument.
1753  * cfga_err() calls gettext() to internationalize proper messages.
1754  */
1755 static void
cfga_err(char ** errstring,...)1756 cfga_err(char **errstring, ...)
1757 {
1758 	int a;
1759 	int i;
1760 	int n;
1761 	int len;
1762 	int flen;
1763 	char *p;
1764 	char *q;
1765 	char *s[32];
1766 	char *failed;
1767 	va_list ap;
1768 
1769 	/*
1770 	 * If errstring is null it means user in not interested in getting
1771 	 * error status. So we don't do all the work
1772 	 */
1773 	if (errstring == NULL) {
1774 		return;
1775 	}
1776 	va_start(ap, errstring);
1777 
1778 	failed = dgettext(TEXT_DOMAIN, cfga_strs[FAILED]);
1779 	flen = strlen(failed);
1780 
1781 	for (n = len = 0; (a = va_arg(ap, int)) != 0; n++) {
1782 		switch (a) {
1783 		case CMD_GETSTAT:
1784 		case CMD_LIST:
1785 		case CMD_SLOT_CONNECT:
1786 		case CMD_SLOT_DISCONNECT:
1787 		case CMD_SLOT_CONFIGURE:
1788 		case CMD_SLOT_UNCONFIGURE:
1789 			p =  cfga_errstrs(a);
1790 			len += (strlen(p) + flen);
1791 			s[n] = p;
1792 			s[++n] = cfga_strs[FAILED];
1793 
1794 			DBG(2, ("<%s>", p));
1795 			DBG(2, (cfga_strs[FAILED]));
1796 			break;
1797 
1798 		case ERR_CMD_INVAL:
1799 		case ERR_AP_INVAL:
1800 		case ERR_OPT_INVAL:
1801 		case ERR_AP_ERR:
1802 			switch (a) {
1803 			case ERR_CMD_INVAL:
1804 				p = dgettext(TEXT_DOMAIN,
1805 				    cfga_errstrs[ERR_CMD_INVAL]);
1806 				break;
1807 			case ERR_AP_INVAL:
1808 				p = dgettext(TEXT_DOMAIN,
1809 				    cfga_errstrs[ERR_AP_INVAL]);
1810 				break;
1811 			case ERR_OPT_INVAL:
1812 				p = dgettext(TEXT_DOMAIN,
1813 				    cfga_errstrs[ERR_OPT_INVAL]);
1814 				break;
1815 			case ERR_AP_ERR:
1816 				p = dgettext(TEXT_DOMAIN,
1817 				    cfga_errstrs[ERR_AP_ERR]);
1818 				break;
1819 			}
1820 
1821 			if ((q = va_arg(ap, char *)) != NULL) {
1822 				len += (strlen(p) + strlen(q));
1823 				s[n] = p;
1824 				s[++n] = q;
1825 				DBG(2, ("<%s>", p));
1826 				DBG(2, ("<%s>", q));
1827 				break;
1828 			} else {
1829 				len += strlen(p);
1830 				s[n] = p;
1831 
1832 			}
1833 			DBG(2, ("<%s>", p));
1834 			break;
1835 
1836 		default:
1837 			n--;
1838 			break;
1839 		}
1840 	}
1841 
1842 	DBG(2, ("\n"));
1843 	va_end(ap);
1844 
1845 	if ((p = calloc(len + 1, 1)) == NULL)
1846 		return;
1847 
1848 	for (i = 0; i < n; i++) {
1849 		(void) strlcat(p, s[i], len + 1);
1850 		DBG(2, ("i:%d, %s\n", i, s[i]));
1851 	}
1852 
1853 	*errstring = p;
1854 #ifdef	DEBUG
1855 	printf("%s\n", *errstring);
1856 	free(*errstring);
1857 #endif
1858 }
1859 
1860 /*
1861  * cfga_ap_id_cmp -- use default_ap_id_cmp() in libcfgadm
1862  */
1863