/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#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 <stdarg.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/dditypes.h>
#include <sys/modctl.h>
#include <sys/obpdefs.h>
#include <sys/fhc.h>
#include <sys/sysctrl.h>
#include <sys/openpromio.h>
#ifdef  SIM
#include <sys/stat.h>
#endif
#define CFGA_PLUGIN_LIB
#include <config_admin.h>

#ifdef  DEBUG
#define DBG     printf
#define DBG1    printf
#define DBG3    printf
#define DBG4    printf
#else
#define DBG(a, b)
#define DBG1(a)
#define DBG3(a, b, c)
#define DBG4(a, b, c, d)
#endif

#define BD_CPU                  1
#define BD_MEM                  2
#define BD_IO_2SBUS             3
#define BD_IO_SBUS_FFB          4
#define BD_IO_PCI               5
#define BD_DISK                 6
#define BD_IO_2SBUS_SOCPLUS     7
#define BD_IO_SBUS_FFB_SOCPLUS  8
#define BD_UNKNOWN              9
#define CMD_GETSTAT             10
#define CMD_LIST                11
#define CMD_CONNECT             12
#define CMD_DISCONNECT          13
#define CMD_CONFIGURE           14
#define CMD_UNCONFIGURE         15
#define CMD_QUIESCE             16
#define CMD_INSERT              17
#define CMD_REMOVE              18
#define CMD_SET_COND            19
#define OPT_ENABLE              20
#define OPT_DISABLE             21
#define ERR_PROM_OPEN           22
#define ERR_PROM_GETPROP        23
#define ERR_PROM_SETPROP        24
#define ERR_TRANS               25
#define ERR_CMD_INVAL           26
#define ERR_OPT_INVAL           27
#define ERR_AP_INVAL            28
#define ERR_DISABLED            29
#define DIAG_FORCE              30
#define DIAG_TRANS_OK           31
#define DIAG_FAILED             32
#define DIAG_WAS_ENABLED        33
#define DIAG_WAS_DISABLED       34
#define DIAG_WILL_ENABLE        35
#define DIAG_WILL_DISABLE       36
#define HELP_HEADER             37
#define HELP_QUIESCE            38
#define HELP_INSERT             39
#define HELP_REMOVE             40
#define HELP_SET_COND           41
#define HELP_ENABLE             42
#define HELP_DISABLE            43
#define HELP_UNKNOWN            44
#define ASK_CONNECT             45
#define STR_BD                  46
#define STR_COL                 47
#define COND_UNKNOWN            48
#define COND_OK                 49
#define COND_FAILING            50
#define COND_FAILED             51
#define COND_UNUSABLE           52
#define SYSC_COOLING            53
#define SYSC_POWER              54
#define SYSC_PRECHARGE          55
#define SYSC_INTRANS            56
#define SYSC_UTHREAD            57
#define SYSC_KTHREAD            58
#define SYSC_DEV_ATTACH         59
#define SYSC_DEV_DETACH         60
#define SYSC_NDI_ATTACH         61
#define SYSC_NDI_DETACH         62
#define SYSC_CORE_RESOURCE      63
#define SYSC_OSTATE             64
#define SYSC_RSTATE             65
#define SYSC_COND               66
#define SYSC_PROM               67
#define SYSC_NOMEM              68
#define SYSC_HOTPLUG            69
#define SYSC_HW_COMPAT          70
#define SYSC_NON_DR_PROM        71
#define SYSC_SUSPEND            72
#define SYSC_RESUME             73
#define SYSC_UNKNOWN            74
#define SYSC_DEVSTR             75

/*
 * The string table contains all the strings used by the platform
 * library.  The comment next to each string specifies whether the
 * string should be internationalized (y) or not (n).
 * Note that there are calls to dgettext() with strings other than
 * the ones below, they are marked by the li18 symbol.
 */
static char *
cfga_strs[] = {
        /*   */ NULL,
        /* n */ "cpu/mem   ",
        /* n */ "mem       ",
        /* n */ "dual-sbus ",
        /* n */ "sbus-upa  ",
        /* n */ "dual-pci  ",
        /* n */ "disk      ",
        /* n */ "soc+sbus  ",
        /* n */ "soc+upa   ",
        /* n */ "unknown   ",
        /* n */ "get-status",
        /* n */ "list",
        /* n */ "connect",
        /* n */ "disconnect",
        /* n */ "configure",
        /* n */ "unconfigure",
        /* n */ "quiesce-test",
        /* n */ "insert-test",
        /* n */ "remove-test",
        /* n */ "set-condition-test",
        /* n */ "enable-at-boot",
        /* n */ "disable-at-boot",
        /* n */ "prom open",
        /* n */ "prom getprop",
        /* n */ "prom setprop",
        /* y */ "invalid transition",
        /* y */ "invalid command: ",
        /* y */ "invalid option: ",
        /* y */ "invalid attachment point: ",
        /* y */ "board is disabled: must override with ",
        /* n */ "[-f][-o enable-at-boot]",
        /* y */ "transition succeeded but ",
        /* y */ " failed: ",
        /* y */ "was already enabled at boot time",
        /* y */ "was already disabled at boot time",
        /* y */ "will be enabled at boot time",
        /* y */ "will be disabled at boot time",
        /* y */ "\nSysctrl specific commands/options:",
        /* n */ "\t-x quiesce-test ap_id [ap_id...]",
        /* n */ "\t-x insert-test  ap_id [ap_id...]",
        /* n */ "\t-x remove-test  ap_id [ap_id...]",
        /* n */ "\t-x set-condition-test=<condition>",
        /* n */ "\t-o enable-at-boot",
        /* n */ "\t-o disable-at-boot",
        /* y */ "\tunknown command or option: ",
        /* y */
        "system will be temporarily suspended to connect a board: proceed",
        /* y */ "board ",
        /* y */ ": ",
        /* n */ "unknown",
        /* n */ "ok",
        /* n */ "failing",
        /* n */ "failed",
        /* n */ "unusable",
        /* y */ "not enough cooling for a new board",
        /* y */ "not enough power for a new board",
        /* y */ "not enough precharge power for a new board",
        /* y */ "configuration operation already in progress on this board",
        /* y */ "could not suspend user process: ",
        /* y */ "could not suspend system processes",
        /* y */ "device did not attach",
        /* y */ "device did not detach",
        /* y */ "nexus error during attach",
        /* y */ "nexus error during detach",
        /* y */ "attempt to remove core system resource",
        /* y */ "invalid occupant state",
        /* y */ "invalid receptacle state",
        /* y */ "insufficient condition",
        /* y */ "firmware operation error",
        /* y */ "not enough memory",
        /* y */ "hotplug feature unavailable on this machine",
        /* y */ "board does not support dynamic reconfiguration",
        /* y */ "firmware does not support dynamic reconfiguration",
        /* y */ "system suspend error",
        /* y */ "system resume error",
        /* y */ "unknown system error",
        /*   */ NULL
};

