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