cmd/sf880drd/sf880drd.c

/*
 * 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 2000, 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sys/types.h>
#include <sys/sunddi.h>
#include <sys/stat.h>
#include <sys/i2c/clients/i2c_client.h>
#include <sys/hpc3130_events.h>
#include <values.h>     /* for BITSPERBYTE */
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <strings.h>
#include <poll.h>
#include <libintl.h>
#include <errno.h>
#include <assert.h>
#include <config_admin.h>
#include <sys/daktari.h>
#include "sf880drd.h"

/*
 * Hotplug Controller addresses.
 */
static const unsigned char controller_names[NUM_CONTROLLERS] =
    { 0xe2, 0xe6, 0xe8, 0xec };

#define INDEX2SLOT(INDEX)   ((INDEX)%4) /* cf init_poll_events() */
#define INDEX2CONTROLLER(INDEX) ((INDEX)/4) /* cf init_poll_events() */

/*
 *  Local variables.
 */
static struct pollfd fds[NUM_FDS];
static unsigned int fault_leds[2];
static unsigned int ok2rem_leds[2];

/*
 *  Local prototypes.
 */
static void init_poll_events(void);
static void process_event(int);
static void report_cfgadm_error(int, char *);
static void set_front_panel_led(uint8_t, boolean_t);

static int i2c_set_bit(int, int, uint8_t);
static void report_syscall_error(char *);

static void pushbutton_event(char *);
static void fault_led_event(hpc3130_event_type_t, int);
static void removable_led_event(hpc3130_event_type_t, int);

/*
 * main(): loops forever looking for events.
 */
int
main()
{
    int i;
    int rv;

    init_poll_events();
    for (;;) {
        /* sleep in poll() waiting an event */
        rv = poll(fds, NUM_FDS, -1);
        if (rv < 0) {
            report_syscall_error("poll");
            continue;
        }

        /* woken up from poll() process the event */
        for (i = 0; i < NUM_FDS; ++i) {
            if (fds[i].revents == POLLIN)
                process_event(i);
        }
    }
    /* NOTREACHED */
    return (0);
}

/*
 * Set up poll fds.
 */
static void
init_poll_events()
{
    int c;
    int p;
    int i = 0;
    char buf[sizeof (HPC3130_DEV_FMT)+8];

    for (c = 0; c < NUM_CONTROLLERS; ++c) {
        for (p = 0; p < SLOTS_PER_CONTROLLER; ++p) {
            (void) sprintf(buf, HPC3130_DEV_FMT,
                controller_names[c], p);
            fds[i].events = POLLIN;
            fds[i].fd = open(buf, O_RDWR);
            if (fds[i].fd == -1) {
                report_syscall_error(buf);
                exit(-1);
            }
            i++;
        }
    }
}

/*
 * Process poll events.
 */
static void
process_event(int fdi)
{
    struct hpc3130_event e;
    int rv;
    int slot = INDEX2SLOT(fdi);
    int cntr = INDEX2CONTROLLER(fdi);

    rv = ioctl(fds[fdi].fd, HPC3130_GET_EVENT, &e);
    if (rv == -1) {
        report_syscall_error("HPC3130_GET_EVENT");
        return;
    }

    switch (e.id) {
    case HPC3130_EVENT_INSERTION:
    case HPC3130_EVENT_REMOVAL:
    case HPC3130_EVENT_POWERON:
    case HPC3130_EVENT_POWEROFF:
        break;
    case HPC3130_EVENT_BUTTON:
        DPRINTF(("\nBUTTON EVENT slot (%s)\n", e.name));
        pushbutton_event(e.name);
        break;
    case HPC3130_LED_FAULT_ON:
        DPRINTF(("\nFAULT LED ON EVENT\n"));
        fault_led_event(e.id, fdi);
        break;
    case HPC3130_LED_FAULT_OFF:
        DPRINTF(("\nFAULT LED OFF EVENT\n"));
        fault_led_event(e.id, fdi);
        break;
    case HPC3130_LED_REMOVABLE_ON:
        DPRINTF(("\nREMOVABLE LED ON EVENT\n"));
        removable_led_event(e.id, fdi);
        break;
    case HPC3130_LED_REMOVABLE_OFF:
        DPRINTF(("\nREMOVABLE LED OFF EVENT\n"));
        removable_led_event(e.id, fdi);
        break;
    default:
        (void) fprintf(stderr, "WARNING: bogus event: %x\n", e.id);
    }
}

/*
 * Button Event handler.
 */
static void
pushbutton_event(char *ap_id)
{
    char            *errstr = NULL;
    struct cfga_list_data   *stat = NULL;
    int         nlist;
    cfga_cmd_t      cmd;
    cfga_err_t      rv;

    rv = config_list_ext(1, &ap_id, &stat, &nlist,
        NULL, NULL, &errstr, 0);
    if (rv != CFGA_OK) {
        report_cfgadm_error(rv, errstr);
        goto out;
    }
    assert(nlist == 1);

    /* The only types of hotplug with buttons */
    assert(!(strcmp(stat->ap_class, "pci")));

    switch (stat->ap_o_state) {
    case CFGA_STAT_UNCONFIGURED:
        cmd = CFGA_CMD_CONFIGURE;
        break;
    case CFGA_STAT_CONFIGURED:
        cmd = CFGA_CMD_DISCONNECT;
        break;
    default:
        /* Should never get here */
        assert(0);
    }

    /*
     * confp & msgp are NULL: when using the pushbutton,
     * simply fail if prompting is required.
     */
    rv = config_change_state(cmd, 1, &ap_id, NULL, NULL, NULL, &errstr, 0);
    if (rv != CFGA_OK) {
        report_cfgadm_error(rv, errstr);
        /* FALLTHRU to "out" */
    }

out:
    if (errstr)
        free(errstr);
    if (stat)
        free(stat);
}

