/*      $NetBSD: pm_direct.c,v 1.39 2024/06/02 13:28:46 andvar Exp $    */

/*
 * Copyright (C) 1997 Takashi Hamada
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *  This product includes software developed by Takashi Hamada
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/* From: pm_direct.c 1.3 03/18/98 Takashi Hamada */

/*
 * TODO : Check bounds on PMData in pmgrop
 *              callers should specify how much room for data is in the buffer
 *              and that should be respected by the pmgrop
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pm_direct.c,v 1.39 2024/06/02 13:28:46 andvar Exp $");

#ifdef DEBUG
#ifndef ADB_DEBUG
#define ADB_DEBUG
#endif
#endif

/* #define      PM_GRAB_SI      1 */

#include <sys/param.h>
#include <sys/device.h>
#include <sys/systm.h>

#include <machine/adbsys.h>
#include <machine/autoconf.h>
#include <machine/cpu.h>
#include <machine/pio.h>

#include <dev/ofw/openfirm.h>

#include <macppc/dev/adbvar.h>
#include <macppc/dev/pm_direct.h>
#include <macppc/dev/viareg.h>

extern int adb_polling;         /* Are we polling?  (Debugger mode) */

/* hardware dependent values */
#define ADBDelay 100            /* XXX */

/* useful macros */
#define PM_SR()                 read_via_reg(VIA1, vSR)
#define PM_VIA_INTR_ENABLE()    write_via_reg(VIA1, vIER, 0x90)
#define PM_VIA_INTR_DISABLE()   write_via_reg(VIA1, vIER, 0x10)
#define PM_VIA_CLR_INTR()       write_via_reg(VIA1, vIFR, 0x90)

#define PM_SET_STATE_ACKON()    via_reg_or(VIA2, vBufB, 0x10)
#define PM_SET_STATE_ACKOFF()   via_reg_and(VIA2, vBufB, ~0x10)
#define PM_IS_ON                (0x08 == (read_via_reg(VIA2, vBufB) & 0x08))
#define PM_IS_OFF               (0x00 == (read_via_reg(VIA2, vBufB) & 0x08))

/*
 * Variables for internal use
 */
u_short pm_existent_ADB_devices = 0x0;  /* each bit expresses the existent ADB device */
u_int   pm_LCD_brightness = 0x0;
u_int   pm_LCD_contrast = 0x0;
u_int   pm_counter = 0;                 /* clock count */

static enum batt_type { BATT_COMET, BATT_HOOPER, BATT_SMART } pmu_batt_type;
static int      pmu_nbatt;
static int      strinlist(const char *, char *, int);
static enum pmu_type { PMU_UNKNOWN, PMU_OHARE, PMU_G3, PMU_KEYLARGO } pmu_type;

/* these values shows that number of data returned after 'send' cmd is sent */
signed char pm_send_cmd_type[] = {
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x01, 0x01,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00,   -1,   -1,   -1,   -1,   -1, 0x00,
          -1, 0x00, 0x02, 0x01, 0x01,   -1,   -1,   -1,
        0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x04, 0x14,   -1, 0x03,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x02, 0x02,   -1,   -1,   -1,   -1,
        0x01, 0x01,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00,   -1,   -1, 0x01,   -1,   -1,   -1,
        0x01, 0x00, 0x02, 0x02,   -1, 0x01, 0x03, 0x01,
        0x00, 0x01, 0x00, 0x00, 0x00,   -1,   -1,   -1,
        0x02,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   -1,   -1,
        0x01, 0x01, 0x01,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00,   -1,   -1,   -1,   -1, 0x04, 0x04,
        0x04,   -1, 0x00,   -1,   -1,   -1,   -1,   -1,
        0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x01, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00,   -1,   -1,   -1,   -1,   -1,   -1,
        0x02, 0x02, 0x02, 0x04,   -1, 0x00,   -1,   -1,
        0x01, 0x01, 0x03, 0x02,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x01, 0x01,   -1,   -1, 0x00, 0x00,   -1,   -1,
          -1, 0x04, 0x00,   -1,   -1,   -1,   -1,   -1,
        0x03,   -1, 0x00,   -1, 0x00,   -1,   -1, 0x00,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1
};