#define cfga_str(i)             cfga_strs[(i)]

#define cfga_eid(a, b)          (((a) << 8) + (b))

/*
 *
 *      Translation table for mapping from an <errno,sysc_err>
 *      pair to an error string.
 *
 *
 *      SYSC_COOLING,           EAGAIN,  SYSC_ERR_COOLING
 *      SYSC_POWER,             EAGAIN,  SYSC_ERR_POWER
 *      SYSC_PRECHARGE,         EAGAIN,  SYSC_ERR_PRECHARGE
 *      SYSC_INTRANS,           EBUSY,   SYSC_ERR_INTRANS
 *      SYSC_KTHREAD,           EBUSY,   SYSC_ERR_KTHREAD
 *      SYSC_DEV_ATTACH,        EBUSY,   SYSC_ERR_NDI_ATTACH
 *      SYSC_DEV_DETACH,        EBUSY,   SYSC_ERR_NDI_DETACH
 *      SYSC_NDI_ATTACH,        EFAULT,  SYSC_ERR_NDI_ATTACH
 *      SYSC_NDI_DETACH,        EFAULT,  SYSC_ERR_NDI_DETACH
 *      SYSC_CORE_RESOURCE,     EINVAL,  SYSC_ERR_CORE_RESOURCE
 *      SYSC_OSTATE,            EINVAL,  SYSC_ERR_OSTATE
 *      SYSC_RSTATE,            EINVAL,  SYSC_ERR_RSTATE
 *      SYSC_COND,              EINVAL,  SYSC_ERR_COND
 *      SYSC_PROM,              EIO,     SYSC_ERR_PROM
 *      SYSC_NOMEM,             ENOMEM,  SYSC_ERR_DR_INIT
 *      SYSC_NOMEM,             ENOMEM,  SYSC_ERR_NDI_ATTACH
 *      SYSC_NOMEM,             ENOMEM,  SYSC_ERR_NDI_DETACH
 *      SYSC_HOTPLUG,           ENOTSUP, SYSC_ERR_HOTPLUG
 *      SYSC_HW_COMPAT,         ENOTSUP, SYSC_ERR_HW_COMPAT
 *      SYSC_NON_DR_PROM,       ENOTSUP, SYSC_ERR_NON_DR_PROM
 *      SYSC_SUSPEND,           ENXIO,   SYSC_ERR_SUSPEND
 *      SYSC_RESUME,            ENXIO,   SYSC_ERR_RESUME
 *      SYSC_UTHREAD,           ESRCH,   SYSC_ERR_UTHREAD
 */
static int
cfga_sid(int err, int scerr)
{
        if (scerr == SYSC_ERR_DEFAULT)
                return (SYSC_UNKNOWN);

        switch (cfga_eid(err, scerr)) {
        case cfga_eid(EAGAIN, SYSC_ERR_COOLING):
                return (SYSC_COOLING);
        case cfga_eid(EAGAIN, SYSC_ERR_POWER):
                return (SYSC_POWER);
        case cfga_eid(EAGAIN, SYSC_ERR_PRECHARGE):
                return (SYSC_PRECHARGE);
        case cfga_eid(EBUSY, SYSC_ERR_INTRANS):
                return (SYSC_INTRANS);
        case cfga_eid(EBUSY, SYSC_ERR_KTHREAD):
                return (SYSC_KTHREAD);
        case cfga_eid(EBUSY, SYSC_ERR_NDI_ATTACH):
                return (SYSC_DEV_ATTACH);
        case cfga_eid(EBUSY, SYSC_ERR_NDI_DETACH):
                return (SYSC_DEV_DETACH);
        case cfga_eid(EFAULT, SYSC_ERR_NDI_ATTACH):
                return (SYSC_NDI_ATTACH);
        case cfga_eid(EFAULT, SYSC_ERR_NDI_DETACH):
                return (SYSC_NDI_DETACH);
        case cfga_eid(EINVAL, SYSC_ERR_CORE_RESOURCE):
                return (SYSC_CORE_RESOURCE);
        case cfga_eid(EINVAL, SYSC_ERR_OSTATE):
                return (SYSC_OSTATE);
        case cfga_eid(EINVAL, SYSC_ERR_RSTATE):
                return (SYSC_RSTATE);
        case cfga_eid(EINVAL, SYSC_ERR_COND):
                return (SYSC_COND);
        case cfga_eid(EIO, SYSC_ERR_PROM):
                return (SYSC_PROM);
        case cfga_eid(ENOMEM, SYSC_ERR_DR_INIT):
                return (SYSC_NOMEM);
        case cfga_eid(ENOMEM, SYSC_ERR_NDI_ATTACH):
                return (SYSC_NOMEM);
        case cfga_eid(ENOMEM, SYSC_ERR_NDI_DETACH):
                return (SYSC_NOMEM);
        case cfga_eid(ENOTSUP, SYSC_ERR_HOTPLUG):
                return (SYSC_HOTPLUG);
        case cfga_eid(ENOTSUP, SYSC_ERR_HW_COMPAT):
                return (SYSC_HW_COMPAT);
        case cfga_eid(ENOTSUP, SYSC_ERR_NON_DR_PROM):
                return (SYSC_NON_DR_PROM);
        case cfga_eid(ENXIO, SYSC_ERR_SUSPEND):
                return (SYSC_SUSPEND);
        case cfga_eid(ENXIO, SYSC_ERR_RESUME):
                return (SYSC_RESUME);
        case cfga_eid(ESRCH, SYSC_ERR_UTHREAD):
                return (SYSC_UTHREAD);
        default:
                break;
        }

        return (SYSC_UNKNOWN);
}