static void
fault_led_event(hpc3130_event_type_t event, int fdi)
{
    int     side = 0;
    unsigned int    old;

    if (INDEX2CONTROLLER(fdi) != GPTWO_CONTROLLER) {
        /* It's a PCI slot; left side of chassis */
        side = 1;
    }

    old = fault_leds[side];

    assert(fdi <= sizeof (fault_leds[side]) * BITSPERBYTE);

    switch (event) {
    case HPC3130_LED_FAULT_ON:
        fault_leds[side] |= (1<<fdi);
        DPRINTF(("fault_led_event: HPC3130_LED_FAULT_ON\n"));
        break;
    case HPC3130_LED_FAULT_OFF:
        fault_leds[side] &= ~(1<<fdi);
        DPRINTF(("fault_led_event: HPC3130_LED_FAULT_OFF\n"));
        break;
    }

    DPRINTF(("fault_led_event: old(0x%x), fault_leds[%d](0x%x)\n",
        old, side, fault_leds[side]));

    if ((old == 0) != (fault_leds[side] == 0) && ok2rem_leds[side] == 0) {
        /*
         * The first FAULT LED has come on, or the last one has gone
         * off on this side, and all the OK2REMOVE LEDS are off on this
         * side.  So we have to update the front panel ARROW LED.
         */
        set_front_panel_led(side ? LEFT_DOOR_ATTEN_LED :
            RIGHT_DOOR_ATTEN_LED,
            fault_leds[side] ? LED_ON : LED_OFF);
    }
}

static void
removable_led_event(hpc3130_event_type_t event, int fdi)
{
    int     side = 0;
    unsigned int    old;

    if (INDEX2CONTROLLER(fdi) != GPTWO_CONTROLLER) {
        /* It's a PCI slot; left side of chassis */
        side = 1;
    }

    old = ok2rem_leds[side];

    assert(fdi <= sizeof (ok2rem_leds[side]) * BITSPERBYTE);

    switch (event) {
    case HPC3130_LED_REMOVABLE_ON:
        ok2rem_leds[side] |= (1<<fdi);
        DPRINTF(("removable_led_event: HPC3130_LED_REMOVABLE_ON\n"));
        break;
    case HPC3130_LED_REMOVABLE_OFF:
        ok2rem_leds[side] &= ~(1<<fdi);
        DPRINTF(("removable_led_event: HPC3130_LED_REMOVABLE_OFF\n"));
        break;
    }

    DPRINTF(("removable_led_event: old(0x%x), ok2rem_leds[%d](0x%x)\n",
        old, side, ok2rem_leds[side]));

    if ((old == 0) != (ok2rem_leds[side] == 0)) {
        /*
         * The first OKAY2REMOVE LED has come on, or the last
         * one has gone off (on this side).  We may have to update
         * the front panel LEDs.
         */
        if (ok2rem_leds[!side] == 0) {
            /*
             * The OK2REMOVE LEDs are all off on the other
             * side of the chassis, so this side determines
             * whether the front OK2REMOVE is on or off.
             */
            set_front_panel_led(SYS_OK2REMOVE_LED,
                ok2rem_leds[side] ? LED_ON : LED_OFF);
        }
        if (fault_leds[side] == 0) {
            /*
             * All the FAULT LEDs are off on this side.  So the
             * OK2REMOVE LEDs determine whether the ARROW LED is on.
             */
        set_front_panel_led(side ? LEFT_DOOR_ATTEN_LED :
            RIGHT_DOOR_ATTEN_LED,
            ok2rem_leds[side] ? LED_ON : LED_OFF);
        }
    }
}

/*
 * Set front panel system leds either on or off.
 */
static void
set_front_panel_led(uint8_t bit_num, boolean_t on_off)
{
    int     fd;
    int     rv;
    i2c_bit_t   arg;

    fd = open(SSC050_LED_PORT, O_RDWR);
    if (fd == -1) {
        report_syscall_error("ssc050");
        return;
    }

    arg.bit_num = bit_num;
    arg.bit_value = on_off;

    rv = ioctl(fd, I2C_SET_BIT, &arg);
    if (rv == -1)
        report_syscall_error("LED I2C_SET_BIT");

    (void) close(fd);
}

static int
i2c_set_bit(int fp, int bit, uint8_t value)
{
    int     rv;
    i2c_bit_t   passin;

    passin.bit_num = (uchar_t)bit;
    passin.bit_value = value;
    rv = ioctl(fp, I2C_SET_BIT, &passin);
    return (rv);
}

static void
report_cfgadm_error(int cfgerrnum, char *errstr)
{
    const char  *ep;

    ep = config_strerror(cfgerrnum);

    if (ep == NULL)
        ep = gettext("configuration administration unknown error");

    if (errstr != NULL && *errstr != '\0') {
        (void) fprintf(stderr, "%s: %s\n", ep, errstr);
    } else {
        (void) fprintf(stderr, "%s\n", ep);
    }
}

static void
report_syscall_error(char *msg)
{
    if (errno != EINTR)
        perror(msg);
}