/* these values shows that number of data returned after 'receive' cmd is sent */
signed char pm_receive_cmd_type[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x02, 0x02,   -1,   -1,   -1,   -1,   -1, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x05, 0x15,   -1, 0x02,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x02, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x02, 0x00, 0x03, 0x03,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x04, 0x04, 0x03, 0x09,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          -1,   -1,   -1,   -1,   -1,   -1, 0x01, 0x01,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x06,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x02, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x02, 0x00, 0x00, 0x00,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x02, 0x02,   -1,   -1, 0x02,   -1,   -1,   -1,
        0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
          -1,   -1, 0x02,   -1,   -1,   -1,   -1, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
};


/*
 * Define the private functions
 */

/* for debugging */
#ifdef ADB_DEBUG
void    pm_printerr(const char *, int, int, const char *);
#endif

int     pm_wait_busy(int);
int     pm_wait_free(int);

static int      pm_receive(u_char *);
static int      pm_send(u_char);

/* these functions are called from adb_direct.c */
void    pm_setup_adb(void);
void    pm_check_adb_devices(int);
int     pm_adb_op(u_char *, adbComp *, volatile int *, int);

/* these functions also use the variables of adb_direct.c */
void    pm_adb_get_TALK_result(PMData *);
void    pm_adb_get_ADB_data(PMData *);


/*
 * These variables are in adb_direct.c.
 */
extern u_char   *adbBuffer;     /* pointer to user data area */
extern adbComp  *adbCompRout;   /* pointer to the completion routine */
extern volatile int *adbCompData;       /* pointer to the completion routine data */
extern int      adbWaiting;     /* waiting for return data from the device */
extern int      adbWaitingCmd;  /* ADB command we are waiting for */
extern int      adbStarting;    /* doing ADB reinit, so do "polling" differently */

#define ADB_MAX_MSG_LENGTH      16
#define ADB_MAX_HDR_LENGTH      8
struct adbCommand {
        u_char  header[ADB_MAX_HDR_LENGTH];     /* not used yet */
        u_char  data[ADB_MAX_MSG_LENGTH];       /* packet data only */
        u_char  *saveBuf;       /* where to save result */
        adbComp *compRout;      /* completion routine pointer */
        volatile int    *compData;      /* completion routine data pointer */
        u_int   cmd;            /* the original command for this data */
        u_int   unsol;          /* 1 if packet was unsolicited */
        u_int   ack_only;       /* 1 for no special processing */
};
extern  void    adb_pass_up(struct adbCommand *);

#if 0
/*
 * Define the external functions
 */
extern int      zshard(int);            /* from zs.c */
#endif

#ifdef ADB_DEBUG
/*
 * This function dumps contents of the PMData
 */
void
pm_printerr(const char *ttl, int rval, int num, const char *data)
{
        int i;

        printf("pm: %s:%04x %02x ", ttl, rval, num);
        for (i = 0; i < num; i++)
                printf("%02x ", data[i]);
        printf("\n");
}
#endif



/*
 * Check the hardware type of the Power Manager
 */
void
pm_setup_adb(void)
{
}

/*
 * Search for targ in list.  list is an area of listlen bytes
 * containing null-terminated strings.
 */
static int
strinlist(const char *targ, char *list, int listlen)
{
        char    *str;
        int     sl;
        int     targlen;

        str = list;
        targlen = strlen(targ);
        while (listlen > 0) {
                sl = strlen(str);
                if (sl == targlen && (strncmp(targ, str, sl) == 0))
                        return 1;
                str += sl+1;
                listlen -= sl+1;
        }
        return 0;
}

/*
 * Check the hardware type of the Power Manager
 */
