/*
 * Device driver for the via-pmu on Apple Powermacs.
 *
 * The VIA (versatile interface adapter) interfaces to the PMU,
 * a 6805 microprocessor core whose primary function is to control
 * battery charging and system power on the PowerBook 3400 and 2400.
 * The PMU also controls the ADB (Apple Desktop Bus) which connects
 * to the keyboard and mouse, as well as the non-volatile RAM
 * and the RTC (real time clock) chip.
 *
 * Copyright (C) 1998 Paul Mackerras and Fabio Riccardi.
 * Copyright (C) 2001-2002 Benjamin Herrenschmidt
 * Copyright (C) 2006-2007 Johannes Berg
 *
 */

#include "config.h"
#include "libopenbios/bindings.h"
#include "drivers/drivers.h"
#include "libc/byteorder.h"
#include "libc/vsprintf.h"

#include "macio.h"
#include "pmu.h"

#undef DEBUG_PMU
#ifdef DEBUG_PMU
#define PMU_DPRINTF(fmt, args...) \
	do { printk("PMU - %s: " fmt, __func__ , ##args); } while (0)
#else
#define PMU_DPRINTF(fmt, args...) do { } while (0)
#endif

#define IO_PMU_OFFSET	0x00016000
#define IO_PMU_SIZE	0x00002000

/* VIA registers - spaced 0x200 bytes apart */
#define RS              0x200           /* skip between registers */
#define B               0               /* B-side data */
#define A               RS              /* A-side data */
#define DIRB            (2*RS)          /* B-side direction (1=output) */
#define DIRA            (3*RS)          /* A-side direction (1=output) */
#define T1CL            (4*RS)          /* Timer 1 ctr/latch (low 8 bits) */
#define T1CH            (5*RS)          /* Timer 1 counter (high 8 bits) */
#define T1LL            (6*RS)          /* Timer 1 latch (low 8 bits) */
#define T1LH            (7*RS)          /* Timer 1 latch (high 8 bits) */
#define T2CL            (8*RS)          /* Timer 2 ctr/latch (low 8 bits) */
#define T2CH            (9*RS)          /* Timer 2 counter (high 8 bits) */
#define SR              (10*RS)         /* Shift register */
#define ACR             (11*RS)         /* Auxiliary control register */
#define PCR             (12*RS)         /* Peripheral control register */
#define IFR             (13*RS)         /* Interrupt flag register */
#define IER             (14*RS)         /* Interrupt enable register */
#define ANH             (15*RS)         /* A-side data, no handshake */

/* Bits in B data register: all active low */
#define TACK		0x08		/* Transfer request (input) */
#define TREQ		0x10		/* Transfer acknowledge (output) */

/* Bits in ACR */
#define SR_CTRL         0x1c            /* Shift register control bits */
#define SR_EXT          0x0c            /* Shift on external clock */
#define SR_OUT          0x10            /* Shift out if 1 */

/* Bits in IFR and IER */
#define IER_SET         0x80            /* set bits in IER */
#define IER_CLR         0               /* clear bits in IER */
#define SR_INT          0x04            /* Shift register full/empty */

/*
 * This table indicates for each PMU opcode:
 * - the number of data bytes to be sent with the command, or -1
 *   if a length byte should be sent,
 * - the number of response bytes which the PMU will return, or
 *   -1 if it will send a length byte.
 */
static const int8_t pmu_data_len[256][2] = {
/*	   0	   1	   2	   3	   4	   5	   6	   7  */
/*00*/  {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*08*/  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
/*10*/  { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*18*/  { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0, 0},
/*20*/  {-1, 0},{ 0, 0},{ 2, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},
/*28*/  { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{ 0,-1},
/*30*/  { 4, 0},{20, 0},{-1, 0},{ 3, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*38*/  { 0, 4},{ 0,20},{ 2,-1},{ 2, 1},{ 3,-1},{-1,-1},{-1,-1},{ 4, 0},
/*40*/  { 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*48*/  { 0, 1},{ 0, 1},{-1,-1},{ 1, 0},{ 1, 0},{-1,-1},{-1,-1},{-1,-1},
/*50*/  { 1, 0},{ 0, 0},{ 2, 0},{ 2, 0},{-1, 0},{ 1, 0},{ 3, 0},{ 1, 0},
/*58*/  { 0, 1},{ 1, 0},{ 0, 2},{ 0, 2},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},
/*60*/  { 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*68*/  { 0, 3},{ 0, 3},{ 0, 2},{ 0, 8},{ 0,-1},{ 0,-1},{-1,-1},{-1,-1},
/*70*/  { 1, 0},{ 1, 0},{ 1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*78*/  { 0,-1},{ 0,-1},{-1,-1},{-1,-1},{-1,-1},{ 5, 1},{ 4, 1},{ 4, 1},
/*80*/  { 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*88*/  { 0, 5},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
/*90*/  { 1, 0},{ 2, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*98*/  { 0, 1},{ 0, 1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
/*a0*/  { 2, 0},{ 2, 0},{ 2, 0},{ 4, 0},{-1, 0},{ 0, 0},{-1, 0},{-1, 0},
/*a8*/  { 1, 1},{ 1, 0},{ 3, 0},{ 2, 0},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
/*b0*/  {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*b8*/  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
/*c0*/  {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*c8*/  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
/*d0*/  { 0, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*d8*/  { 1, 1},{ 1, 1},{-1,-1},{-1,-1},{ 0, 1},{ 0,-1},{-1,-1},{-1,-1},
/*e0*/  {-1, 0},{ 4, 0},{ 0, 1},{-1, 0},{-1, 0},{ 4, 0},{-1, 0},{-1, 0},
/*e8*/  { 3,-1},{-1,-1},{ 0, 1},{-1,-1},{ 0,-1},{-1,-1},{-1,-1},{ 0, 0},
/*f0*/  {-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},{-1, 0},
/*f8*/  {-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},
};

/*
 * PMU commands
 */
#define PMU_POWER_CTRL0            0x10  /* control power of some devices */
#define PMU_POWER_CTRL             0x11  /* control power of some devices */
#define PMU_ADB_CMD                0x20  /* send ADB packet */
#define PMU_ADB_POLL_OFF           0x21  /* disable ADB auto-poll */
#define PMU_WRITE_NVRAM            0x33  /* write non-volatile RAM */
#define PMU_READ_NVRAM             0x3b  /* read non-volatile RAM */
#define PMU_SET_RTC                0x30  /* set real-time clock */
#define PMU_READ_RTC               0x38  /* read real-time clock */
#define PMU_SET_VOLBUTTON          0x40  /* set volume up/down position */
#define PMU_BACKLIGHT_BRIGHT       0x41  /* set backlight brightness */
#define PMU_GET_VOLBUTTON          0x48  /* get volume up/down position */
#define PMU_PCEJECT                0x4c  /* eject PC-card from slot */
#define PMU_BATTERY_STATE          0x6b  /* report battery state etc. */
#define PMU_SMART_BATTERY_STATE    0x6f  /* report battery state (new way) */
#define PMU_SET_INTR_MASK          0x70  /* set PMU interrupt mask */
#define PMU_INT_ACK                0x78  /* read interrupt bits */
#define PMU_SHUTDOWN               0x7e  /* turn power off */
#define PMU_CPU_SPEED              0x7d  /* control CPU speed on some models */
#define PMU_SLEEP                  0x7f  /* put CPU to sleep */
#define PMU_POWER_EVENTS           0x8f  /* Send power-event commands to PMU */
#define PMU_I2C_CMD                0x9a  /* I2C operations */
#define PMU_RESET                  0xd0  /* reset CPU */
#define PMU_GET_BRIGHTBUTTON       0xd9  /* report brightness up/down pos */
#define PMU_GET_COVER              0xdc  /* report cover open/closed */
#define PMU_SYSTEM_READY           0xdf  /* tell PMU we are awake */
#define PMU_GET_VERSION            0xea  /* read the PMU version */

/* Bits to use with the PMU_POWER_CTRL0 command */
#define PMU_POW0_ON                0x80  /* OR this to power ON the device */
#define PMU_POW0_OFF               0x00  /* leave bit 7 to 0 to power it OFF */
#define PMU_POW0_HARD_DRIVE        0x04  /* Hard drive power (on wallstreet/lombard ?) */

/* Bits to use with the PMU_POWER_CTRL command */
#define PMU_POW_ON                 0x80  /* OR this to power ON the device */
#define PMU_POW_OFF                0x00  /* leave bit 7 to 0 to power it OFF */
#define PMU_POW_BACKLIGHT          0x01  /* backlight power */
#define PMU_POW_CHARGER            0x02  /* battery charger power */
#define PMU_POW_IRLED              0x04  /* IR led power (on wallstreet) */
#define PMU_POW_MEDIABAY           0x08  /* media bay power (wallstreet/lombard ?) */

/* Bits in PMU interrupt and interrupt mask bytes */
#define PMU_INT_PCEJECT            0x04  /* PC-card eject buttons */
#define PMU_INT_SNDBRT             0x08  /* sound/brightness up/down buttons */
#define PMU_INT_ADB                0x10  /* ADB autopoll or reply data */
#define PMU_INT_BATTERY            0x20  /* Battery state change */
#define PMU_INT_ENVIRONMENT        0x40  /* Environment interrupts */
#define PMU_INT_TICK               0x80  /* 1-second tick interrupt */

/* Other bits in PMU interrupt valid when PMU_INT_ADB is set */
#define PMU_INT_ADB_AUTO           0x04  /* ADB autopoll, when PMU_INT_ADB */
#define PMU_INT_WAITING_CHARGER    0x01  /* ??? */
#define PMU_INT_AUTO_SRQ_POLL      0x02  /* ??? */

/* Bits in the environement message (either obtained via PMU_GET_COVER,
 * or via PMU_INT_ENVIRONMENT on core99 */
#define PMU_ENV_LID_CLOSED         0x01  /* The lid is closed */

/* I2C related definitions */
#define PMU_I2C_MODE_SIMPLE    0
#define PMU_I2C_MODE_STDSUB    1
#define PMU_I2C_MODE_COMBINED  2

#define PMU_I2C_BUS_STATUS     0
#define PMU_I2C_BUS_SYSCLK     1
#define PMU_I2C_BUS_POWER      2

#define PMU_I2C_STATUS_OK          0
#define PMU_I2C_STATUS_DATAREAD    1
#define PMU_I2C_STATUS_BUSY        0xfe

/* PMU PMU_POWER_EVENTS commands */
enum {
    PMU_PWR_GET_POWERUP_EVENTS = 0x00,
    PMU_PWR_SET_POWERUP_EVENTS = 0x01,
    PMU_PWR_CLR_POWERUP_EVENTS = 0x02,
    PMU_PWR_GET_WAKEUP_EVENTS  = 0x03,
    PMU_PWR_SET_WAKEUP_EVENTS  = 0x04,
    PMU_PWR_CLR_WAKEUP_EVENTS  = 0x05,
};

/* Power events wakeup bits */
enum {
    PMU_PWR_WAKEUP_KEY       = 0x01,  /* Wake on key press */
    PMU_PWR_WAKEUP_AC_INSERT = 0x02,  /* Wake on AC adapter plug */
    PMU_PWR_WAKEUP_AC_CHANGE = 0x04,
    PMU_PWR_WAKEUP_LID_OPEN  = 0x08,
    PMU_PWR_WAKEUP_RING      = 0x10,
};

static uint8_t pmu_readb(pmu_t *dev, int reg)
{
    return *(volatile uint8_t *)(dev->base + reg);
    asm volatile("eieio" : : : "memory");
}

static void pmu_writeb(pmu_t *dev, int reg, uint8_t val)
{
    *(volatile uint8_t *)(dev->base + reg) = val;
    asm volatile("eieio" : : : "memory");
}

static void pmu_handshake(pmu_t *dev)
{
    pmu_writeb(dev, B, pmu_readb(dev, B) & ~TREQ);
    while ((pmu_readb(dev, B) & TACK) != 0);

    pmu_writeb(dev, B, pmu_readb(dev, B) | TREQ);
    while ((pmu_readb(dev, B) & TACK) == 0);
}

static void pmu_send_byte(pmu_t *dev, uint8_t val)
{
    pmu_writeb(dev, ACR, pmu_readb(dev, ACR) | SR_OUT | SR_EXT);
    pmu_writeb(dev, SR, val);
    pmu_handshake(dev);
}

static uint8_t pmu_recv_byte(pmu_t *dev)
{
    pmu_writeb(dev, ACR, (pmu_readb(dev, ACR) & ~SR_OUT) | SR_EXT);
    pmu_readb(dev, SR);
    pmu_handshake(dev);

    return pmu_readb(dev, SR);
}

int pmu_request(pmu_t *dev, uint8_t cmd,
                uint8_t in_len, uint8_t *in_data,
                uint8_t *out_len, uint8_t *out_data)
{
    int i, l, out_sz;
    uint8_t d;

    /* Check command data size */
    l = pmu_data_len[cmd][0];
    if (l >= 0 && in_len != l) {
        printk("PMU: Error, request %02x wants %d args, got %d\n",
               cmd, l, in_len);
        return -1;
    }

    /* Make sure PMU is idle */
    while ((pmu_readb(dev, B) & TACK) == 0);

    /* Send command */
    pmu_send_byte(dev, cmd);

    /* Optionally send data length */
    if (l < 0) {
        pmu_send_byte(dev, in_len);
        /* Send data */
    }

    for (i = 0; i < in_len; i++) {
        pmu_send_byte(dev, in_data[i]);
    }

    /* Check response size */
    l = pmu_data_len[cmd][1];
    if (l < 0) {
        l = pmu_recv_byte(dev);
    }

    if (out_len) {
        out_sz = *out_len;
        *out_len = 0;
    } else {
        out_sz = 0;
    }

    if (l > out_sz) {
        printk("PMU: Error, request %02x returns %d bytes"
               ", room for %d\n", cmd, l, out_sz);
    }

    for (i = 0; i < l; i++) {
        d = pmu_recv_byte(dev);
        if (i < out_sz) {
            out_data[i] = d;
            (*out_len)++;
        }
    }

    return 0;
}

#define MAX_REQ_SIZE     128

#ifdef CONFIG_DRIVER_ADB
static int pmu_adb_req(void *host, const uint8_t *snd_buf, int len,
                       uint8_t *rcv_buf)
{
    uint8_t buffer[MAX_REQ_SIZE], *pos, olen;
    int rc;

    PMU_DPRINTF("pmu_adb_req: len=%d: %02x %02x %02x...\n",
                len, snd_buf[0], snd_buf[1], snd_buf[2]);

    if (len >= (MAX_REQ_SIZE - 1)) {
        printk("pmu_adb_req: too big ! (%d)\n", len);
        return -1;
    }

    buffer[0] = snd_buf[0];
    buffer[1] = 0; /* We don't do autopoll */
    buffer[2] = len - 1;

    if (len > 1) {
        memcpy(&buffer[3], &snd_buf[1], len - 1);
    }
    rc = pmu_request(host, PMU_ADB_CMD, len + 2, buffer, NULL, NULL);
    if (rc) {
        printk("PMU adb request failure %d\n", rc);
        return 0;
    }
    olen = MAX_REQ_SIZE;
    rc = pmu_request(host, PMU_INT_ACK, 0, NULL, &olen, buffer);
    if (rc) {
        printk("PMU intack request failure %d\n", rc);
        return 0;
    }
    PMU_DPRINTF("pmu_resp=%d int=0x%02x\n", olen, buffer[0]);
    if (olen <= 2) {
        return 0;
    } else {
        pos = &buffer[3];
        olen -= 3;
        PMU_DPRINTF("ADB resp: 0x%02x 0x%02x\n", buffer[3], buffer[4]);
    }
    memcpy(rcv_buf, pos, olen);

    return olen;
}
#endif

DECLARE_UNNAMED_NODE(ob_pmu, 0, sizeof(int));

static pmu_t *main_pmu;

static void pmu_reset_all(void)
{
    pmu_request(main_pmu, PMU_RESET, 0, NULL, NULL, NULL);
}

static void pmu_poweroff(void)
{
    uint8_t params[] = "MATT";

    pmu_request(main_pmu, PMU_SHUTDOWN, 4, params, NULL, NULL);
}

static void ob_pmu_open(int *idx)
{
    RET(-1);
}

static void ob_pmu_close(int *idx)
{
}

NODE_METHODS(ob_pmu) = {
    { "open",      ob_pmu_open },
    { "close",     ob_pmu_close },
};

DECLARE_UNNAMED_NODE(rtc, 0, sizeof(int));

static void rtc_open(int *idx)
{
    RET(-1);
}

static void rtc_close(int *idx)
{
}

/*
 * get-time ( -- second minute hour day month year )
 *
 */

static const int days_month[12] =
    { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
static const int days_month_leap[12] =
    { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

static inline int is_leap(int year)
{
    return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}

static void rtc_get_time(int *idx)
{
    uint8_t obuf[4], olen;
    ucell second, minute, hour, day, month, year;
    uint32_t now;
    int current;
    const int *days;

    olen = 4;
    pmu_request(main_pmu, PMU_READ_RTC, 0, NULL, &olen, obuf);

    /* seconds since 01/01/1904 */
    now = (obuf[0] << 24) + (obuf[1] << 16) + (obuf[2] << 8) + obuf[3];

    second =  now % 60;
    now /= 60;

    minute = now % 60;
    now /= 60;

    hour = now % 24;
    now /= 24;

    year = now * 100 / 36525;
    now -= year * 36525 / 100;
    year += 1904;

    days = is_leap(year) ?  days_month_leap : days_month;

    current = 0;
    month = 0;
    while (month < 12) {
        if (now <= current + days[month]) {
            break;
        }

        current += days[month];
        month++;
    }
    month++;

    day = now - current;

    PUSH(second);
    PUSH(minute);
    PUSH(hour);
    PUSH(day);
    PUSH(month);
    PUSH(year);
}

/*
 * set-time ( second minute hour day month year -- )
 *
 */

static  void rtc_set_time(int *idx)
{
    uint8_t ibuf[4];
    ucell second, minute, hour, day, month, year;
    const int *days;
    uint32_t now;
    unsigned int nb_days;
    int i;

    year = POP();
    month = POP();
    day = POP();
    hour = POP();
    minute = POP();
    second = POP();

    days = is_leap(year) ?  days_month_leap : days_month;
    nb_days = (year - 1904) * 36525 / 100 + day;
    for (i = 0; i < month - 1; i++) {
        nb_days += days[i];
    }

    now = (((nb_days * 24) + hour) * 60 + minute) * 60 + second;

    ibuf[0] = now >> 24;
    ibuf[1] = now >> 16;
    ibuf[2] = now >> 8;
    ibuf[3] = now;
    pmu_request(main_pmu, PMU_SET_RTC, 4, ibuf, NULL, NULL);
}

NODE_METHODS(rtc) = {
    { "open",      rtc_open },
    { "close",      rtc_close },
    { "get-time",  rtc_get_time },
    { "set-time",  rtc_set_time },
};

static void rtc_init(char *path)
{
    phandle_t aliases;
    char buf[128];

    push_str(path);
    fword("find-device");

    fword("new-device");

    push_str("rtc");
    fword("device-name");

    push_str("rtc");
    fword("device-type");

    push_str("rtc,via-pmu");
    fword("encode-string");
    push_str("compatible");
    fword("property");

    BIND_NODE_METHODS(get_cur_dev(), rtc);
    fword("finish-device");

    aliases = find_dev("/aliases");
    snprintf(buf, sizeof(buf), "%s/rtc", path);
    set_property(aliases, "rtc", buf, strlen(buf) + 1);
}

static void powermgt_init(char *path)
{
    phandle_t ph;

    push_str(path);
    fword("find-device");

    fword("new-device");

    push_str("power-mgt");
    fword("device-name");

    push_str("power-mgt");
    fword("device-type");

    push_str("via-pmu-99");
    fword("encode-string");
    push_str("compatible");
    fword("property");

    push_str("extint-gpio1");
    fword("encode-string");
    push_str("registry-name");
    fword("property");

    /* This is a bunch of magic "Feature" bits for which we only have
     * partial definitions from Darwin. These are taken from a
     * PowerMac3,1 device-tree. They are also identical in a
     * PowerMac5,1 "Cube". Note that more recent machines such as
     * the MacMini (PowerMac10,1) do not have this property, however
     * MacOS 9 seems to require it (it hangs during boot otherwise).
     */
    const char prim[] = { 0x00, 0x00, 0x00, 0xff,
                          0x00, 0x00, 0x00, 0x2c,
                          0x00, 0x03, 0x0d, 0x40,
                          /* Public PM features */
                          /* 0x00000001 : Wake timer supported */
                          /* 0x00000004 : Processor cycling supported */
                          /* 0x00000100 : Can wake on modem ring */
                          /* 0x00000200 : Has monitor dimming support */
                          /* 0x00000400 : Can program startup timer */
                          /* 0x00002000 : Supports wake on LAN */
                          /* 0x00004000 : Can wake on LID/case open */
                          /* 0x00008000 : Can power off PCI on sleep */
                          /* 0x00010000 : Supports deep sleep */
                          0x00, 0x01, 0xe7, 0x05,
                          /* Private PM features */
                          /* 0x00000400 : Supports ICT control */
                          /* 0x00001000 : Supports Idle2 in hardware */
                          /* 0x00002000 : Open case prevents sleep */
                          0x00, 0x00, 0x34, 0x00,
                          0x00, 0x00, 0x00, 0x00,
                          0x00, 0x00, /* # of batteries supported */
                          0x26, 0x0d,
                          0x46, 0x00, 0x02, 0x78,
                          0x78, 0x3c, 0x00 };

    ph = get_cur_dev();
    BIND_NODE_METHODS(ph, rtc);

    set_property(ph, "prim-info", prim, sizeof(prim));

    fword("finish-device");
}

pmu_t *pmu_init(const char *path, phys_addr_t base)
{
    pmu_t *pmu;
    char buf[64];
    phandle_t aliases;

    base += IO_PMU_OFFSET;
    PMU_DPRINTF(" base=" FMT_plx "\n", base);

    pmu = malloc(sizeof(pmu_t));
    if (pmu == NULL) {
        return NULL;
    }

    fword("new-device");

    push_str("via-pmu");
    fword("device-name");

    push_str("via-pmu");
    fword("device-type");

    push_str("pmu");
    fword("encode-string");
    push_str("compatible");
    fword("property");

    PUSH(1);
    fword("encode-int");
    push_str("#address-cells");
    fword("property");

    PUSH(0);
    fword("encode-int");
    push_str("#size-cells");
    fword("property");

    PUSH(IO_PMU_OFFSET);
    fword("encode-int");
    PUSH(IO_PMU_SIZE);
    fword("encode-int");
    fword("encode+");
    push_str("reg");
    fword("property");

    /* On newworld machines the PMU is on interrupt 0x19 */
    PUSH(0x19);
    fword("encode-int");
    PUSH(1);
    fword("encode-int");
    fword("encode+");
    push_str("interrupts");
    fword("property");

    PUSH(0xd0330c);
    fword("encode-int");
    push_str("pmu-version");
    fword("property");

    BIND_NODE_METHODS(get_cur_dev(), ob_pmu);

    aliases = find_dev("/aliases");
    snprintf(buf, sizeof(buf), "%s/via-pmu", path);
    set_property(aliases, "via-pmu", buf, strlen(buf) + 1);
    pmu->base = base;

#ifdef CONFIG_DRIVER_ADB
    if (has_adb()) {
       pmu->adb_bus = adb_bus_new(pmu, &pmu_adb_req);
       adb_bus_init(buf, pmu->adb_bus);
    }
#endif

    rtc_init(buf);
    powermgt_init(buf);

    main_pmu = pmu;

    fword("finish-device");

    bind_func("pmu-power-off", pmu_poweroff);
    feval("['] pmu-power-off to power-off");
    bind_func("pmu-reset-all", pmu_reset_all);
    feval("['] pmu-reset-all to reset-all");

    return pmu;
}