static void
sysc_cmd_init(sysc_cfga_cmd_t *sc, char *outputstr, int force)
{
        sc->force = force;
        sc->outputstr = outputstr;
        sc->errtype = SYSC_ERR_DEFAULT;

        (void) memset((void *)outputstr, 0, sizeof (outputstr));

        cfga_str(SYSC_DEVSTR) = outputstr;
}

/*
 * 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 dgettext() to internationalize proper messages.
 */
static void
cfga_err(sysc_cfga_cmd_t *sc, char **errstring, ...)
{
        int a;
        int i;
        int n;
        int len;
        int flen;
        char *p;
        char *q;
        char *s[32];
        char *failed;
        va_list ap;
        char syserr_num[20];

        /*
         * 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_str(DIAG_FAILED));
        flen = strlen(failed);

        for (n = len = 0; (a = va_arg(ap, int)) != 0; n++) {

                switch (a) {
                case ERR_PROM_OPEN:
                case ERR_PROM_GETPROP:
                case ERR_PROM_SETPROP:
                case CMD_GETSTAT:
                case CMD_LIST:
                case CMD_CONNECT:
                case CMD_DISCONNECT:
                case CMD_CONFIGURE:
                case CMD_UNCONFIGURE:
                case CMD_QUIESCE:
                case CMD_INSERT:
                case CMD_REMOVE:
                case CMD_SET_COND:
                        p =  cfga_str(a);
                        len += (strlen(p) + flen);
                        s[n] = p;
                        s[++n] = failed;

                        DBG("<%s>", p);
                        DBG("<%s>", failed);
                        break;

                case OPT_ENABLE:
                case OPT_DISABLE:
                        p = dgettext(TEXT_DOMAIN, cfga_str(DIAG_TRANS_OK));
                        q = cfga_str(a);
                        len += (strlen(p) + strlen(q) + flen);
                        s[n] = p;
                        s[++n] = q;
                        s[++n] = failed;

                        DBG("<%s>", p);
                        DBG("<%s>", q);
                        DBG("<%s>", failed);
                        break;

                case ERR_CMD_INVAL:
                case ERR_AP_INVAL:
                case ERR_OPT_INVAL:
                        p =  dgettext(TEXT_DOMAIN, cfga_str(a));
                        q = va_arg(ap, char *);
                        len += (strlen(p) + strlen(q));
                        s[n] = p;
                        s[++n] = q;

                        DBG("<%s>", p);
                        DBG("<%s>", q);
                        break;

                case ERR_TRANS:
                case ERR_DISABLED:
                        p =  dgettext(TEXT_DOMAIN, cfga_str(a));
                        len += strlen(p);
                        s[n] = p;

                        DBG("<%s>", p);
                        break;

                case DIAG_FORCE:
                default:
                        p =  cfga_str(a);
                        len += strlen(p);
                        s[n] = p;

                        DBG("<%s>", p);
                        break;
                }
        }

        DBG1("\n");
        va_end(ap);

        if (errno) {
                if (sc)
                        i = cfga_sid(errno, (int)sc->errtype);
                else
                        i = SYSC_UNKNOWN;

                DBG4("cfga_sid(%d,%d)=%d\n", errno, sc->errtype, i);

                if (i == SYSC_UNKNOWN) {
                        p = strerror(errno);
                        if (p == NULL) {
                                (void) sprintf(syserr_num, "errno=%d", errno);
                                p = syserr_num;
                        }
                } else
                        p = dgettext(TEXT_DOMAIN, cfga_str(i));

                len += strlen(p);
                s[n++] = p;
                p = cfga_str(SYSC_DEVSTR);
                if (p && p[0]) {
                        q = cfga_str(STR_COL);

                        len += strlen(q);
                        s[n++] = q;
                        len += strlen(p);
                        s[n++] = p;
                }
        }

        if ((p = (char *)calloc(len, 1)) == NULL)
                return;

        for (i = 0; i < n; i++)
                (void) strcat(p, s[i]);

        *errstring = p;
#ifdef  SIM_MSG
        printf("%s\n", *errstring);
#endif
}

/*
 * This routine accepts a variable number of message IDs and constructs
 * a corresponding error string which is printed via the message print routine
 * argument.  The HELP_UNKNOWN message ID has an argument string (the unknown
 * help topic) that follows.
 */
static void
cfga_msg(struct cfga_msg *msgp, ...)
{
        int a;
        int i;
        int n;
        int len;
        char *p;
        char *s[32];
        va_list ap;

        va_start(ap, msgp);

        for (n = len = 0; (a = va_arg(ap, int)) != 0; n++) {
                DBG("<%d>", a);
                p =  dgettext(TEXT_DOMAIN, cfga_str(a));
                len += strlen(p);
                s[n] = p;
                if (a == HELP_UNKNOWN) {
                        p = va_arg(ap, char *);
                        len += strlen(p);
                        s[++n] = p;
                }
        }

        va_end(ap);

        if ((p = (char *)calloc(len + 1, 1)) == NULL)
                return;

        for (i = 0; i < n; i++)
                (void) strcat(p, s[i]);
        (void) strcat(p, "\n");

#ifdef  SIM_MSG
        printf("%s", p);
#else
        (*msgp->message_routine)(msgp->appdata_ptr, p);
#endif
        free(p);
}

static sysc_cfga_stat_t *
sysc_stat(const char *ap_id, int *fdp)
{
        int fd;
        static sysc_cfga_stat_t sc_list[MAX_BOARDS];


        if ((fd = open(ap_id, O_RDWR, 0)) == -1)
                return (NULL);
        else if (ioctl(fd, SYSC_CFGA_CMD_GETSTATUS, sc_list) == -1) {
                (void) close(fd);
                return (NULL);
        } else if (fdp)
                *fdp = fd;
        else
                (void) close(fd);

        return (sc_list);
}

/*
 * This code implementes the simulation of the ioctls that transition state.
 * The GETSTAT ioctl is not simulated.  In this way a snapshot of the system
 * state is read and manipulated by the simulation routines.  It is basically
 * a useful debugging tool.
 */
#ifdef  SIM
static int sim_idx;
static int sim_fd = -1;
static int sim_size = MAX_BOARDS * sizeof (sysc_cfga_stat_t);
static sysc_cfga_stat_t sim_sc_list[MAX_BOARDS];

static sysc_cfga_stat_t *
sim_sysc_stat(const char *ap_id, int *fdp)
{
        int fd;
        struct stat buf;

        if (sim_fd != -1)
                return (sim_sc_list);

        if ((sim_fd = open("/tmp/cfga_simdata", O_RDWR|O_CREAT)) == -1) {
                perror("sim_open");
                exit(1);
        } else if (fstat(sim_fd, &buf) == -1) {
                perror("sim_stat");
                exit(1);
        }

        if (buf.st_size) {
                if (buf.st_size != sim_size) {
                        perror("sim_size");
                        exit(1);
                } else if (read(sim_fd, sim_sc_list, sim_size) == -1) {
                        perror("sim_read");
                        exit(1);
                }
        } else if ((fd = open(ap_id, O_RDWR, 0)) == -1)
                return (NULL);
        else if (ioctl(fd, SYSC_CFGA_CMD_GETSTATUS, sim_sc_list) == -1) {
                (void) close(fd);
                return (NULL);
        } else if (fdp)
                *fdp = fd;

        return (sim_sc_list);
}

static int
sim_open(char *a, int b, int c)
{
        printf("sim_open(%s)\n", a);

        if (strcmp(a, "/dev/openprom") == 0)
                return (open(a, b, c));
        return (0);
}

static int
sim_close(int a)
{
        return (0);
}

static int
sim_ioctl(int fd, int cmd, void *a)
{
        printf("sim_ioctl(%d)\n", sim_idx);

        switch (cmd) {
        case SYSC_CFGA_CMD_CONNECT:
                sim_sc_list[sim_idx].rstate = SYSC_CFGA_RSTATE_CONNECTED;
                break;
        case SYSC_CFGA_CMD_CONFIGURE:
                sim_sc_list[sim_idx].ostate = SYSC_CFGA_OSTATE_CONFIGURED;
                break;
        case SYSC_CFGA_CMD_UNCONFIGURE:
                sim_sc_list[sim_idx].ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
                break;
        case SYSC_CFGA_CMD_DISCONNECT:
                sim_sc_list[sim_idx].rstate = SYSC_CFGA_RSTATE_DISCONNECTED;
                break;
        case SYSC_CFGA_CMD_QUIESCE_TEST:
        case SYSC_CFGA_CMD_TEST:
                return (0);
        case OPROMGETOPT:
                return (ioctl(fd, OPROMGETOPT, a));
        case OPROMSETOPT:
                return (ioctl(fd, OPROMSETOPT, a));
        }

        if (lseek(sim_fd, SEEK_SET, 0) == -1) {
                perror("sim_seek");
                exit(1);
        }
        if (write(sim_fd, sim_sc_list, sim_size) == -1) {
                perror("sim_write");
                exit(1);
        }

        return (0);
}

#define open(a, b, c)   sim_open((char *)(a), (int)(b), (int)(c))
#define close(a)        sim_close(a)
#define ioctl(a, b, c)  sim_ioctl((int)(a), (int)(b), (void *)(c))
#define sysc_stat(a, b) sim_sysc_stat(a, b)
#endif  /* SIM */

static char *promdev = "/dev/openprom";
static char *dlprop = "disabled-board-list";

#define BUFSIZE         128

typedef union {
        char buf[BUFSIZE];
        struct openpromio opp;
} oppbuf_t;

static int
prom_get_prop(int prom_fd, char *var, char **val)
{
        static oppbuf_t oppbuf;
        struct openpromio *opp = &(oppbuf.opp);

        (void) strncpy(opp->oprom_array, var, OBP_MAXPROPNAME);
        opp->oprom_array[OBP_MAXPROPNAME + 1] = '\0';
        opp->oprom_size = BUFSIZE;

        DBG3("getprop(%s, %d)\n", opp->oprom_array, opp->oprom_size);

        if (ioctl(prom_fd, OPROMGETOPT, opp) < 0)
                return (ERR_PROM_GETPROP);
        else if (opp->oprom_size > 0)
                *val = opp->oprom_array;
        else
                *val = NULL;

        return (0);
}

static cfga_err_t
prom_set_prop(int prom_fd, char *var, char *val)
{
        oppbuf_t oppbuf;
        struct openpromio *opp = &(oppbuf.opp);
        int varlen = strlen(var) + 1;
        int vallen = strlen(val);

        DBG("prom_set_prop(%s)\n", val);

        (void) strcpy(opp->oprom_array, var);
        (void) strcpy(opp->oprom_array + varlen, val);
        opp->oprom_size = varlen + vallen;

        if (ioctl(prom_fd, OPROMSETOPT, opp) < 0)
                return (ERR_PROM_SETPROP);

        return (0);
}

static int
dlist_find(int board, char **dlist, int *disabled)
{
        int i;
        int err;
        int prom_fd;
        char *p;
        char *dl;
        char b[2];

        if ((prom_fd = open(promdev, O_RDWR, 0)) < 0)
                return (ERR_PROM_OPEN);
        else if (err = prom_get_prop(prom_fd, dlprop, dlist)) {
                (void) close(prom_fd);
                return (err);
        } else
                (void) close(prom_fd);

        b[1] = 0;
        *disabled = 0;

        if ((dl = *dlist) != NULL) {
                int len = strlen(dl);

                for (i = 0; i < len; i++) {
                        int bd;

                        b[0] = dl[i];
                        bd = strtol(b, &p, 16);

                        if (p != b && bd == board)
                                (*disabled)++;
                }
        }

        return (0);
}

static int
dlist_update(int board, int disable, char *dlist, struct cfga_msg *msgp,
    int verbose)
{
        int i, j, n;
        int err;
        int found;
        int update;
        int prom_fd;
        char *p;
        char b[2];
        char ndlist[64];

        b[1] = 0;
        ndlist[0] = 0;
        j = 0;
        found = 0;
        update = 0;

        if ((prom_fd = open(promdev, O_RDWR, 0)) < 0)
                return (ERR_PROM_OPEN);

        if (dlist) {
                int len = strlen(dlist);

                for (i = 0; i < len; i++) {
                        int bd;

                        b[0] = dlist[i];
                        bd = strtol(b, &p, 16);

                        if (p != b && bd == board) {

                                found++;
                                if (disable) {
                                        if (verbose)
                                                cfga_msg(msgp, STR_BD,
                                                    DIAG_WAS_DISABLED, 0);
                                } else {
                                        if (verbose)
                                                cfga_msg(msgp, STR_BD,
                                                    DIAG_WILL_ENABLE, 0);
                                        update++;
                                        continue;
                                }
                        }
                        ndlist[j++] = dlist[i];
                }
                ndlist[j] = 0;
        }

        if (!found)
                if (disable) {
                        if (verbose)
                                cfga_msg(msgp, STR_BD, DIAG_WILL_DISABLE, 0);
                        p = &ndlist[j];
                        n = sprintf(p, "%x", board);
                        p[n] = 0;
                        update++;
                } else {
                        if (verbose)
                                cfga_msg(msgp, STR_BD, DIAG_WAS_ENABLED, 0);
                }

        if (update)
                err = prom_set_prop(prom_fd, dlprop, ndlist);
        else
                err = 0;

        (void) close(prom_fd);

        return (err);
}

static int
ap_idx(const char *ap_id)
{
        int id;
        char *s;
        static char *slot = "slot";

        DBG("ap_idx(%s)\n", ap_id);

        if ((s = strstr(ap_id, slot)) == NULL)
                return (-1);
        else {
                int n;

                s += strlen(slot);
                n = strlen(s);

                DBG3("ap_idx: s=%s, n=%d\n", s, n);

                switch (n) {
                case 2:
                        if (!isdigit(s[1]))
                                return (-1);
                /* FALLTHROUGH */
                case 1:
                        if (!isdigit(s[0]))
                                return (-1);
                        break;
                default:
                        return (-1);
                }
        }

        if ((id = atoi(s)) > MAX_BOARDS)
                return (-1);

        DBG3("ap_idx(%s)=%d\n", s, id);

        return (id);
}

/*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 fd;
        int idx;
        int err;
        int force;
        int verbose;
        int opterr;
        int disable;
        int disabled;
        cfga_err_t rc;
        sysc_cfga_stat_t *ss;
        sysc_cfga_cmd_t *sc, sysc_cmd;
        sysc_cfga_rstate_t rs;
        sysc_cfga_ostate_t os;
        char *dlist;
        char outputstr[SYSC_OUTPUT_LEN];

        if (errstring != NULL)
                *errstring = NULL;

        rc = CFGA_ERROR;

        if (options) {
                disable = 0;
                if (strcmp(options, cfga_str(OPT_DISABLE)) == 0)
                        disable++;
                else if (strcmp(options, cfga_str(OPT_ENABLE))) {
                        cfga_err(NULL, errstring, ERR_OPT_INVAL, options, 0);
                        return (rc);
                }
        }

        if ((idx = ap_idx(ap_id)) == -1) {
                cfga_err(NULL, errstring, ERR_AP_INVAL, ap_id, 0);
                return (rc);
        } else if ((ss = sysc_stat(ap_id, &fd)) == NULL) {
                cfga_err(NULL, errstring, CMD_GETSTAT, 0);
                return (rc);
        }
#ifdef  SIM
        sim_idx = idx;
#endif
        /*
         * We disallow connecting on the disabled list unless
         * either the FORCE flag or the enable-at-boot option
         * is set. The check is made further below
         */
        if (opterr = dlist_find(idx, &dlist, &disabled)) {
                err = disable ? OPT_DISABLE : OPT_ENABLE;
                cfga_err(NULL, errstring, err, opterr, 0);
                (void) close(fd);
                return (rc);
        } else
                force = flags & CFGA_FLAG_FORCE;

        rs = ss[idx].rstate;
        os = ss[idx].ostate;

        sc = &sysc_cmd;
        sysc_cmd_init(sc, outputstr, force);
        verbose = flags & CFGA_FLAG_VERBOSE;

        switch (state_change_cmd) {
        case CFGA_CMD_CONNECT:
                if (rs != SYSC_CFGA_RSTATE_DISCONNECTED)
                        cfga_err(NULL, errstring, ERR_TRANS, 0);
                else if (disabled && !(force || (options && !disable)))
                        cfga_err(NULL, errstring, CMD_CONNECT,
                            ERR_DISABLED, DIAG_FORCE, 0);
                else if (!(*confp->confirm)(confp->appdata_ptr,
                    cfga_str(ASK_CONNECT))) {
                        (void) close(fd);
                        return (CFGA_NACK);
                } else if (ioctl(fd, SYSC_CFGA_CMD_CONNECT, sc) == -1)
                        cfga_err(sc, errstring, CMD_CONNECT, 0);
                else if (options && (opterr = dlist_update(idx, disable,
                    dlist, msgp, verbose))) {
                        err = disable ? OPT_DISABLE : OPT_ENABLE;
                        cfga_err(NULL, errstring, err, opterr, 0);
                } else
                        rc = CFGA_OK;
                break;

        case CFGA_CMD_DISCONNECT:
                if ((os == SYSC_CFGA_OSTATE_CONFIGURED) &&
                    (ioctl(fd, SYSC_CFGA_CMD_UNCONFIGURE, sc) == -1)) {
                        cfga_err(sc, errstring, CMD_UNCONFIGURE, 0);
                        (void) close(fd);
                        return (CFGA_ERROR);
                } else
                        sysc_cmd_init(sc, outputstr, force);

                if (rs == SYSC_CFGA_RSTATE_CONNECTED) {
                        if (ioctl(fd, SYSC_CFGA_CMD_DISCONNECT, sc) == -1)
                                cfga_err(sc, errstring, CMD_DISCONNECT, 0);
                        else if (options && (opterr = dlist_update(idx, disable,
                            dlist, msgp, verbose))) {
                                err = disable ? OPT_DISABLE : OPT_ENABLE;
                                cfga_err(NULL, errstring, err, opterr, 0);
                        } else
                                rc = CFGA_OK;
                } else
                        cfga_err(NULL, errstring, ERR_TRANS, 0);
                break;

        case CFGA_CMD_CONFIGURE:
                if (rs == SYSC_CFGA_RSTATE_DISCONNECTED)
                        if (disabled && !(force || (options && !disable))) {
                                cfga_err(NULL, errstring, CMD_CONFIGURE,
                                    ERR_DISABLED, DIAG_FORCE, 0);
                                (void) close(fd);
                                return (CFGA_ERROR);
                        } else if (!(*confp->confirm)(confp->appdata_ptr,
                            cfga_str(ASK_CONNECT))) {
                                (void) close(fd);
                                return (CFGA_NACK);
                        } else if (ioctl(fd, SYSC_CFGA_CMD_CONNECT, sc) == -1) {
                                cfga_err(sc, errstring, CMD_CONNECT, 0);
                                (void) close(fd);
                                return (CFGA_ERROR);
                        } else
                                sysc_cmd_init(sc, outputstr, force);

                if (os == SYSC_CFGA_OSTATE_UNCONFIGURED) {
                        if (ioctl(fd, SYSC_CFGA_CMD_CONFIGURE, sc) == -1)
                                cfga_err(sc, errstring, CMD_CONFIGURE, 0);
                        else if (options && (opterr = dlist_update(idx,
                            disable, dlist, msgp, verbose))) {
                                err = disable ? OPT_DISABLE : OPT_ENABLE;
                                cfga_err(NULL, errstring, err, opterr, 0);
                        } else
                                rc = CFGA_OK;
                } else
                        cfga_err(NULL, errstring, ERR_TRANS, 0);
                break;

        case CFGA_CMD_UNCONFIGURE:
                if (os != SYSC_CFGA_OSTATE_CONFIGURED)
                        cfga_err(NULL, errstring, ERR_TRANS, 0);
                else if (ioctl(fd, SYSC_CFGA_CMD_UNCONFIGURE, sc) == -1)
                        cfga_err(sc, errstring, CMD_UNCONFIGURE, 0);
                else if (options && (opterr = dlist_update(idx, disable,
                    dlist, msgp, verbose))) {
                        err = disable ? OPT_DISABLE : OPT_ENABLE;
                        cfga_err(NULL, errstring, err, opterr, 0);
                } else
                        rc = CFGA_OK;
                break;

        default:
                rc = CFGA_OPNOTSUPP;
                break;
        }

        (void) close(fd);
        return (rc);
}