void
pm_init(void)
{
        uint32_t        regs[10];
        PMData          pmdata;
        char            compat[128];
        int             clen, node, pm_imask;

        node = OF_peer(0);
        if (node == -1) {
                printf("pmu: Failed to get root");
                return;
        }
        clen = OF_getprop(node, "compatible", compat, sizeof(compat));
        if (clen <= 0) {
                printf("pmu: failed to read root compatible data %d\n", clen);
                return;
        }

        pm_imask =
            PMU_INT_PCEJECT | PMU_INT_SNDBRT | PMU_INT_ADB | PMU_INT_TICK;

        if (strinlist("AAPL,3500", compat, clen) ||
            strinlist("AAPL,3400/2400", compat, clen)) {
                /* How to distinguish BATT_COMET? */
                pmu_nbatt = 1;
                pmu_batt_type = BATT_HOOPER;
                pmu_type = PMU_OHARE;
        } else if (strinlist("AAPL,PowerBook1998", compat, clen) ||
                   strinlist("PowerBook1,1", compat, clen)) {
                pmu_nbatt = 2;
                pmu_batt_type = BATT_SMART;
                pmu_type = PMU_G3;
        } else {
                pmu_nbatt = 1;
                pmu_batt_type = BATT_SMART;
                pmu_type = PMU_KEYLARGO;
                node = of_getnode_byname(0, "power-mgt");
                if (node == -1) {
                        printf("pmu: can't find power-mgt\n");
                        return;
                }
                clen = OF_getprop(node, "prim-info", regs, sizeof(regs));
                if (clen < 24) {
                        printf("pmu: failed to read prim-info\n");
                        return;
                }
                pmu_nbatt = regs[6] >> 16;
        }

        pmdata.command = PMU_SET_IMASK;
        pmdata.num_data = 1;
        pmdata.s_buf = pmdata.data;
        pmdata.r_buf = pmdata.data;
        pmdata.data[0] = pm_imask;      
        pmgrop(&pmdata);
}


/*
 * Check the existent ADB devices
 */
void
pm_check_adb_devices(int id)
{
        u_short ed = 0x1;

        ed <<= id;
        pm_existent_ADB_devices |= ed;
}


/*
 * Wait until PM IC is busy
 */
int
pm_wait_busy(int delaycycles)
{
        while (PM_IS_ON) {
#ifdef PM_GRAB_SI
#if 0
                zshard(0);              /* grab any serial interrupts */
#else
                (void)intr_dispatch(0x70);
#endif
#endif
                if ((--delaycycles) < 0)
                        return 1;       /* timeout */
        }
        return 0;
}


/*
 * Wait until PM IC is free
 */
int
pm_wait_free(int delaycycles)
{
        while (PM_IS_OFF) {
#ifdef PM_GRAB_SI
#if 0
                zshard(0);              /* grab any serial interrupts */
#else
                (void)intr_dispatch(0x70);
#endif
#endif
                if ((--delaycycles) < 0)
                        return 0;       /* timeout */
        }
        return 1;
}



/*
 * Receive data from PMU
 */
static int
pm_receive(u_char *data)
{
        int i;
        int rval;

        rval = 0xffffcd34;

        switch (1) {
        default:
                /* set VIA SR to input mode */
                via_reg_or(VIA1, vACR, 0x0c);
                via_reg_and(VIA1, vACR, ~0x10);
                i = PM_SR();

                PM_SET_STATE_ACKOFF();
                if (pm_wait_busy((int)ADBDelay*32) != 0)
                        break;          /* timeout */

                PM_SET_STATE_ACKON();
                rval = 0xffffcd33;
                if (pm_wait_free((int)ADBDelay*32) == 0)
                        break;          /* timeout */

                *data = PM_SR();
                rval = 0;

                break;
        }

        PM_SET_STATE_ACKON();
        via_reg_or(VIA1, vACR, 0x1c);

        return rval;
}       



/*
 * Send data to PMU
 */
static int
pm_send(u_char data)
{
        int rval;

        via_reg_or(VIA1, vACR, 0x1c);
        write_via_reg(VIA1, vSR, data); /* PM_SR() = data; */

        PM_SET_STATE_ACKOFF();
        rval = 0xffffcd36;
        if (pm_wait_busy((int)ADBDelay*32) != 0) {
                PM_SET_STATE_ACKON();

                via_reg_or(VIA1, vACR, 0x1c);

                return rval;            
        }

        PM_SET_STATE_ACKON();
        rval = 0xffffcd35;
        if (pm_wait_free((int)ADBDelay*32) != 0)
                rval = 0;

        PM_SET_STATE_ACKON();
        via_reg_or(VIA1, vACR, 0x1c);

        return rval;
}



/*
 * The PMgrOp routine
 */
