/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Plugin Library for PCI Hot-Plug Controller
*/
#include <stddef.h>
#include <locale.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <locale.h>
#include <langinfo.h>
#include <time.h>
#include <sys/param.h>
#include <stdarg.h>
#include <libdevinfo.h>
#include <libdevice.h>
#define CFGA_PLUGIN_LIB
#include <config_admin.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/dditypes.h>
#include <sys/devctl.h>
#include <sys/modctl.h>
#include <sys/hotplug/hpctrl.h>
#include <sys/pci.h>
#include <libintl.h>
#include <dirent.h>
#include <limits.h>
#include <sys/mkdev.h>
#include <librcm.h>
#include "../../../../common/pci/pci_strings.h"
extern const struct pci_class_strings_s class_pci[];
extern int class_pci_items;
/*
* Set the version number
*/
int cfga_version = CFGA_HSL_V2;
#ifdef DEBUG
#define PCIHP_DBG 1
#endif
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
/*
* DEBUGING LEVEL
*
* External routines: 1 - 2
* Internal routines: 3 - 4
*/
#ifdef PCIHP_DBG
int pcihp_debug = 1;
#define DBG(level, args) \
{ if (pcihp_debug >= (level)) printf args; }
#define DBG_F(level, args) \
{ if (pcihp_debug >= (level)) fprintf args; }
#else
#define DBG(level, args) /* nothing */
#define DBG_F(level, args) /* nothing */
#endif
#define CMD_ACQUIRE 0
#define CMD_GETSTAT 1
#define CMD_LIST 2
#define CMD_SLOT_CONNECT 3
#define CMD_SLOT_DISCONNECT 4
#define CMD_SLOT_CONFIGURE 5
#define CMD_SLOT_UNCONFIGURE 6
#define CMD_SLOT_INSERT 7
#define CMD_SLOT_REMOVE 8
#define CMD_OPEN 9
#define CMD_FSTAT 10
#define ERR_CMD_INVAL 11
#define ERR_AP_INVAL 12
#define ERR_AP_ERR 13
#define ERR_OPT_INVAL 14
static char *
cfga_errstrs[] = {
/* n */ "acquire ",
/* n */ "get-status ",
/* n */ "list ",
/* n */ "connect ",
/* n */ "disconnect ",
/* n */ "configure ",
/* n */ "unconfigure ",
/* n */ "insert ",
/* n */ "remove ",
/* n */ "open ",
/* n */ "fstat ",
/* y */ "invalid command ",
/* y */ "invalid attachment point ",
/* y */ "invalid transition ",
/* y */ "invalid option ",
NULL
};
#define HELP_HEADER 1
#define HELP_CONFIG 2
#define HELP_ENABLE_SLOT 3
#define HELP_DISABLE_SLOT 4
#define HELP_ENABLE_AUTOCONF 5
#define HELP_DISABLE_AUTOCONF 6
#define HELP_LED_CNTRL 7
#define HELP_UNKNOWN 8
#define SUCCESS 9
#define FAILED 10
#define UNKNOWN 11
#define MAXLINE 256
/* for type string assembly in get_type() */
#define TPCT(s) (void) strlcat(buf, (s), CFGA_TYPE_LEN)
extern int errno;
static void cfga_err(char **errstring, ...);
static cfga_err_t fix_ap_name(char *ap_log_id, const char *ap_id,
char *slot_name, char **errstring);
static void build_control_data(struct hpc_control_data *iocdata, uint_t cmd,
void *retdata);
static cfga_err_t check_options(const char *options);
static void cfga_msg(struct cfga_msg *msgp, const char *str);
static char *findlink(char *ap_phys_id);
static char *
cfga_strs[] = {
NULL,
"\nPCI hotplug specific commands:",
"\t-c [connect|disconnect|configure|unconfigure|insert|remove] "
"ap_id [ap_id...]",
"\t-x enable_slot ap_id [ap_id...]",
"\t-x disable_slot ap_id [ap_id...]",
"\t-x enable_autoconfig ap_id [ap_id...]",
"\t-x disable_autoconfig ap_id [ap_id...]",
"\t-x led[=[fault|power|active|attn],mode=[on|off|blink]] ap_id [ap_id...]",
"\tunknown command or option: ",
"success ",
"failed ",
"unknown",
NULL
};
#define MAX_FORMAT 80
#define ENABLE_SLOT 0
#define DISABLE_SLOT 1
#define ENABLE_AUTOCNF 2
#define DISABLE_AUTOCNF 3
#define LED 4
#define MODE 5
/*
* Board Type
*/
static char *
board_strs[] = {
/* n */ "???", /* HPC_BOARD_UNKNOWN */
/* n */ "hp", /* HPC_BOARD_PCI_HOTPLUG */
/* n */ "nhs", /* HPC_BOARD_CPCI_NON_HS */
/* n */ "bhs", /* HPC_BOARD_CPCI_BASIC_HS */
/* n */ "fhs", /* HPC_BOARD_CPCI_FULL_HS */
/* n */ "hs", /* HPC_BOARD_CPCI_HS */
/* n */ NULL
};
/*
* HW functions
*/
static char *
func_strs[] = {
/* n */ "enable_slot",
/* n */ "disable_slot",
/* n */ "enable_autoconfig",
/* n */ "disable_autoconfig",
/* n */ "led",
/* n */ "mode",
/* n */ NULL
};
/*
* LED strings
*/
static char *
led_strs[] = {
/* n */ "fault", /* HPC_FAULT_LED */
/* n */ "power", /* HPC_POWER_LED */
/* n */ "attn", /* HPC_ATTN_LED */
/* n */ "active", /* HPC_ACTIVE_LED */
/* n */ NULL
};
#define FAULT 0
#define POWER 1
#define ATTN 2
#define ACTIVE 3
static char *
mode_strs[] = {
/* n */ "off", /* HPC_LED_OFF */
/* n */ "on", /* HPC_LED_ON */
/* n */ "blink", /* HPC_LED_BLINK */
/* n */ NULL
};
#define OFF 0
#define ON 1
#define BLINK 2
#define cfga_errstrs(i) cfga_errstrs[(i)]
#define cfga_eid(a, b) (((a) << 8) + (b))
#define MAXDEVS 32
typedef enum {
SOLARIS_SLT_NAME,
PROM_SLT_NAME
} slt_name_src_t;
struct searcharg {
char *devpath;
char slotnames[MAXDEVS][MAXNAMELEN];
int minor;
di_prom_handle_t promp;
slt_name_src_t slt_name_src;
};
static void *private_check;
static int
get_occupants(const char *ap_id, hpc_occupant_info_t *occupant)
{
int rv;
int fd;
di_node_t ap_node;
char *prop_data;
char *tmp;
char *ptr;
struct stat statbuf;
dev_t devt;
if ((fd = open(ap_id, O_RDWR)) == -1) {
DBG(2, ("open = ap_id%s, fd%d\n", ap_id, fd));
DBG_F(2, (stderr, "open on %s failed\n", ap_id));
return (CFGA_ERROR);
}
if (fstat(fd, &statbuf) == -1) {
DBG(1, ("stat failed: %i\n", errno));
(void) close(fd);
return (CFGA_ERROR);
}
(void) close(fd);
devt = statbuf.st_rdev;
tmp = (char *)(ap_id + sizeof ("/devices") - 1);
if ((ptr = strrchr(tmp, ':')) != NULL)
*ptr = '\0';
ap_node = di_init(tmp, DINFOPROP | DINFOMINOR);
if (ap_node == DI_NODE_NIL) {
DBG(1, ("dead %i\n", errno));
return (CFGA_ERROR);
}
#ifdef PCIHP_DBG
ptr = di_devfs_path(ap_node);
DBG(1, ("get_occupants: %s\n", ptr));
di_devfs_path_free(ptr);
#endif
if ((rv = di_prop_lookup_strings(devt, ap_node, "pci-occupant",
&prop_data)) == -1) {
DBG(1, ("get_occupants: prop_lookup failed: %i\n", errno));
di_fini(ap_node);
return (CFGA_ERROR);
}
if (prop_data && (strcmp(prop_data, "") == 0)) {
di_fini(ap_node);
occupant->i = 0;
occupant->id[0] = NULL;
return (CFGA_OK);
}
DBG(1, ("get_occupants: %i devices found\n", rv));
for (occupant->i = 0; occupant->i < rv; occupant->i++) {
if (occupant->i >= (HPC_MAX_OCCUPANTS - 1)) {
occupant->i--;
break;
}
occupant->id[occupant->i] = (char *)malloc(
strlen(prop_data) + sizeof ("/devices"));
(void) snprintf(occupant->id[occupant->i], strlen(prop_data) +
sizeof ("/devices"), "/devices%s", prop_data);
DBG(1, ("%s\n", occupant->id[occupant->i]));
prop_data += strlen(prop_data) + 1;
}
di_fini(ap_node);
occupant->id[occupant->i] = NULL;
return (CFGA_OK);
}
/*
* let rcm know that the device has indeed been removed and clean
* up rcm data
*/
static void
confirm_rcm(hpc_occupant_info_t *occupant, rcm_handle_t *rhandle)
{
DBG(1, ("confirm_rcm\n"));
if (occupant->i == 0) /* nothing was found to ask rcm about */
return;
(void) rcm_notify_remove_list(rhandle, occupant->id, 0, NULL);
(void) rcm_free_handle(rhandle);
for (; occupant->i >= 0; occupant->i--)
free(occupant->id[occupant->i]);
}
static void
fail_rcm(hpc_occupant_info_t *occupant, rcm_handle_t *rhandle)
{
DBG(1, ("fail_rcm\n"));
if (occupant->i == 0) /* nothing was found to ask rcm about */
return;
(void) rcm_notify_online_list(rhandle, occupant->id, 0, NULL);
(void) rcm_free_handle(rhandle);
for (; occupant->i >= 0; occupant->i--)
free(occupant->id[occupant->i]);
}
/*
* copied from scsi_rcm_info_table
*
* Takes an opaque rcm_info_t pointer and a character pointer, and appends
* the rcm_info_t data in the form of a table to the given character pointer.
*/
static void
pci_rcm_info_table(rcm_info_t *rinfo, char **table)
{
int i;
size_t w;
size_t width = 0;
size_t w_rsrc = 0;
size_t w_info = 0;
size_t table_size = 0;
uint_t tuples = 0;
rcm_info_tuple_t *tuple = NULL;
char *rsrc;
char *info;
char *newtable;
static char format[MAX_FORMAT];
const char *infostr;
/* Protect against invalid arguments */
if (rinfo == NULL || table == NULL)
return;
/* Set localized table header strings */
rsrc = dgettext(TEXT_DOMAIN, "Resource");
info = dgettext(TEXT_DOMAIN, "Information");
/* A first pass, to size up the RCM information */
while (tuple = rcm_info_next(rinfo, tuple)) {
if ((infostr = rcm_info_info(tuple)) != NULL) {
tuples++;
if ((w = strlen(rcm_info_rsrc(tuple))) > w_rsrc)
w_rsrc = w;
if ((w = strlen(infostr)) > w_info)
w_info = w;
}
}
/* If nothing was sized up above, stop early */
if (tuples == 0)
return;
/* Adjust column widths for column headings */
if ((w = strlen(rsrc)) > w_rsrc)
w_rsrc = w;
else if ((w_rsrc - w) % 2)
w_rsrc++;
if ((w = strlen(info)) > w_info)
w_info = w;
else if ((w_info - w) % 2)
w_info++;
/*
* Compute the total line width of each line,
* accounting for intercolumn spacing.
*/
width = w_info + w_rsrc + 4;
/* Allocate space for the table */
table_size = (2 + tuples) * (width + 1) + 2;
if (*table == NULL) {
/* zero fill for the strcat() call below */
*table = calloc(table_size, sizeof (char));
if (*table == NULL)
return;
} else {
newtable = realloc(*table, strlen(*table) + table_size);
if (newtable == NULL)
return;
else
*table = newtable;
}
/* Place a table header into the string */
/* The resource header */
(void) strcat(*table, "\n");
w = strlen(rsrc);
for (i = 0; i < ((w_rsrc - w) / 2); i++)
(void) strcat(*table, " ");
(void) strcat(*table, rsrc);
for (i = 0; i < ((w_rsrc - w) / 2); i++)
(void) strcat(*table, " ");
/* The information header */
(void) strcat(*table, " ");
w = strlen(info);
for (i = 0; i < ((w_info - w) / 2); i++)
(void) strcat(*table, " ");
(void) strcat(*table, info);
for (i = 0; i < ((w_info - w) / 2); i++)
(void) strcat(*table, " ");
/* Underline the headers */
(void) strcat(*table, "\n");
for (i = 0; i < w_rsrc; i++)
(void) strcat(*table, "-");
(void) strcat(*table, " ");
for (i = 0; i < w_info; i++)
(void) strcat(*table, "-");
/* Construct the format string */
(void) snprintf(format, MAX_FORMAT, "%%-%ds %%-%ds",
(int)w_rsrc, (int)w_info);
/* Add the tuples to the table string */
tuple = NULL;
while ((tuple = rcm_info_next(rinfo, tuple)) != NULL) {
if ((infostr = rcm_info_info(tuple)) != NULL) {
(void) strcat(*table, "\n");
(void) sprintf(&((*table)[strlen(*table)]),
format, rcm_info_rsrc(tuple),
infostr);
}
}
}
/*
* Figure out what device is about to be unconfigured or disconnected
* and make sure rcm is ok with it.
* hangs on to a list of handles so they can then be confirmed or denied
* if either getting the occupant list or talking to rcm fails
* return CFGA_ERROR so that things can go on without rcm
*/
static int
check_rcm(const char *ap_id, hpc_occupant_info_t *occupant,
rcm_handle_t **rhandlep, char **errstring, cfga_flags_t flags)
{
int rv;
rcm_info_t *rinfo;
rcm_handle_t *rhandle;
uint_t rcmflags;
if (get_occupants(ap_id, occupant) != 0) {
DBG(1, ("check_rcm: failed to get occupants\n"));
return (CFGA_ERROR);
}
if (occupant->i == 0) {
DBG(1, ("check_rcm: no drivers attaching to occupants\n"));
return (CFGA_OK);
}
if (rcm_alloc_handle(NULL, 0, NULL, &rhandle)
!= RCM_SUCCESS) {
DBG(1, ("check_rcm: blocked by rcm failure\n"));
return (CFGA_ERROR);
}
rcmflags = (flags & CFGA_FLAG_FORCE) ? RCM_FORCE : 0;
rv = rcm_request_offline_list(rhandle, occupant->id, rcmflags, &rinfo);
if (rv == RCM_FAILURE) {
DBG(1, ("check_rcm: blocked by rcm failure 2\n"));
pci_rcm_info_table(rinfo, errstring);
rcm_free_info(rinfo);
fail_rcm(occupant, rhandle);
return (CFGA_BUSY);
}
if (rv == RCM_CONFLICT) {
DBG(1, ("check_rcm: blocked by %i\n",
rcm_info_pid(rinfo)));
pci_rcm_info_table(rinfo, errstring);
rcm_free_info(rinfo);
(void) rcm_free_handle(rhandle);
for (; occupant->i >= 0; occupant->i--)
free(occupant->id[occupant->i]);
return (CFGA_BUSY);
}
rcm_free_info(rinfo);
*rhandlep = rhandle;
/* else */
return (CFGA_OK);
}
/*
* Transitional Diagram:
*
* empty unconfigure
* (remove) ^| (physically insert card)
* |V
* disconnect configure
* "-c DISCONNECT" ^| "-c CONNECT"
* |V "-c CONFIGURE"
* connect unconfigure -> connect configure
* <-
* "-c UNCONFIGURE"
*
*/
/*ARGSUSED*/
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)
{
int rv;
devctl_hdl_t dcp;
devctl_ap_state_t state;
ap_rstate_t rs;
ap_ostate_t os;
hpc_occupant_info_t occupants;
rcm_handle_t *rhandle;
if ((rv = check_options(options)) != CFGA_OK) {
return (rv);
}
if (errstring != NULL)
*errstring = NULL;
rv = CFGA_OK;
DBG(1, ("cfga_change_state:(%s)\n", ap_id));
if ((dcp = devctl_ap_acquire((char *)ap_id, 0)) == NULL) {
if (rv == EBUSY) {
cfga_err(errstring, CMD_ACQUIRE, ap_id, 0);
DBG(1, ("cfga_change_state: device is busy\n"));
rv = CFGA_BUSY;
} else
rv = CFGA_ERROR;
return (rv);
}
if (devctl_ap_getstate(dcp, NULL, &state) == -1) {
DBG(2, ("cfga_change_state: devctl ap getstate failed\n"));
cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
devctl_release((devctl_hdl_t)dcp);
if (rv == EBUSY)
rv = CFGA_BUSY;
else
rv = CFGA_ERROR;
return (rv);
}
rs = state.ap_rstate;
os = state.ap_ostate;
DBG(1, ("cfga_change_state: rs is %d\n", state.ap_rstate));
DBG(1, ("cfga_change_state: os is %d\n", state.ap_ostate));
switch (state_change_cmd) {
case CFGA_CMD_CONNECT:
if ((rs == AP_RSTATE_EMPTY) ||
(rs == AP_RSTATE_CONNECTED) ||
(os == AP_OSTATE_CONFIGURED)) {
cfga_err(errstring, ERR_AP_ERR, 0);
rv = CFGA_INVAL;
} else {
/* Lets connect the slot */
if (devctl_ap_connect(dcp, NULL) == -1) {
rv = CFGA_ERROR;
cfga_err(errstring,
CMD_SLOT_CONNECT, 0);
}
}
break;
case CFGA_CMD_DISCONNECT:
DBG(1, ("disconnect\n"));
if (os == AP_OSTATE_CONFIGURED) {
if ((rv = check_rcm(ap_id, &occupants, &rhandle,
errstring, flags)) == CFGA_BUSY) {
break;
} else if (rv == CFGA_OK) {
if (devctl_ap_unconfigure(dcp, NULL) == -1) {
if (errno == EBUSY)
rv = CFGA_BUSY;
else
rv = CFGA_ERROR;
cfga_err(errstring,
CMD_SLOT_DISCONNECT, 0);
fail_rcm(&occupants, rhandle);
break;
} else {
confirm_rcm(&occupants, rhandle);
}
} else { /* rv == CFGA_ERROR */
if (devctl_ap_unconfigure(dcp, NULL) == -1) {
if (errno == EBUSY)
rv = CFGA_BUSY;
else
rv = CFGA_ERROR;
break;
} else {
rv = CFGA_OK;
}
}
}
if (rs == AP_RSTATE_CONNECTED) {
if (devctl_ap_disconnect(dcp, NULL) == -1) {
rv = CFGA_ERROR;
cfga_err(errstring, CMD_SLOT_DISCONNECT, 0);
break;
}
} else {
cfga_err(errstring, ERR_AP_ERR, 0);
rv = CFGA_INVAL;
}
break;
case CFGA_CMD_CONFIGURE:
if (rs == AP_RSTATE_DISCONNECTED) {
if (devctl_ap_connect(dcp, NULL) == -1) {
rv = CFGA_ERROR;
cfga_err(errstring, CMD_SLOT_CONNECT, 0);
break;
}
}
/*
* for multi-func device we allow multiple
* configure on the same slot because one
* func can be configured and other one won't
*/
if (devctl_ap_configure(dcp, NULL) == -1) {
rv = CFGA_ERROR;
cfga_err(errstring, CMD_SLOT_CONFIGURE, 0);
if ((rs == AP_RSTATE_DISCONNECTED) &&
(devctl_ap_disconnect(dcp, NULL)
== -1)) {
rv = CFGA_ERROR;
cfga_err(errstring,
CMD_SLOT_CONFIGURE, 0);
}
break;
}
break;
case CFGA_CMD_UNCONFIGURE:
DBG(1, ("unconfigure\n"));
if (os == AP_OSTATE_CONFIGURED) {
if ((rv = check_rcm(ap_id, &occupants, &rhandle,
errstring, flags)) == CFGA_BUSY) {
break;
} else if (rv == CFGA_OK) {
if (devctl_ap_unconfigure(dcp, NULL) == -1) {
if (errno == EBUSY)
rv = CFGA_BUSY;
else {
if (errno == ENOTSUP)
rv = CFGA_OPNOTSUPP;
else
rv = CFGA_ERROR;
}
cfga_err(errstring,
CMD_SLOT_UNCONFIGURE, 0);
fail_rcm(&occupants, rhandle);
} else {
confirm_rcm(&occupants, rhandle);
}
} else { /* rv == CFGA_ERROR */
if (devctl_ap_unconfigure(dcp, NULL) == -1) {
if (errno == EBUSY)
rv = CFGA_BUSY;
else {
if (errno == ENOTSUP)
rv = CFGA_OPNOTSUPP;
else
rv = CFGA_ERROR;
}
cfga_err(errstring,
CMD_SLOT_UNCONFIGURE, 0);
} else {
rv = CFGA_OK;
}
}
} else {
cfga_err(errstring, ERR_AP_ERR, 0);
rv = CFGA_INVAL;
}
DBG(1, ("uncofigure rv:(%i)\n", rv));
break;
case CFGA_CMD_LOAD:
if ((os == AP_OSTATE_UNCONFIGURED) &&
(rs == AP_RSTATE_DISCONNECTED)) {
if (devctl_ap_insert(dcp, NULL) == -1) {
rv = CFGA_ERROR;
cfga_err(errstring, CMD_SLOT_INSERT, 0);
}
} else {
cfga_err(errstring, ERR_AP_ERR, 0);
rv = CFGA_INVAL;
}
break;
case CFGA_CMD_UNLOAD:
if ((os == AP_OSTATE_UNCONFIGURED) &&
(rs == AP_RSTATE_DISCONNECTED)) {
if (devctl_ap_remove(dcp, NULL) == -1) {
rv = CFGA_ERROR;
cfga_err(errstring, CMD_SLOT_REMOVE, 0);
}
} else {
cfga_err(errstring, ERR_AP_ERR, 0);
rv = CFGA_INVAL;
}
break;
default:
rv = CFGA_OPNOTSUPP;
break;
}
devctl_release((devctl_hdl_t)dcp);
return (rv);
}
/*
* Building iocdatat to pass it to nexus
*
* iocdata->cmd == HPC_CTRL_ENABLE_SLOT/HPC_CTRL_DISABLE_SLOT
* HPC_CTRL_ENABLE_AUTOCFG/HPC_CTRL_DISABLE_AUTOCFG
* HPC_CTRL_GET_LED_STATE/HPC_CTRL_SET_LED_STATE
* HPC_CTRL_GET_SLOT_STATE/HPC_CTRL_GET_SLOT_INFO
* HPC_CTRL_DEV_CONFIGURE/HPC_CTRL_DEV_UNCONFIGURE
* HPC_CTRL_GET_BOARD_TYPE
*
*/
static void
build_control_data(struct hpc_control_data *iocdata, uint_t cmd,
void *retdata)
{
iocdata->cmd = cmd;
iocdata->data = retdata;
}
/*
* building logical name from ap_id
*/
/*ARGSUSED2*/
static void
get_logical_name(const char *ap_id, char *buf, dev_t rdev)
{
char *bufptr, *bufptr2, *pci, *apid;
DBG(1, ("get_logical_name: %s\n", ap_id));
if ((apid = malloc(MAXPATHLEN)) == NULL) {
DBG(1, ("malloc failed\n"));
return;
}
(void) memset(apid, 0, MAXPATHLEN);
(void) strncpy(apid, ap_id, strlen(ap_id));
/* needs to look for last /, not first */
bufptr = strrchr(apid, '/');
bufptr2 = strrchr(apid, ':');
pci = ++bufptr;
bufptr = strchr(pci, ',');
if (bufptr != NULL) {
*bufptr = '\0';
}
bufptr = strchr(pci, '@');
if (bufptr != NULL) {
*bufptr = '\0';
bufptr++;
}
DBG(1, ("%s\n%s\n%s\n", pci, bufptr, bufptr2));
(void) strcat(buf, pci);
(void) strcat(buf, bufptr);
(void) strcat(buf, bufptr2);
free(apid);
}
static cfga_err_t
prt_led_mode(const char *ap_id, int repeat, char **errstring,
struct cfga_msg *msgp)
{
hpc_led_info_t power_led_info = {HPC_POWER_LED, 0};
hpc_led_info_t fault_led_info = {HPC_FAULT_LED, 0};
hpc_led_info_t attn_led_info = {HPC_ATTN_LED, 0};
hpc_led_info_t active_led_info = {HPC_ACTIVE_LED, 0};
struct hpc_control_data iocdata;
struct stat statbuf;
char *buff;
int fd;
hpc_slot_info_t slot_info;
char *cp, line[MAXLINE];
int len = MAXLINE;
DBG(1, ("prt_led_mod function\n"));
if (!repeat)
cfga_msg(msgp, "Ap_Id\t\t\tLed");
if ((fd = open(ap_id, O_RDWR)) == -1) {
DBG(2, ("open = ap_id%s, fd%d\n", ap_id, fd));
DBG_F(2, (stderr, "open on %s failed\n", ap_id));
cfga_err(errstring, CMD_OPEN, ap_id, 0);
return (CFGA_ERROR);
}
if (fstat(fd, &statbuf) == -1) {
DBG(2, ("fstat = ap_id%s, fd%d\n", ap_id, fd));
DBG_F(2, (stderr, "fstat on %s failed\n", ap_id));
cfga_err(errstring, CMD_FSTAT, ap_id, 0);
return (CFGA_ERROR);
}
if ((buff = malloc(MAXPATHLEN)) == NULL) {
cfga_err(errstring, "malloc ", 0);
return (CFGA_ERROR);
}
(void) memset(buff, 0, MAXPATHLEN);
DBG(1, ("ioctl boardtype\n"));
build_control_data(&iocdata, HPC_CTRL_GET_SLOT_INFO,
(void *)&slot_info);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
get_logical_name(ap_id, slot_info.pci_slot_name, 0);
DBG(1, ("ioctl failed slotinfo: %s\n",
slot_info.pci_slot_name));
} else {
/*
* the driver will report back things like hpc0_slot0
* this needs to be changed to things like pci1:hpc0_slot0
*/
if (fix_ap_name(buff, ap_id, slot_info.pci_slot_name,
errstring) != CFGA_OK) {
free(buff);
(void) close(fd);
return (CFGA_ERROR);
}
DBG(1, ("ioctl slotinfo: %s\n", buff));
}
cp = line;
(void) snprintf(cp, len, "%s\t\t", buff);
len -= strlen(cp);
cp += strlen(cp);
free(buff);
build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &power_led_info);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
(void) snprintf(cp, len, "%s=%s,",
led_strs[power_led_info.led], cfga_strs[UNKNOWN]);
len -= strlen(cp);
cp += strlen(cp);
} else {
(void) snprintf(cp, len, "%s=%s,", led_strs[power_led_info.led],
mode_strs[power_led_info.state]);
len -= strlen(cp);
cp += strlen(cp);
}
DBG(1, ("%s:%d\n", led_strs[power_led_info.led], power_led_info.state));
build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &fault_led_info);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
(void) snprintf(cp, len, "%s=%s,",
led_strs[fault_led_info.led], cfga_strs[UNKNOWN]);
len -= strlen(cp);
cp += strlen(cp);
} else {
(void) snprintf(cp, len, "%s=%s,",
led_strs[fault_led_info.led],
mode_strs[fault_led_info.state]);
len -= strlen(cp);
cp += strlen(cp);
}
DBG(1, ("%s:%d\n", led_strs[fault_led_info.led], fault_led_info.state));
build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &attn_led_info);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
(void) snprintf(cp, len, "%s=%s,",
led_strs[attn_led_info.led], cfga_strs[UNKNOWN]);
len -= strlen(cp);
cp += strlen(cp);
} else {
(void) snprintf(cp, len, "%s=%s,",
led_strs[attn_led_info.led],
mode_strs[attn_led_info.state]);
len -= strlen(cp);
cp += strlen(cp);
}
DBG(1, ("%s:%d\n", led_strs[attn_led_info.led], attn_led_info.state));
build_control_data(&iocdata, HPC_CTRL_GET_LED_STATE, &active_led_info);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
(void) snprintf(cp, len, "%s=%s", led_strs[active_led_info.led],
cfga_strs[UNKNOWN]);
} else {
(void) snprintf(cp, len, "%s=%s",
led_strs[active_led_info.led],
mode_strs[active_led_info.state]);
}
cfga_msg(msgp, line); /* print the message */
DBG(1, ("%s:%d\n", led_strs[active_led_info.led],
active_led_info.state));
(void) close(fd);
return (CFGA_OK);
}
/*ARGSUSED*/
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)
{
char *str;
int len, fd, i = 0, repeat = 0;
char buf[MAXNAMELEN];
char ptr;
hpc_led_info_t led_info;
struct hpc_control_data iocdata;
cfga_err_t rv;
DBG(1, ("cfgadm_private_func: ap_id:%s\n", ap_id));
DBG(2, (" options: %s\n", (options == NULL)?"null":options));
DBG(2, (" confp: %x\n", confp));
DBG(2, (" cfga_msg: %x\n", cfga_msg));
DBG(2, (" flag: %d\n", flags));
if ((rv = check_options(options)) != CFGA_OK) {
return (rv);
}
if (private_check == confp)
repeat = 1;
else
private_check = (void*)confp;
/* XXX change const 6 to func_str[i] != NULL */
for (i = 0, str = func_strs[i], len = strlen(str); i < 6; i++) {
str = func_strs[i];
len = strlen(str);
if (strncmp(function, str, len) == 0)
break;
}
switch (i) {
case ENABLE_SLOT:
build_control_data(&iocdata,
HPC_CTRL_ENABLE_SLOT, 0);
break;
case DISABLE_SLOT:
build_control_data(&iocdata,
HPC_CTRL_DISABLE_SLOT, 0);
break;
case ENABLE_AUTOCNF:
build_control_data(&iocdata,
HPC_CTRL_ENABLE_AUTOCFG, 0);
break;
case DISABLE_AUTOCNF:
build_control_data(&iocdata,
HPC_CTRL_DISABLE_AUTOCFG, 0);
break;
case LED:
/* set mode */
ptr = function[len++];
if (ptr == '=') {
str = (char *)function;
for (str = (str+len++), i = 0; *str != ',';
i++, str++) {
if (i == (MAXNAMELEN - 1))
break;
buf[i] = *str;
DBG_F(2, (stdout, "%c\n", buf[i]));
}
buf[i] = '\0'; str++;
DBG(2, ("buf = %s\n", buf));
/* ACTIVE=3,ATTN=2,POWER=1,FAULT=0 */
if (strcmp(buf, led_strs[POWER]) == 0)
led_info.led = HPC_POWER_LED;
else if (strcmp(buf, led_strs[FAULT]) == 0)
led_info.led = HPC_FAULT_LED;
else if (strcmp(buf, led_strs[ATTN]) == 0)
led_info.led = HPC_ATTN_LED;
else if (strcmp(buf, led_strs[ACTIVE]) == 0)
led_info.led = HPC_ACTIVE_LED;
else return (CFGA_INVAL);
len = strlen(func_strs[MODE]);
if ((strncmp(str, func_strs[MODE], len) == 0) &&
(*(str+(len)) == '=')) {
for (str = (str+(++len)), i = 0;
*str != NULL; i++, str++) {
buf[i] = *str;
}
}
buf[i] = '\0';
DBG(2, ("buf_mode= %s\n", buf));
/* ON = 1, OFF = 0 */
if (strcmp(buf, mode_strs[ON]) == 0)
led_info.state = HPC_LED_ON;
else if (strcmp(buf, mode_strs[OFF]) == 0)
led_info.state = HPC_LED_OFF;
else if (strcmp(buf, mode_strs[BLINK]) == 0)
led_info.state = HPC_LED_BLINK;
else return (CFGA_INVAL);
/* sendin */
build_control_data(&iocdata,
HPC_CTRL_SET_LED_STATE,
(void *)&led_info);
break;
} else if (ptr == '\0') {
/* print mode */
DBG(1, ("Print mode\n"));
return (prt_led_mode(ap_id, repeat, errstring,
msgp));
}
default:
DBG(1, ("default\n"));
errno = EINVAL;
return (CFGA_INVAL);
}
if ((fd = open(ap_id, O_RDWR)) == -1) {
DBG(1, ("open failed\n"));
return (CFGA_ERROR);
}
DBG(1, ("open = ap_id=%s, fd=%d\n", ap_id, fd));
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
DBG(1, ("ioctl failed\n"));
(void) close(fd);
return (CFGA_ERROR);
}
(void) close(fd);
return (CFGA_OK);
}
/*ARGSUSED*/
cfga_err_t cfga_test(const char *ap_id, const char *options,
struct cfga_msg *msgp, char **errstring, cfga_flags_t flags)
{
cfga_err_t rv;
if (errstring != NULL)
*errstring = NULL;
if ((rv = check_options(options)) != CFGA_OK) {
return (rv);
}
DBG(1, ("cfga_test:(%s)\n", ap_id));
/* will need to implement pci CTRL command */
return (CFGA_NOTSUPP);
}
static int
fixup_slotname(int rval, int *intp, struct searcharg *slotarg)
{
/*
* The slot-names property describes the external labeling of add-in slots.
* This property is an encoded array, an integer followed by a list of
* strings. The return value from di_prop_lookup_ints for slot-names is -1.
* The expected return value should be the number of elements.
* Di_prop_decode_common does not decode encoded data from software,
* such as the solaris device tree, unlike from the prom.
* Di_prop_decode_common takes the size of the encoded data and mods
* it with the size of int. The size of the encoded data for slot-names is 9
* and the size of int is 4, yielding a non zero result. A value of -1 is used
* to indicate that the number of elements can not be determined.
* Di_prop_decode_common can be modified to decode encoded data from the solaris
* device tree.
*/
if ((slotarg->slt_name_src == PROM_SLT_NAME) && (rval == -1)) {
return (DI_WALK_TERMINATE);
} else {
int i;
char *tmptr = (char *)(intp+1);
DBG(1, ("slot-bitmask: %x \n", *intp));
rval = (rval -1) * 4;
for (i = 0; i <= slotarg->minor; i++) {
DBG(2, ("curr slot-name: %s \n", tmptr));
if (i >= MAXDEVS)
return (DI_WALK_TERMINATE);
if ((*intp >> i) & 1) {
/* assign tmptr */
DBG(2, ("slot-name: %s \n", tmptr));
if (i == slotarg->minor)
(void) strcpy(slotarg->slotnames[i],
tmptr);
/* wind tmptr to next \0 */
while (*tmptr != '\0') {
tmptr++;
}
tmptr++;
} else {
/* point at unknown string */
if (i == slotarg->minor)
(void) strcpy(slotarg->slotnames[i],
"unknown");
}
}
}
return (DI_WALK_TERMINATE);
}
static int
find_slotname(di_node_t din, di_minor_t dim, void *arg)
{
struct searcharg *slotarg = (struct searcharg *)arg;
di_prom_handle_t ph = (di_prom_handle_t)slotarg->promp;
di_prom_prop_t prom_prop;
di_prop_t solaris_prop;
int *intp, rval;
char *devname;
char fulldevname[MAXNAMELEN];
slotarg->minor = dim->dev_minor % 256;
DBG(2, ("minor number:(%i)\n", slotarg->minor));
DBG(2, ("hot plug slots found so far:(%i)\n", 0));
if ((devname = di_devfs_path(din)) != NULL) {
(void) snprintf(fulldevname, MAXNAMELEN,
"/devices%s:%s", devname, di_minor_name(dim));
di_devfs_path_free(devname);
}
if (strcmp(fulldevname, slotarg->devpath) == 0) {
/*
* Check the Solaris device tree first
* in the case of a DR operation
*/
solaris_prop = di_prop_hw_next(din, DI_PROP_NIL);
while (solaris_prop != DI_PROP_NIL) {
if (strcmp("slot-names", di_prop_name(solaris_prop))
== 0) {
rval = di_prop_lookup_ints(DDI_DEV_T_ANY,
din, di_prop_name(solaris_prop), &intp);
slotarg->slt_name_src = SOLARIS_SLT_NAME;
return (fixup_slotname(rval, intp, slotarg));
}
solaris_prop = di_prop_hw_next(din, solaris_prop);
}
/*
* Check the prom device tree which is populated at boot.
* If this fails, give up and set the slot name to null.
*/
prom_prop = di_prom_prop_next(ph, din, DI_PROM_PROP_NIL);
while (prom_prop != DI_PROM_PROP_NIL) {
if (strcmp("slot-names", di_prom_prop_name(prom_prop))
== 0) {
rval = di_prom_prop_lookup_ints(ph,
din, di_prom_prop_name(prom_prop), &intp);
slotarg->slt_name_src = PROM_SLT_NAME;
return (fixup_slotname(rval, intp, slotarg));
}
prom_prop = di_prom_prop_next(ph, din, prom_prop);
}
*slotarg->slotnames[slotarg->minor] = '\0';
return (DI_WALK_TERMINATE);
} else
return (DI_WALK_CONTINUE);
}
static int
find_physical_slot_names(const char *devcomp, struct searcharg *slotarg)
{
di_node_t root_node;
DBG(1, ("find_physical_slot_names\n"));
if ((root_node = di_init("/", DINFOCPYALL|DINFOPATH))
== DI_NODE_NIL) {
DBG(1, ("di_init() failed\n"));
return (NULL);
}
slotarg->devpath = (char *)devcomp;
if ((slotarg->promp = di_prom_init()) == DI_PROM_HANDLE_NIL) {
DBG(1, ("di_prom_init() failed\n"));
di_fini(root_node);
return (NULL);
}
(void) di_walk_minor(root_node, "ddi_ctl:attachment_point:pci",
0, (void *)slotarg, find_slotname);
di_prom_fini(slotarg->promp);
di_fini(root_node);
if (slotarg->slotnames[0] != NULL)
return (0);
else
return (-1);
}
static void
get_type(hpc_board_type_t boardtype, hpc_card_info_t cardinfo, char *buf)
{
int i;
DBG(1, ("class: %i\n", cardinfo.base_class));
DBG(1, ("subclass: %i\n", cardinfo.sub_class));
if (cardinfo.base_class == PCI_CLASS_NONE) {
TPCT("unknown");
return;
}
for (i = 0; i < class_pci_items; i++) {
if ((cardinfo.base_class == class_pci[i].base_class) &&
(cardinfo.sub_class == class_pci[i].sub_class) &&
(cardinfo.prog_class == class_pci[i].prog_class)) {
TPCT(class_pci[i].short_desc);
break;
}
}
if (i == class_pci_items)
TPCT("unknown");
TPCT("/");
switch (boardtype) {
case HPC_BOARD_PCI_HOTPLUG:
case HPC_BOARD_CPCI_NON_HS:
case HPC_BOARD_CPCI_BASIC_HS:
case HPC_BOARD_CPCI_FULL_HS:
case HPC_BOARD_CPCI_HS:
TPCT(board_strs[boardtype]);
break;
case HPC_BOARD_UNKNOWN:
default:
TPCT(board_strs[HPC_BOARD_UNKNOWN]);
}
}
/*
* call-back function for di_devlink_walk
* if the link lives in /dev/cfg copy its name
*/
static int
found_devlink(di_devlink_t link, void *ap_log_id)
{
if (strncmp("/dev/cfg/", di_devlink_path(link), 9) == 0) {
/* copy everything but /dev/cfg/ */
(void) strcpy((char *)ap_log_id, di_devlink_path(link) + 9);
DBG(1, ("found_devlink: %s\n", (char *)ap_log_id));
return (DI_WALK_TERMINATE);
}
return (DI_WALK_CONTINUE);
}
/*
* Walk throught the cached /dev link tree looking for links to the ap
* if none are found return an error
*/
static cfga_err_t
check_devlinks(char *ap_log_id, const char *ap_id)
{
di_devlink_handle_t hdl;
DBG(1, ("check_devlinks: %s\n", ap_id));
hdl = di_devlink_init(NULL, 0);
if (strncmp("/devices/", ap_id, 9) == 0) {
/* ap_id is a valid minor_path with /devices prepended */
(void) di_devlink_walk(hdl, NULL, ap_id + 8, DI_PRIMARY_LINK,
(void *)ap_log_id, found_devlink);
} else {
DBG(1, ("check_devlinks: invalid ap_id: %s\n", ap_id));
return (CFGA_ERROR);
}
(void) di_devlink_fini(&hdl);
if (ap_log_id[0] != '\0')
return (CFGA_OK);
else
return (CFGA_ERROR);
}
/*
* most of this is needed to compensate for
* differences between various platforms
*/
static cfga_err_t
fix_ap_name(char *ap_log_id, const char *ap_id, char *slot_name,
char **errstring)
{
char *buf;
char *tmp;
char *ptr;
di_node_t ap_node;
ap_log_id[0] = '\0';
if (check_devlinks(ap_log_id, ap_id) == CFGA_OK)
return (CFGA_OK);
DBG(1, ("fix_ap_name: %s\n", ap_id));
if ((buf = malloc(strlen(ap_id) + 1)) == NULL) {
DBG(1, ("malloc failed\n"));
return (CFGA_ERROR);
}
(void) strcpy(buf, ap_id);
tmp = buf + sizeof ("/devices") - 1;
ptr = strchr(tmp, ':');
ptr[0] = '\0';
DBG(1, ("fix_ap_name: %s\n", tmp));
ap_node = di_init(tmp, DINFOMINOR);
if (ap_node == DI_NODE_NIL) {
cfga_err(errstring, "di_init ", 0);
DBG(1, ("fix_ap_name: failed to snapshot node\n"));
return (CFGA_ERROR);
}
(void) snprintf(ap_log_id, strlen(ap_id) + 1, "%s%i:%s",
di_driver_name(ap_node), di_instance(ap_node), slot_name);
DBG(1, ("fix_ap_name: %s\n", ap_log_id));
di_fini(ap_node);
free(buf);
return (CFGA_OK);
}
static int
findlink_cb(di_devlink_t devlink, void *arg)
{
(*(char **)arg) = strdup(di_devlink_path(devlink));
return (DI_WALK_TERMINATE);
}
/*
* returns an allocated string containing the full path to the devlink for
* <ap_phys_id> in the devlink database; we expect only one devlink per
* <ap_phys_id> so we return the first encountered
*/
static char *
findlink(char *ap_phys_id)
{
di_devlink_handle_t hdl;
char *path = NULL;
hdl = di_devlink_init(NULL, 0);
if (strncmp("/devices/", ap_phys_id, 9) == 0)
ap_phys_id += 8;
(void) di_devlink_walk(hdl, "^cfg/.+$", ap_phys_id, DI_PRIMARY_LINK,
(void *)&path, findlink_cb);
(void) di_devlink_fini(&hdl);
return (path);
}
/*
* returns CFGA_OK if it can succesfully retrieve the devlink info associated
* with devlink for <ap_phys_id> which will be returned through <ap_info>
*/
cfga_err_t
get_dli(char *dlpath, char *ap_info, int ap_info_sz)
{
int fd;
fd = di_dli_openr(dlpath);
if (fd < 0)
return (CFGA_ERROR);
(void) read(fd, ap_info, ap_info_sz);
ap_info[ap_info_sz - 1] = '\0';
di_dli_close(fd);
return (CFGA_OK);
}
/*ARGSUSED*/
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)
{
devctl_hdl_t dcp;
struct hpc_control_data iocdata;
devctl_ap_state_t state;
hpc_board_type_t boardtype;
hpc_card_info_t cardinfo;
hpc_slot_info_t slot_info;
struct searcharg slotname_arg;
int fd;
int rv = CFGA_OK;
char *dlpath = NULL;
if ((rv = check_options(options)) != CFGA_OK) {
return (rv);
}
if (errstring != NULL)
*errstring = NULL;
(void) memset(&slot_info, 0, sizeof (hpc_slot_info_t));
DBG(1, ("cfga_list_ext:(%s)\n", ap_id));
if (cs == NULL || nlist == NULL) {
rv = CFGA_ERROR;
return (rv);
}
*nlist = 1;
if ((*cs = malloc(sizeof (cfga_list_data_t))) == NULL) {
cfga_err(errstring, "malloc ", 0);
DBG(1, ("malloc failed\n"));
rv = CFGA_ERROR;
return (rv);
}
(void) memset(*cs, 0, sizeof (cfga_list_data_t));
if ((dcp = devctl_ap_acquire((char *)ap_id, 0)) == NULL) {
cfga_err(errstring, CMD_GETSTAT, 0);
DBG(2, ("cfga_list_ext::(devctl_ap_acquire())\n"));
rv = CFGA_ERROR;
return (rv);
}
if (devctl_ap_getstate(dcp, NULL, &state) == -1) {
cfga_err(errstring, ERR_AP_ERR, ap_id, 0);
devctl_release((devctl_hdl_t)dcp);
DBG(2, ("cfga_list_ext::(devctl_ap_getstate())\n"));
rv = CFGA_ERROR;
return (rv);
}
switch (state.ap_rstate) {
case AP_RSTATE_EMPTY:
(*cs)->ap_r_state = CFGA_STAT_EMPTY;
DBG(2, ("ap_rstate = CFGA_STAT_EMPTY\n"));
break;
case AP_RSTATE_DISCONNECTED:
(*cs)->ap_r_state = CFGA_STAT_DISCONNECTED;
DBG(2, ("ap_rstate = CFGA_STAT_DISCONNECTED\n"));
break;
case AP_RSTATE_CONNECTED:
(*cs)->ap_r_state = CFGA_STAT_CONNECTED;
DBG(2, ("ap_rstate = CFGA_STAT_CONNECTED\n"));
break;
default:
cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
rv = CFGA_ERROR;
devctl_release((devctl_hdl_t)dcp);
return (rv);
}
switch (state.ap_ostate) {
case AP_OSTATE_CONFIGURED:
(*cs)->ap_o_state = CFGA_STAT_CONFIGURED;
DBG(2, ("ap_ostate = CFGA_STAT_CONFIGURED\n"));
break;
case AP_OSTATE_UNCONFIGURED:
(*cs)->ap_o_state = CFGA_STAT_UNCONFIGURED;
DBG(2, ("ap_ostate = CFGA_STAT_UNCONFIGURED\n"));
break;
default:
cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
rv = CFGA_ERROR;
devctl_release((devctl_hdl_t)dcp);
return (rv);
}
switch (state.ap_condition) {
case AP_COND_OK:
(*cs)->ap_cond = CFGA_COND_OK;
DBG(2, ("ap_cond = CFGA_COND_OK\n"));
break;
case AP_COND_FAILING:
(*cs)->ap_cond = CFGA_COND_FAILING;
DBG(2, ("ap_cond = CFGA_COND_FAILING\n"));
break;
case AP_COND_FAILED:
(*cs)->ap_cond = CFGA_COND_FAILED;
DBG(2, ("ap_cond = CFGA_COND_FAILED\n"));
break;
case AP_COND_UNUSABLE:
(*cs)->ap_cond = CFGA_COND_UNUSABLE;
DBG(2, ("ap_cond = CFGA_COND_UNUSABLE\n"));
break;
case AP_COND_UNKNOWN:
(*cs)->ap_cond = CFGA_COND_UNKNOWN;
DBG(2, ("ap_cond = CFGA_COND_UNKNOW\n"));
break;
default:
cfga_err(errstring, CMD_GETSTAT, ap_id, 0);
rv = CFGA_ERROR;
devctl_release((devctl_hdl_t)dcp);
return (rv);
}
(*cs)->ap_busy = (int)state.ap_in_transition;
devctl_release((devctl_hdl_t)dcp);
if ((fd = open(ap_id, O_RDWR)) == -1) {
cfga_err(errstring, ERR_AP_ERR, ap_id, 0);
(*cs)->ap_status_time = 0;
boardtype = HPC_BOARD_UNKNOWN;
cardinfo.base_class = PCI_CLASS_NONE;
get_logical_name(ap_id, slot_info.pci_slot_name, 0);
DBG(2, ("open on %s failed\n", ap_id));
goto cont;
}
DBG(1, ("open = ap_id=%s, fd=%d\n", ap_id, fd));
(*cs)->ap_status_time = state.ap_last_change;
/* need board type and a way to get to hpc_slot_info */
build_control_data(&iocdata, HPC_CTRL_GET_BOARD_TYPE,
(void *)&boardtype);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
boardtype = HPC_BOARD_UNKNOWN;
}
DBG(1, ("ioctl boardtype\n"));
build_control_data(&iocdata, HPC_CTRL_GET_SLOT_INFO,
(void *)&slot_info);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
get_logical_name(ap_id, slot_info.pci_slot_name, 0);
DBG(1, ("ioctl failed slotinfo: %s\n",
slot_info.pci_slot_name));
} else {
/*
* the driver will report back things like hpc0_slot0
* this needs to be changed to things like pci1:hpc0_slot0
*/
rv = fix_ap_name((*cs)->ap_log_id,
ap_id, slot_info.pci_slot_name, errstring);
DBG(1, ("ioctl slotinfo: %s\n", (*cs)->ap_log_id));
}
build_control_data(&iocdata, HPC_CTRL_GET_CARD_INFO,
(void *)&cardinfo);
if (ioctl(fd, DEVCTL_AP_CONTROL, &iocdata) == -1) {
DBG(1, ("ioctl failed\n"));
cardinfo.base_class = PCI_CLASS_NONE;
}
DBG(1, ("ioctl cardinfo: %d\n", cardinfo.base_class));
DBG(1, ("ioctl subclass: %d\n", cardinfo.sub_class));
DBG(1, ("ioctl headertype: %d\n", cardinfo.header_type));
(void) close(fd);
cont:
(void) strcpy((*cs)->ap_phys_id, ap_id); /* physical path of AP */
dlpath = findlink((*cs)->ap_phys_id);
if (dlpath != NULL) {
if (get_dli(dlpath, (*cs)->ap_info,
sizeof ((*cs)->ap_info)) != CFGA_OK)
(*cs)->ap_info[0] = '\0';
free(dlpath);
}
if ((*cs)->ap_log_id[0] == '\0')
(void) strcpy((*cs)->ap_log_id, slot_info.pci_slot_name);
if ((*cs)->ap_info[0] == '\0') {
/* slot_names of bus node */
if (find_physical_slot_names(ap_id, &slotname_arg) != -1)
(void) strcpy((*cs)->ap_info,
slotname_arg.slotnames[slotname_arg.minor]);
}
/* class_code/subclass/boardtype */
get_type(boardtype, cardinfo, (*cs)->ap_type);
DBG(1, ("cfga_list_ext return success\n"));
rv = CFGA_OK;
return (rv);
}
/*
* This routine prints a single line of help message
*/
static void
cfga_msg(struct cfga_msg *msgp, const char *str)
{
DBG(2, ("<%s>", str));
if (msgp == NULL || msgp->message_routine == NULL)
return;
(*msgp->message_routine)(msgp->appdata_ptr, str);
(*msgp->message_routine)(msgp->appdata_ptr, "\n");
}
static cfga_err_t
check_options(const char *options)
{
struct cfga_msg *msgp = NULL;
if (options) {
cfga_msg(msgp, dgettext(TEXT_DOMAIN, cfga_strs[HELP_UNKNOWN]));
cfga_msg(msgp, options);
return (CFGA_INVAL);
}
return (CFGA_OK);
}
/*ARGSUSED*/
cfga_err_t
cfga_help(struct cfga_msg *msgp, const char *options, cfga_flags_t flags)
{
if (options) {
cfga_msg(msgp, dgettext(TEXT_DOMAIN, cfga_strs[HELP_UNKNOWN]));
cfga_msg(msgp, options);
}
DBG(1, ("cfga_help\n"));
cfga_msg(msgp, dgettext(TEXT_DOMAIN, cfga_strs[HELP_HEADER]));
cfga_msg(msgp, cfga_strs[HELP_CONFIG]);
cfga_msg(msgp, cfga_strs[HELP_ENABLE_SLOT]);
cfga_msg(msgp, cfga_strs[HELP_DISABLE_SLOT]);
cfga_msg(msgp, cfga_strs[HELP_ENABLE_AUTOCONF]);
cfga_msg(msgp, cfga_strs[HELP_DISABLE_AUTOCONF]);
cfga_msg(msgp, cfga_strs[HELP_LED_CNTRL]);
return (CFGA_OK);
}
/*
* cfga_err() accepts a variable number of message IDs and constructs
* a corresponding error string which is returned via the errstring argument.
* cfga_err() calls gettext() to internationalize proper messages.
*/
static void
cfga_err(char **errstring, ...)
{
int a;
int i;
int n;
int len;
int flen;
char *p;
char *q;
char *s[32];
char *failed;
va_list ap;
/*
* If errstring is null it means user in not interested in getting
* error status. So we don't do all the work
*/
if (errstring == NULL) {
return;
}
va_start(ap, errstring);
failed = dgettext(TEXT_DOMAIN, cfga_strs[FAILED]);
flen = strlen(failed);
for (n = len = 0; (a = va_arg(ap, int)) != 0; n++) {
switch (a) {
case CMD_GETSTAT:
case CMD_LIST:
case CMD_SLOT_CONNECT:
case CMD_SLOT_DISCONNECT:
case CMD_SLOT_CONFIGURE:
case CMD_SLOT_UNCONFIGURE:
p = cfga_errstrs(a);
len += (strlen(p) + flen);
s[n] = p;
s[++n] = cfga_strs[FAILED];
DBG(2, ("<%s>", p));
DBG(2, (cfga_strs[FAILED]));
break;
case ERR_CMD_INVAL:
case ERR_AP_INVAL:
case ERR_OPT_INVAL:
case ERR_AP_ERR:
switch (a) {
case ERR_CMD_INVAL:
p = dgettext(TEXT_DOMAIN,
cfga_errstrs[ERR_CMD_INVAL]);
break;
case ERR_AP_INVAL:
p = dgettext(TEXT_DOMAIN,
cfga_errstrs[ERR_AP_INVAL]);
break;
case ERR_OPT_INVAL:
p = dgettext(TEXT_DOMAIN,
cfga_errstrs[ERR_OPT_INVAL]);
break;
case ERR_AP_ERR:
p = dgettext(TEXT_DOMAIN,
cfga_errstrs[ERR_AP_ERR]);
break;
}
if ((q = va_arg(ap, char *)) != NULL) {
len += (strlen(p) + strlen(q));
s[n] = p;
s[++n] = q;
DBG(2, ("<%s>", p));
DBG(2, ("<%s>", q));
break;
} else {
len += strlen(p);
s[n] = p;
}
DBG(2, ("<%s>", p));
break;
default:
n--;
break;
}
}
DBG(2, ("\n"));
va_end(ap);
if ((p = calloc(len + 1, 1)) == NULL)
return;
for (i = 0; i < n; i++) {
(void) strlcat(p, s[i], len + 1);
DBG(2, ("i:%d, %s\n", i, s[i]));
}
*errstring = p;
#ifdef DEBUG
printf("%s\n", *errstring);
free(*errstring);
#endif
}
/*
* cfga_ap_id_cmp -- use default_ap_id_cmp() in libcfgadm
*/