static int
str2cond(const char *cond)
{
        int c;

        if (strcmp(cond, cfga_str(COND_UNKNOWN)) == 0)
                c =  SYSC_CFGA_COND_UNKNOWN;
        else if (strcmp(cond, cfga_str(COND_OK)) == 0)
                c =  SYSC_CFGA_COND_OK;
        else if (strcmp(cond, cfga_str(COND_FAILING)) == 0)
                c =  SYSC_CFGA_COND_FAILING;
        else if (strcmp(cond, cfga_str(COND_FAILED)) == 0)
                c =  SYSC_CFGA_COND_FAILED;
        else if (strcmp(cond, cfga_str(COND_UNUSABLE)) == 0)
                c =  SYSC_CFGA_COND_UNUSABLE;
        else
                c = -1;

        return (c);
}

/*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)
{
        int fd;
        int idx;
        int len;
        int cmd;
        int cond;
        int err;
        int opterr;
        int verbose;
        int disable;
        int disabled;
        cfga_err_t rc;
        char *str;
        char *dlist;
        char outputstr[SYSC_OUTPUT_LEN];
        sysc_cfga_cmd_t *sc, sysc_cmd;

        if (errstring != NULL)
                *errstring = NULL;

        verbose = flags & CFGA_FLAG_VERBOSE;

        rc = CFGA_ERROR;

        if (options) {
                disable = 0;
                if (strcmp(options, cfga_str(OPT_DISABLE)) == 0)
                        disable++;
                else if (strcmp(options, cfga_str(OPT_ENABLE))) {
                        cfga_err(NULL, errstring, ERR_OPT_INVAL, options, 0);
                        return (rc);
                }
        }

        sc = &sysc_cmd;
        str = cfga_str(CMD_SET_COND);
        len = strlen(str);

        if ((strncmp(function, str, len) == 0) && (function[len++] == '=') &&
            ((cond = (str2cond(&function[len]))) != -1)) {
                cmd = SYSC_CFGA_CMD_TEST_SET_COND;
                err = CMD_SET_COND;
                sc->arg = cond;
        } else if (strcmp(function, cfga_str(CMD_QUIESCE)) == 0) {
                cmd = SYSC_CFGA_CMD_QUIESCE_TEST;
                err = CMD_QUIESCE;
        } else if (strcmp(function, cfga_str(CMD_INSERT)) == 0) {
                cmd = SYSC_CFGA_CMD_TEST;
                err = CMD_INSERT;
        } else if (strcmp(function, cfga_str(CMD_REMOVE)) == 0) {
                cmd = SYSC_CFGA_CMD_TEST;
                err = CMD_REMOVE;
        } else {
                cfga_err(NULL, errstring, ERR_CMD_INVAL, (char *)function, 0);
                return (rc);
        }

        sysc_cmd_init(sc, outputstr, 0);

        if ((idx = ap_idx(ap_id)) == -1)
                cfga_err(NULL, errstring, ERR_AP_INVAL, ap_id, 0);
        else if (((fd = open(ap_id, O_RDWR, 0)) == -1) ||
            (ioctl(fd, cmd, sc) == -1))
                cfga_err(NULL, errstring, err, 0);
        else
                rc = CFGA_OK;

        if (options) {
                opterr = (dlist_find(idx, &dlist, &disabled) ||
                    dlist_update(idx, disable, dlist, msgp, verbose));
                if (opterr) {
                        err = disable ? OPT_DISABLE : OPT_ENABLE;
                        if (verbose)
                                cfga_msg(msgp, err, opterr, 0);
                }
        }

        (void) close(fd);
        return (rc);
}


/*ARGSUSED*/
cfga_err_t
cfga_test(
        const char *ap_id,
        const char *options,
        struct cfga_msg *msgp,
        char **errstring,
        cfga_flags_t flags)
{
        if (errstring != NULL)
                *errstring = NULL;

        return (CFGA_OPNOTSUPP);
}