int
pmgrop(PMData *pmdata)
{
        int i;
        int s;
        u_char via1_vIER;
        int rval = 0;
        int num_pm_data = 0;
        u_char pm_cmd;  
        short pm_num_rx_data;
        u_char pm_data;
        u_char *pm_buf;

        s = splhigh();

        /* disable all interrupts but PM */
        via1_vIER = 0x10;
        via1_vIER &= read_via_reg(VIA1, vIER);
        write_via_reg(VIA1, vIER, via1_vIER);
        if (via1_vIER != 0x0)
                via1_vIER |= 0x80;

        switch (pmdata->command) {
        default:
                /* wait until PM is free */
                pm_cmd = (u_char)(pmdata->command & 0xff);
                rval = 0xcd38;
                if (pm_wait_free(ADBDelay * 4) == 0)
                        break;                  /* timeout */

                /* send PM command */
                if ((rval = pm_send((u_char)(pm_cmd & 0xff))))
                        break;                          /* timeout */

                /* send number of PM data */
                num_pm_data = pmdata->num_data;
                if (pm_send_cmd_type[pm_cmd] < 0) {
                        if ((rval = pm_send((u_char)(num_pm_data & 0xff))) != 0)
                                break;          /* timeout */
                        pmdata->command = 0;
                }
                /* send PM data */
                pm_buf = (u_char *)pmdata->s_buf;
                for (i = 0 ; i < num_pm_data; i++)
                        if ((rval = pm_send(pm_buf[i])) != 0)
                                break;                  /* timeout */
                if (i != num_pm_data)
                        break;                          /* timeout */


                /* check if PM will send me data  */
                pm_num_rx_data = pm_receive_cmd_type[pm_cmd];
                pmdata->num_data = pm_num_rx_data;
                if (pm_num_rx_data == 0) {
                        rval = 0;
                        break;                          /* no return data */
                }

                /* receive PM command */
                pm_data = pmdata->command;
                pm_num_rx_data--;
                if (pm_num_rx_data == 0)
                        if ((rval = pm_receive(&pm_data)) != 0) {
                                rval = 0xffffcd37;
                                break;
                        }
                pmdata->command = pm_data;

                /* receive number of PM data */
                if (pm_num_rx_data < 0) {
                        if ((rval = pm_receive(&pm_data)) != 0)
                                break;          /* timeout */
                        num_pm_data = pm_data;
                } else
                        num_pm_data = pm_num_rx_data;
                pmdata->num_data = num_pm_data;

                /* receive PM data */
                pm_buf = (u_char *)pmdata->r_buf;
                for (i = 0; i < num_pm_data; i++) {
                        if ((rval = pm_receive(&pm_data)) != 0)
                                break;                  /* timeout */
                        pm_buf[i] = pm_data;
                }

                rval = 0;
        }

        /* restore former value */
        write_via_reg(VIA1, vIER, via1_vIER);
        splx(s);

        return rval;
}


/*
 * My PMU interrupt routine
 */
int
pm_intr(void *arg)
{
        int s;
        int rval;
        PMData pmdata;

        s = splhigh();

        PM_VIA_CLR_INTR();                      /* clear VIA1 interrupt */
                                                /* ask PM what happened */
        pmdata.command = PMU_INT_ACK;
        pmdata.num_data = 0;
        pmdata.s_buf = &pmdata.data[2];
        pmdata.r_buf = &pmdata.data[2];
        rval = pmgrop(&pmdata);
        if (rval != 0) {
#ifdef ADB_DEBUG
                if (adb_debug)
                        printf("pm: PM is not ready. error code: %08x\n", rval);
#endif
                splx(s);
                return 0;
        }

        switch ((u_int)(pmdata.data[2] & 0xff)) {
        case 0x00:              /* no event pending? */
                break;
        case 0x80:              /* 1 sec interrupt? */
                pm_counter++;
                break;
        case 0x08:              /* Brightness/Contrast button on LCD panel */
                /* get brightness and contrast of the LCD */
                pm_LCD_brightness = (u_int)pmdata.data[3] & 0xff;
                pm_LCD_contrast = (u_int)pmdata.data[4] & 0xff;

                /* this is experimental code */
                pmdata.command = PMU_SET_BRIGHTNESS;
                pmdata.num_data = 1;
                pmdata.s_buf = pmdata.data;
                pmdata.r_buf = pmdata.data;
                pm_LCD_brightness = 0x7f - pm_LCD_brightness / 2;
                if (pm_LCD_brightness < 0x08)
                        pm_LCD_brightness = 0x08;
                if (pm_LCD_brightness > 0x78)
                        pm_LCD_brightness = 0x78;
                pmdata.data[0] = pm_LCD_brightness;
                rval = pmgrop(&pmdata);
                break;

        case 0x10:              /* ADB data requested by TALK command */
        case 0x14:
                pm_adb_get_TALK_result(&pmdata);
                break;
        case 0x16:              /* ADB device event */
        case 0x18:
        case 0x1e:
                pm_adb_get_ADB_data(&pmdata);
                break;
        default:
#ifdef ADB_DEBUG
                if (adb_debug)
                        pm_printerr("driver does not support this event.",
                            pmdata.data[2], pmdata.num_data,
                            pmdata.data);
#endif
                break;
        }

        splx(s);

        return 1;
}