static cfga_stat_t
rstate_cvt(sysc_cfga_rstate_t rs)
{
        cfga_stat_t cs;

        switch (rs) {
        case SYSC_CFGA_RSTATE_EMPTY:
                cs = CFGA_STAT_EMPTY;
                break;
        case SYSC_CFGA_RSTATE_DISCONNECTED:
                cs = CFGA_STAT_DISCONNECTED;
                break;
        case SYSC_CFGA_RSTATE_CONNECTED:
                cs = CFGA_STAT_CONNECTED;
                break;
        default:
                cs = CFGA_STAT_NONE;
                break;
        }

        return (cs);
}

static cfga_stat_t
ostate_cvt(sysc_cfga_ostate_t os)
{
        cfga_stat_t cs;

        switch (os) {
        case SYSC_CFGA_OSTATE_UNCONFIGURED:
                cs = CFGA_STAT_UNCONFIGURED;
                break;
        case SYSC_CFGA_OSTATE_CONFIGURED:
                cs = CFGA_STAT_CONFIGURED;
                break;
        default:
                cs = CFGA_STAT_NONE;
                break;
        }

        return (cs);
}

static cfga_cond_t
cond_cvt(sysc_cfga_cond_t sc)
{
        cfga_cond_t cc;

        switch (sc) {
        case SYSC_CFGA_COND_OK:
                cc = CFGA_COND_OK;
                break;
        case SYSC_CFGA_COND_FAILING:
                cc = CFGA_COND_FAILING;
                break;
        case SYSC_CFGA_COND_FAILED:
                cc = CFGA_COND_FAILED;
                break;
        case SYSC_CFGA_COND_UNUSABLE:
                cc = CFGA_COND_UNUSABLE;
                break;
        case SYSC_CFGA_COND_UNKNOWN:
        default:
                cc = CFGA_COND_UNKNOWN;
                break;
        }

        return (cc);
}