/*
 * Synchronous ADBOp routine for the Power Manager
 */
int
pm_adb_op(u_char *buffer, adbComp *compRout, volatile int *data, int command)
{
        int i;
        int s;
        int rval;
        int timo;
        PMData pmdata;
        struct adbCommand packet;

        if (adbWaiting == 1)
                return 1;

        s = splhigh();
        write_via_reg(VIA1, vIER, 0x10);

        adbBuffer = buffer;
        adbCompRout = compRout;
        adbCompData = data;

        pmdata.command = PMU_ADB_CMD;
        pmdata.s_buf = pmdata.data;
        pmdata.r_buf = pmdata.data;

        /* if the command is LISTEN, add number of ADB data to number of PM data */
        if ((command & 0xc) == 0x8) {
                if (buffer != (u_char *)0)
                        pmdata.num_data = buffer[0] + 3;
        } else {
                pmdata.num_data = 3;
        }

        pmdata.data[0] = (u_char)(command & 0xff);
        pmdata.data[1] = 0;
        if ((command & 0xc) == 0x8) {           /* if the command is LISTEN, copy ADB data to PM buffer */
                if ((buffer != (u_char *)0) && (buffer[0] <= 24)) {
                        pmdata.data[2] = buffer[0];             /* number of data */
                        for (i = 0; i < buffer[0]; i++)
                                pmdata.data[3 + i] = buffer[1 + i];
                } else
                        pmdata.data[2] = 0;
        } else
                pmdata.data[2] = 0;

        if ((command & 0xc) != 0xc) {           /* if the command is not TALK */
                /* set up stuff for adb_pass_up */
                packet.data[0] = 1 + pmdata.data[2];
                packet.data[1] = command;
                for (i = 0; i < pmdata.data[2]; i++)
                        packet.data[i+2] = pmdata.data[i+3];
                packet.saveBuf = adbBuffer;
                packet.compRout = adbCompRout;
                packet.compData = adbCompData;
                packet.cmd = command;
                packet.unsol = 0;
                packet.ack_only = 1;
                adb_polling = 1;
                adb_pass_up(&packet);
                adb_polling = 0;
        }

        rval = pmgrop(&pmdata);
        if (rval != 0) {
                splx(s);
                return 1;
        }

        delay(10000);

        adbWaiting = 1;
        adbWaitingCmd = command;

        PM_VIA_INTR_ENABLE();

        /* wait until the PM interrupt has occurred */
        timo = 0x80000;
        while (adbWaiting == 1) {
                if (read_via_reg(VIA1, vIFR) & 0x14)
                        pm_intr(NULL);
#ifdef PM_GRAB_SI
#if 0
                        zshard(0);              /* grab any serial interrupts */
#else
                        (void)intr_dispatch(0x70);
#endif
#endif
                if ((--timo) < 0) {
                        /* Try to take an interrupt anyway, just in case.
                         * This has been observed to happen on my ibook
                         * when i press a key after boot and before adb
                         * is attached;  For example, when booting with -d.
                         */
                        pm_intr(NULL);
                        if (adbWaiting) {
                                printf("pm_adb_op: timeout. command = 0x%x\n",command);
                                splx(s);
                                return 1;
                        }
#ifdef ADB_DEBUG
                        else {
                                printf("pm_adb_op: missed interrupt. cmd=0x%x\n",command);
                        }
#endif
                }
        }

        /* this command enables the interrupt by operating ADB devices */
        pmdata.command = PMU_ADB_CMD;
        pmdata.num_data = 4;
        pmdata.s_buf = pmdata.data;
        pmdata.r_buf = pmdata.data;
        pmdata.data[0] = 0x00;  
        pmdata.data[1] = 0x86;  /* magic spell for awaking the PM */
        pmdata.data[2] = 0x00;  
        pmdata.data[3] = 0x0c;  /* each bit may express the existent ADB device */
        rval = pmgrop(&pmdata);

        splx(s);
        return rval;
}


void
pm_adb_get_TALK_result(PMData *pmdata)
{
        int i;
        struct adbCommand packet;

        /* set up data for adb_pass_up */
        packet.data[0] = pmdata->num_data-1;
        packet.data[1] = pmdata->data[3];
        for (i = 0; i <packet.data[0]-1; i++)
                packet.data[i+2] = pmdata->data[i+4];

        packet.saveBuf = adbBuffer;
        packet.compRout = adbCompRout;
        packet.compData = adbCompData;
        packet.unsol = 0;
        packet.ack_only = 0;
        adb_polling = 1;
        adb_pass_up(&packet);
        adb_polling = 0;

        adbWaiting = 0;
        adbBuffer = (long)0;
        adbCompRout = (long)0;
        adbCompData = (long)0;
}


void
pm_adb_get_ADB_data(PMData *pmdata)
{
        int i;
        struct adbCommand packet;

        if (pmu_type == PMU_OHARE && pmdata->num_data == 4 &&
            pmdata->data[1] == 0x2c && pmdata->data[3] == 0xff &&
            ((pmdata->data[2] & ~1) == 0xf4)) {
                if (pmdata->data[2] == 0xf4) {
                        pm_eject_pcmcia(0);
                } else {
                        pm_eject_pcmcia(1);
                }
                return;
        }
        /* set up data for adb_pass_up */
        packet.data[0] = pmdata->num_data-1;    /* number of raw data */
        packet.data[1] = pmdata->data[3];       /* ADB command */
        for (i = 0; i <packet.data[0]-1; i++)
                packet.data[i+2] = pmdata->data[i+4];
        packet.unsol = 1;
        packet.ack_only = 0;
        adb_pass_up(&packet);
}


void
pm_adb_restart(void)
{
        PMData p;

        p.command = PMU_RESET_CPU;
        p.num_data = 0;
        p.s_buf = p.data;
        p.r_buf = p.data;
        pmgrop(&p);
}

void
pm_adb_poweroff(void)
{
        PMData p;

        p.command = PMU_POWER_OFF;
        p.num_data = 4;
        p.s_buf = p.data;
        p.r_buf = p.data;
        strcpy(p.data, "MATT");
        pmgrop(&p);
}

void
pm_read_date_time(u_long *t)
{
        PMData p;

        p.command = PMU_READ_RTC;
        p.num_data = 0;
        p.s_buf = p.data;
        p.r_buf = p.data;
        pmgrop(&p);

        memcpy(t, p.data, 4);
}

void
pm_set_date_time(u_long t)
{
        PMData p;

        p.command = PMU_SET_RTC;
        p.num_data = 4;
        p.s_buf = p.r_buf = p.data;
        memcpy(p.data, &t, 4);
        pmgrop(&p);
}

int
pm_read_brightness(void)
{
        PMData p;

        p.command = PMU_READ_BRIGHTNESS;
        p.num_data = 1;         /* XXX why 1? */
        p.s_buf = p.r_buf = p.data;
        p.data[0] = 0;
        pmgrop(&p);

        return p.data[0];
}

void
pm_set_brightness(int val)
{
        PMData p;

        val = 0x7f - val / 2;
        if (val < 0x08)
                val = 0x08;
        if (val > 0x78)
                val = 0x78;

        p.command = PMU_SET_BRIGHTNESS;
        p.num_data = 1;
        p.s_buf = p.r_buf = p.data;
        p.data[0] = val;
        pmgrop(&p);
}

void
pm_init_brightness(void)
{
        int val;

        val = pm_read_brightness();
        pm_set_brightness(val);
}

void
pm_eject_pcmcia(int slot)
{
        PMData p;

        if (slot != 0 && slot != 1)
                return;

        p.command = PMU_EJECT_PCMCIA;
        p.num_data = 1;
        p.s_buf = p.r_buf = p.data;
        p.data[0] = 5 + slot;   /* XXX */
        pmgrop(&p);
}

/*
 * Thanks to Paul Mackerras and Fabio Riccardi's Linux implementation
 * for a clear description of the PMU results.
 */