static char *
type_str(enum board_type type)
{
        char *type_str;

        switch (type) {
        case MEM_BOARD:
                type_str = cfga_str(BD_MEM);
                break;
        case CPU_BOARD:
                type_str = cfga_str(BD_CPU);
                break;
        case IO_2SBUS_BOARD:
                type_str = cfga_str(BD_IO_2SBUS);
                break;
        case IO_SBUS_FFB_BOARD:
                type_str = cfga_str(BD_IO_SBUS_FFB);
                break;
        case IO_PCI_BOARD:
                type_str = cfga_str(BD_IO_PCI);
                break;
        case DISK_BOARD:
                type_str = cfga_str(BD_DISK);
                break;
        case IO_2SBUS_SOCPLUS_BOARD:
                type_str = cfga_str(BD_IO_2SBUS_SOCPLUS);
                break;
        case IO_SBUS_FFB_SOCPLUS_BOARD:
                type_str = cfga_str(BD_IO_SBUS_FFB_SOCPLUS);
                break;
        case UNKNOWN_BOARD:
        default:
                type_str = cfga_str(BD_UNKNOWN);
                break;
        }
        return (type_str);
}

static void
info_set(sysc_cfga_stat_t *sc, cfga_info_t info, int disabled)
{
        int i;
        struct cpu_info *cpu;
        union bd_un *bd = &sc->bd;

        *info = '\0';

        switch (sc->type) {
        case CPU_BOARD:
                for (i = 0, cpu = bd->cpu; i < 2; i++, cpu++) {
                        if (cpu->cpu_speed > 1) {
                                info += sprintf(info, "cpu %d: ", i);
                                info += sprintf(info, "%3d MHz ",
                                    cpu->cpu_speed);
                                if (cpu->cache_size)
                                        info += sprintf(info, "%0.1fM ",
                                            (float)cpu->cache_size /
                                            (float)(1024 * 1024));
                        }
                }
                break;
        case IO_SBUS_FFB_BOARD:
                switch (bd->io2.ffb_size) {
                case FFB_SINGLE:
                        info += sprintf(info, "single buffered ffb   ");
                        break;
                case FFB_DOUBLE:
                        info += sprintf(info, "double buffered ffb   ");
                        break;
                case FFB_NOT_FOUND:
#ifdef FFB_DR_SUPPORT
                        info += sprintf(info, "no ffb installed   ");
#endif
                        break;
                default:
                        info += sprintf(info, "illegal ffb size   ");
                        break;
                }
                break;
        case DISK_BOARD:
                for (i = 0; i < 2; i++)
                        if (bd->dsk.disk_pres[i])
                                info += sprintf(info, "target: %2d ",
                                    bd->dsk.disk_id[i]);
                        else
                                info += sprintf(info, "no disk   ");
                break;
        }

        if (disabled)
                info += sprintf(info, "disabled at boot   ");

        if (sc->no_detach)
                info += sprintf(info, "non-detachable   ");

        if (sc->plus_board)
                info += sprintf(info, "100 MHz capable   ");
}