static int
pm_battery_info_smart(int battery, struct pmu_battery_info *info)
{
        PMData p;

        p.command = PMU_SMART_BATTERY_STATE;
        p.num_data = 1;
        p.s_buf = p.r_buf = p.data;
        p.data[0] = battery + 1;
        pmgrop(&p);

        info->flags = p.data[1];

        info->secs_remaining = 0;
        switch (p.data[0]) {
        case 3:
        case 4:
                info->cur_charge = p.data[2];
                info->max_charge = p.data[3];
                info->draw = *((signed char *)&p.data[4]);
                info->voltage = p.data[5];
                break;
        case 5:
                info->cur_charge = ((p.data[2] << 8) | (p.data[3]));
                info->max_charge = ((p.data[4] << 8) | (p.data[5]));
                info->draw = *((signed short *)&p.data[6]);
                info->voltage = ((p.data[8] << 8) | (p.data[7]));
                break;
        default:
                /* XXX - Error condition */
                info->cur_charge = 0;
                info->max_charge = 0;
                info->draw = 0;
                info->voltage = 0;
                break;
        }
        if (info->draw) {
                if (info->flags & PMU_PWR_AC_PRESENT && info->draw > 0) {
                        info->secs_remaining =
                                ((info->max_charge - info->cur_charge) * 3600)
                                / info->draw;
                } else {
                        info->secs_remaining =
                                (info->cur_charge * 3600) / -info->draw;
                }
        }

        return 1;
}

static int
pm_battery_info_legacy(int battery, struct pmu_battery_info *info, int ty)
{
        PMData p;
        long pcharge=0, charge, vb, vmax, chargemax;
        long vmax_charging, vmax_charged, amperage, voltage;

        p.command = PMU_BATTERY_STATE;
        p.num_data = 0;
        p.s_buf = p.r_buf = p.data;
        pmgrop(&p);

        info->flags = p.data[0];

        if (info->flags & PMU_PWR_BATT_PRESENT) {
                if (ty == BATT_COMET) {
                        vmax_charging = 213;
                        vmax_charged = 189;
                        chargemax = 6500;
                } else {
                        /* Experimental values */
                        vmax_charging = 365;
                        vmax_charged = 365;
                        chargemax = 6500;
                }
                vmax = vmax_charged;
                vb = (p.data[1] << 8) | p.data[2];
                voltage = (vb * 256 + 72665) / 10;
                amperage = (unsigned char) p.data[5];
                if ((info->flags & PMU_PWR_AC_PRESENT) == 0) {
                        if (amperage > 200)
                                vb += ((amperage - 200) * 15)/100;
                } else if (info->flags & PMU_PWR_BATT_CHARGING) {
                        vb = (vb * 97) / 100;
                        vmax = vmax_charging;
                }
                charge = (100 * vb) / vmax;
                if (info->flags & PMU_PWR_PCHARGE_RESET) {
                        pcharge = (p.data[6] << 8) | p.data[7];
                        if (pcharge > chargemax)
                                pcharge = chargemax;
                        pcharge *= 100;
                        pcharge = 100 - pcharge / chargemax;
                        if (pcharge < charge)
                                charge = pcharge;
                }
                info->cur_charge = charge;
                info->max_charge = 100;
                info->draw = -amperage;
                info->voltage = voltage;
                if (amperage > 0)
                        info->secs_remaining = (charge * 16440) / amperage;
                else
                        info->secs_remaining = 0;
        } else {
                info->cur_charge = 0;
                info->max_charge = 0;
                info->draw = 0;
                info->voltage = 0;
                info->secs_remaining = 0;
        }

        return 1;
}

int
pm_battery_info(int battery, struct pmu_battery_info *info)
{

        if (battery > pmu_nbatt)
                return 0;

        switch (pmu_batt_type) {
        case BATT_COMET:
        case BATT_HOOPER:
                return pm_battery_info_legacy(battery, info, pmu_batt_type);

        case BATT_SMART:
                return pm_battery_info_smart(battery, info);
        }

        return 0;
}

int
pm_read_nvram(int addr)
{
        PMData p;

        p.command = PMU_READ_NVRAM;
        p.num_data = 2;
        p.s_buf = p.r_buf = p.data;
        p.data[0] = addr >> 8;
        p.data[1] = addr;
        pmgrop(&p);

        return p.data[0];
}

void
pm_write_nvram(int addr, int val)
{
        PMData p;

        p.command = PMU_WRITE_NVRAM;
        p.num_data = 3;
        p.s_buf = p.r_buf = p.data;
        p.data[0] = addr >> 8;
        p.data[1] = addr;
        p.data[2] = val;
        pmgrop(&p);
}