static void
sysc_cvt(sysc_cfga_stat_t *sc, cfga_stat_data_t *cs, int disabled)
{
        (void) strcpy(cs->ap_type, type_str(sc->type));
        cs->ap_r_state = rstate_cvt(sc->rstate);
        cs->ap_o_state = ostate_cvt(sc->ostate);
        cs->ap_cond = cond_cvt(sc->condition);
        cs->ap_busy = (cfga_busy_t)sc->in_transition;
        cs->ap_status_time = sc->last_change;
        info_set(sc, cs->ap_info, disabled);
        cs->ap_log_id[0] = '\0';
        cs->ap_phys_id[0] = '\0';
}

/*ARGSUSED*/
cfga_err_t
cfga_list(
        const char *ap_id,
        cfga_stat_data_t **ap_list,
        int *nlist,
        const char *options,
        char **errstring)
{
        int i;
        cfga_err_t rc;
        sysc_cfga_stat_t *sc;
        cfga_stat_data_t *cs;

        if (errstring != NULL)
                *errstring = NULL;

        rc = CFGA_ERROR;

        if (ap_idx(ap_id) == -1)
                cfga_err(NULL, errstring, ERR_AP_INVAL, ap_id, 0);
        else if ((sc = sysc_stat(ap_id, NULL)) == NULL)
                cfga_err(NULL, errstring, CMD_LIST, 0);
        else if (!(cs = (cfga_stat_data_t *)malloc(MAX_BOARDS * sizeof (*cs))))
                cfga_err(NULL, errstring, CMD_LIST, 0);
        else {
                *ap_list = cs;

                for (*nlist = 0, i = 0; i < MAX_BOARDS; i++, sc++) {
                        if (sc->board == -1)
                                continue;
                        sysc_cvt(sc, cs++, 0); /* XXX - disable */
                        (*nlist)++;
                }

                rc = CFGA_OK;
        }

        return (rc);
}

/*ARGSUSED*/
cfga_err_t
cfga_stat(
        const char *ap_id,
        struct cfga_stat_data *cs,
        const char *options,
        char **errstring)
{
        cfga_err_t rc;
        int idx;
        int err;
        int opterr;
        int disable;
        int disabled;
        char *dlist;
        sysc_cfga_stat_t *sc;

        if (errstring != NULL)
                *errstring = NULL;

        rc = CFGA_ERROR;

        if (options && options[0]) {
                disable = 0;
                if (strcmp(options, cfga_str(OPT_DISABLE)) == 0)
                        disable++;
                else if (strcmp(options, cfga_str(OPT_ENABLE))) {
                        cfga_err(NULL, errstring, ERR_OPT_INVAL, options, 0);
                        return (rc);
                }
        }

        if ((idx = ap_idx(ap_id)) == -1)
                cfga_err(NULL, errstring, ERR_AP_INVAL, ap_id, 0);
        else if ((sc = sysc_stat(ap_id, NULL)) == NULL)
                cfga_err(NULL, errstring, CMD_GETSTAT, 0);
        else {
                opterr = dlist_find(idx, &dlist, &disabled);
                sysc_cvt(sc + idx, cs, disabled);

                rc = CFGA_OK;

                if (options && options[0] && ((opterr != 0) ||
                    ((opterr = dlist_update(idx, disable, dlist, NULL, 0))
                    != 0))) {
                                err = disable ? OPT_DISABLE : OPT_ENABLE;
                                cfga_err(NULL, errstring, err, opterr, 0);
                }
        }

        return (rc);
}

/*ARGSUSED*/
cfga_err_t
cfga_help(struct cfga_msg *msgp, const char *options, cfga_flags_t flags)
{
        int help = 0;

        if (options) {
                if (strcmp(options, cfga_str(OPT_DISABLE)) == 0)
                        help = HELP_DISABLE;
                else if (strcmp(options, cfga_str(OPT_ENABLE)) == 0)
                        help = HELP_ENABLE;
                else if (strcmp(options, cfga_str(CMD_INSERT)) == 0)
                        help = HELP_INSERT;
                else if (strcmp(options, cfga_str(CMD_REMOVE)) == 0)
                        help = HELP_REMOVE;
                else if (strcmp(options, cfga_str(CMD_QUIESCE)) == 0)
                        help = HELP_QUIESCE;
                else
                        help = HELP_UNKNOWN;
        }

        if (help)  {
                if (help == HELP_UNKNOWN)
                        cfga_msg(msgp, help, options, 0);
                else
                        cfga_msg(msgp, help, 0);
        } else {
                cfga_msg(msgp, HELP_HEADER, 0);
                cfga_msg(msgp, HELP_DISABLE, 0);
                cfga_msg(msgp, HELP_ENABLE, 0);
                cfga_msg(msgp, HELP_INSERT, 0);
                cfga_msg(msgp, HELP_REMOVE, 0);
                cfga_msg(msgp, HELP_QUIESCE, 0);
                cfga_msg(msgp, HELP_SET_COND, 0);
        }

        return (CFGA_OK);
}

/*
 * cfga_ap_id_cmp -- use default_ap_id_cmp() in libcfgadm
 */