OpenBSD 6.0 cannot boot on PowerMac 11,2

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
10 messages Options
TCH
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

OpenBSD 6.0 cannot boot on PowerMac 11,2

TCH
Hi.

I've just installed OpenBSD on my PowerMac 11,2. The install was
successfully done, but when i try to boot it, then in the middle of the
boot, it stops with the following message:

smu0 at mainbus0: cannot map smu-doorbell gpio

and then it stops and freezes. Slowly after this, the fans in the
machine are roars up and they begin to blow like hell.

Any ideas on this?

- TCH

Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

Super Bisquit
ftp://ftp.stu.edu.tw/BSD/OpenBSD/src/sys/arch/macppc/dev/smu.c
and for cross reference

/*-
 * Copyright (c) 2009 Nathan Whitehorn
 * 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.
 *
 * 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.
 *
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD: head/sys/powerpc/powermac/smu.c 273377 2014-10-21
07:31:21Z hselasky $");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/systm.h>
#include <sys/module.h>
#include <sys/conf.h>
#include <sys/cpu.h>
#include <sys/clock.h>
#include <sys/ctype.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/reboot.h>
#include <sys/rman.h>
#include <sys/sysctl.h>
#include <sys/unistd.h>

#include <machine/bus.h>
#include <machine/intr_machdep.h>
#include <machine/md_var.h>

#include <dev/iicbus/iicbus.h>
#include <dev/iicbus/iiconf.h>
#include <dev/led/led.h>
#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>
#include <powerpc/powermac/macgpiovar.h>
#include <powerpc/powermac/powermac_thermal.h>

#include "clock_if.h"
#include "iicbus_if.h"

struct smu_cmd {
    volatile uint8_t cmd;
    uint8_t        len;
    uint8_t        data[254];

    STAILQ_ENTRY(smu_cmd) cmd_q;
};

STAILQ_HEAD(smu_cmdq, smu_cmd);

struct smu_fan {
    struct pmac_fan fan;
    device_t dev;
    cell_t    reg;

    enum {
        SMU_FAN_RPM,
        SMU_FAN_PWM
    } type;
    int    setpoint;
    int    old_style;
    int     rpm;
};

/* We can read the PWM and the RPM from a PWM controlled fan.
 * Offer both values via sysctl.
 */
enum {
    SMU_PWM_SYSCTL_PWM   = 1 << 8,
    SMU_PWM_SYSCTL_RPM   = 2 << 8
};

struct smu_sensor {
    struct pmac_therm therm;
    device_t dev;

    cell_t    reg;
    enum {
        SMU_CURRENT_SENSOR,
        SMU_VOLTAGE_SENSOR,
        SMU_POWER_SENSOR,
        SMU_TEMP_SENSOR
    } type;
};

struct smu_softc {
    device_t    sc_dev;
    struct mtx    sc_mtx;

    struct resource    *sc_memr;
    int        sc_memrid;
    int        sc_u3;

    bus_dma_tag_t    sc_dmatag;
    bus_space_tag_t    sc_bt;
    bus_space_handle_t sc_mailbox;

    struct smu_cmd    *sc_cmd, *sc_cur_cmd;
    bus_addr_t    sc_cmd_phys;
    bus_dmamap_t    sc_cmd_dmamap;
    struct smu_cmdq    sc_cmdq;

    struct smu_fan    *sc_fans;
    int        sc_nfans;
    int        old_style_fans;
    struct smu_sensor *sc_sensors;
    int        sc_nsensors;

    int        sc_doorbellirqid;
    struct resource    *sc_doorbellirq;
    void        *sc_doorbellirqcookie;

    struct proc    *sc_fanmgt_proc;
    time_t        sc_lastuserchange;

    /* Calibration data */
    uint16_t    sc_cpu_diode_scale;
    int16_t        sc_cpu_diode_offset;

    uint16_t    sc_cpu_volt_scale;
    int16_t        sc_cpu_volt_offset;
    uint16_t    sc_cpu_curr_scale;
    int16_t        sc_cpu_curr_offset;

    uint16_t    sc_slots_pow_scale;
    int16_t        sc_slots_pow_offset;

    struct cdev     *sc_leddev;
};

/* regular bus attachment functions */

static int    smu_probe(device_t);
static int    smu_attach(device_t);
static const struct ofw_bus_devinfo *
    smu_get_devinfo(device_t bus, device_t dev);

/* cpufreq notification hooks */

static void    smu_cpufreq_pre_change(device_t, const struct cf_level
*level);
static void    smu_cpufreq_post_change(device_t, const struct cf_level
*level);

/* clock interface */
static int    smu_gettime(device_t dev, struct timespec *ts);
static int    smu_settime(device_t dev, struct timespec *ts);

/* utility functions */
static int    smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait);
static int    smu_get_datablock(device_t dev, int8_t id, uint8_t *buf,
            size_t len);
static void    smu_attach_i2c(device_t dev, phandle_t i2croot);
static void    smu_attach_fans(device_t dev, phandle_t fanroot);
static void    smu_attach_sensors(device_t dev, phandle_t sensroot);
static void    smu_set_sleepled(void *xdev, int onoff);
static int    smu_server_mode(SYSCTL_HANDLER_ARGS);
static void    smu_doorbell_intr(void *xdev);
static void    smu_shutdown(void *xdev, int howto);

/* where to find the doorbell GPIO */

static device_t    smu_doorbell = NULL;

static device_method_t  smu_methods[] = {
    /* Device interface */
    DEVMETHOD(device_probe,        smu_probe),
    DEVMETHOD(device_attach,    smu_attach),

    /* Clock interface */
    DEVMETHOD(clock_gettime,    smu_gettime),
    DEVMETHOD(clock_settime,    smu_settime),

    /* ofw_bus interface */
    DEVMETHOD(bus_child_pnpinfo_str,ofw_bus_gen_child_pnpinfo_str),
    DEVMETHOD(ofw_bus_get_devinfo,    smu_get_devinfo),
    DEVMETHOD(ofw_bus_get_compat,    ofw_bus_gen_get_compat),
    DEVMETHOD(ofw_bus_get_model,    ofw_bus_gen_get_model),
    DEVMETHOD(ofw_bus_get_name,    ofw_bus_gen_get_name),
    DEVMETHOD(ofw_bus_get_node,    ofw_bus_gen_get_node),
    DEVMETHOD(ofw_bus_get_type,    ofw_bus_gen_get_type),

    { 0, 0 },
};

static driver_t smu_driver = {
    "smu",
    smu_methods,
    sizeof(struct smu_softc)
};

static devclass_t smu_devclass;

DRIVER_MODULE(smu, ofwbus, smu_driver, smu_devclass, 0, 0);
static MALLOC_DEFINE(M_SMU, "smu", "SMU Sensor Information");

#define SMU_MAILBOX        0x8000860c
#define SMU_FANMGT_INTERVAL    1000 /* ms */

/* Command types */
#define SMU_ADC            0xd8
#define SMU_FAN            0x4a
#define SMU_RPM_STATUS        0x01
#define SMU_RPM_SETPOINT    0x02
#define SMU_PWM_STATUS        0x11
#define SMU_PWM_SETPOINT    0x12
#define SMU_I2C            0x9a
#define  SMU_I2C_SIMPLE        0x00
#define  SMU_I2C_NORMAL        0x01
#define  SMU_I2C_COMBINED    0x02
#define SMU_MISC        0xee
#define  SMU_MISC_GET_DATA    0x02
#define  SMU_MISC_LED_CTRL    0x04
#define SMU_POWER        0xaa
#define SMU_POWER_EVENTS    0x8f
#define  SMU_PWR_GET_POWERUP    0x00
#define  SMU_PWR_SET_POWERUP    0x01
#define  SMU_PWR_CLR_POWERUP    0x02
#define SMU_RTC            0x8e
#define  SMU_RTC_GET        0x81
#define  SMU_RTC_SET        0x80

/* Power event types */
#define SMU_WAKEUP_KEYPRESS    0x01
#define SMU_WAKEUP_AC_INSERT    0x02
#define SMU_WAKEUP_AC_CHANGE    0x04
#define SMU_WAKEUP_RING        0x10

/* Data blocks */
#define SMU_CPUTEMP_CAL        0x18
#define SMU_CPUVOLT_CAL        0x21
#define SMU_SLOTPW_CAL        0x78

/* Partitions */
#define SMU_PARTITION        0x3e
#define SMU_PARTITION_LATEST    0x01
#define SMU_PARTITION_BASE    0x02
#define SMU_PARTITION_UPDATE    0x03

static int
smu_probe(device_t dev)
{
    const char *name = ofw_bus_get_name(dev);

    if (strcmp(name, "smu") != 0)
        return (ENXIO);

    device_set_desc(dev, "Apple System Management Unit");
    return (0);
}

static void
smu_phys_callback(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
{
    struct smu_softc *sc = xsc;

    sc->sc_cmd_phys = segs[0].ds_addr;
}

static int
smu_attach(device_t dev)
{
    struct smu_softc *sc;
    phandle_t    node, child;
    uint8_t        data[12];

    sc = device_get_softc(dev);

    mtx_init(&sc->sc_mtx, "smu", NULL, MTX_DEF);
    sc->sc_cur_cmd = NULL;
    sc->sc_doorbellirqid = -1;

    sc->sc_u3 = 0;
    if (OF_finddevice("/u3") != -1)
        sc->sc_u3 = 1;

    /*
     * Map the mailbox area. This should be determined from firmware,
     * but I have not found a simple way to do that.
     */
    bus_dma_tag_create(NULL, 16, 0, BUS_SPACE_MAXADDR_32BIT,
        BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE, 0, NULL,
        NULL, &(sc->sc_dmatag));
    sc->sc_bt = &bs_le_tag;
    bus_space_map(sc->sc_bt, SMU_MAILBOX, 4, 0, &sc->sc_mailbox);

    /*
     * Allocate the command buffer. This can be anywhere in the low 4 GB
     * of memory.
     */
    bus_dmamem_alloc(sc->sc_dmatag, (void **)&sc->sc_cmd, BUS_DMA_WAITOK |
        BUS_DMA_ZERO, &sc->sc_cmd_dmamap);
    bus_dmamap_load(sc->sc_dmatag, sc->sc_cmd_dmamap,
        sc->sc_cmd, PAGE_SIZE, smu_phys_callback, sc, 0);
    STAILQ_INIT(&sc->sc_cmdq);

    /*
     * Set up handlers to change CPU voltage when CPU frequency is changed.
     */
    EVENTHANDLER_REGISTER(cpufreq_pre_change, smu_cpufreq_pre_change, dev,
        EVENTHANDLER_PRI_ANY);
    EVENTHANDLER_REGISTER(cpufreq_post_change, smu_cpufreq_post_change, dev,
        EVENTHANDLER_PRI_ANY);

    node = ofw_bus_get_node(dev);

    /* Some SMUs have RPM and PWM controlled fans which do not sit
     * under the same node. So we have to attach them separately.
     */
    smu_attach_fans(dev, node);

    /*
     * Now detect and attach the other child devices.
     */
    for (child = OF_child(node); child != 0; child = OF_peer(child)) {
        char name[32];
        memset(name, 0, sizeof(name));
        OF_getprop(child, "name", name, sizeof(name));

        if (strncmp(name, "sensors", 8) == 0)
            smu_attach_sensors(dev, child);

        if (strncmp(name, "smu-i2c-control", 15) == 0)
            smu_attach_i2c(dev, child);
    }

    /* Some SMUs have the I2C children directly under the bus. */
    smu_attach_i2c(dev, node);

    /*
     * Collect calibration constants.
     */
    smu_get_datablock(dev, SMU_CPUTEMP_CAL, data, sizeof(data));
    sc->sc_cpu_diode_scale = (data[4] << 8) + data[5];
    sc->sc_cpu_diode_offset = (data[6] << 8) + data[7];

    smu_get_datablock(dev, SMU_CPUVOLT_CAL, data, sizeof(data));
    sc->sc_cpu_volt_scale = (data[4] << 8) + data[5];
    sc->sc_cpu_volt_offset = (data[6] << 8) + data[7];
    sc->sc_cpu_curr_scale = (data[8] << 8) + data[9];
    sc->sc_cpu_curr_offset = (data[10] << 8) + data[11];

    smu_get_datablock(dev, SMU_SLOTPW_CAL, data, sizeof(data));
    sc->sc_slots_pow_scale = (data[4] << 8) + data[5];
    sc->sc_slots_pow_offset = (data[6] << 8) + data[7];

    /*
     * Set up LED interface
     */
    sc->sc_leddev = led_create(smu_set_sleepled, dev, "sleepled");

    /*
     * Reset on power loss behavior
     */

    SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
            SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
        "server_mode", CTLTYPE_INT | CTLFLAG_RW, dev, 0,
        smu_server_mode, "I", "Enable reboot after power failure");

    /*
     * Set up doorbell interrupt.
     */
    sc->sc_doorbellirqid = 0;
    sc->sc_doorbellirq = bus_alloc_resource_any(smu_doorbell, SYS_RES_IRQ,
        &sc->sc_doorbellirqid, RF_ACTIVE);
    bus_setup_intr(smu_doorbell, sc->sc_doorbellirq,
        INTR_TYPE_MISC | INTR_MPSAFE, NULL, smu_doorbell_intr, dev,
        &sc->sc_doorbellirqcookie);
    powerpc_config_intr(rman_get_start(sc->sc_doorbellirq),
        INTR_TRIGGER_EDGE, INTR_POLARITY_LOW);

    /*
     * Connect RTC interface.
     */
    clock_register(dev, 1000);

    /*
     * Learn about shutdown events
     */
    EVENTHANDLER_REGISTER(shutdown_final, smu_shutdown, dev,
        SHUTDOWN_PRI_LAST);

    return (bus_generic_attach(dev));
}

static const struct ofw_bus_devinfo *
smu_get_devinfo(device_t bus, device_t dev)
{

    return (device_get_ivars(dev));
}

static void
smu_send_cmd(device_t dev, struct smu_cmd *cmd)
{
    struct smu_softc *sc;

    sc = device_get_softc(dev);

    mtx_assert(&sc->sc_mtx, MA_OWNED);

    if (sc->sc_u3)
        powerpc_pow_enabled = 0; /* SMU cannot work if we go to NAP */

    sc->sc_cur_cmd = cmd;

    /* Copy the command to the mailbox */
    sc->sc_cmd->cmd = cmd->cmd;
    sc->sc_cmd->len = cmd->len;
    memcpy(sc->sc_cmd->data, cmd->data, sizeof(cmd->data));
    bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap, BUS_DMASYNC_PREWRITE);
    bus_space_write_4(sc->sc_bt, sc->sc_mailbox, 0, sc->sc_cmd_phys);

    /* Flush the cacheline it is in -- SMU bypasses the cache */
    __asm __volatile("sync; dcbf 0,%0; sync" :: "r"(sc->sc_cmd): "memory");

    /* Ring SMU doorbell */
    macgpio_write(smu_doorbell, GPIO_DDR_OUTPUT);
}

static void
smu_doorbell_intr(void *xdev)
{
    device_t smu;
    struct smu_softc *sc;
    int doorbell_ack;

    smu = xdev;
    doorbell_ack = macgpio_read(smu_doorbell);
    sc = device_get_softc(smu);

    if (doorbell_ack != (GPIO_DDR_OUTPUT | GPIO_LEVEL_RO | GPIO_DATA))
        return;

    mtx_lock(&sc->sc_mtx);

    if (sc->sc_cur_cmd == NULL)    /* spurious */
        goto done;

    /* Check result. First invalidate the cache again... */
    __asm __volatile("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory");

    bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap, BUS_DMASYNC_POSTREAD);

    sc->sc_cur_cmd->cmd = sc->sc_cmd->cmd;
    sc->sc_cur_cmd->len = sc->sc_cmd->len;
    memcpy(sc->sc_cur_cmd->data, sc->sc_cmd->data,
        sizeof(sc->sc_cmd->data));
    wakeup(sc->sc_cur_cmd);
    sc->sc_cur_cmd = NULL;
    if (sc->sc_u3)
        powerpc_pow_enabled = 1;

    done:
    /* Queue next command if one is pending */
    if (STAILQ_FIRST(&sc->sc_cmdq) != NULL) {
        sc->sc_cur_cmd = STAILQ_FIRST(&sc->sc_cmdq);
        STAILQ_REMOVE_HEAD(&sc->sc_cmdq, cmd_q);
        smu_send_cmd(smu, sc->sc_cur_cmd);
    }

    mtx_unlock(&sc->sc_mtx);
}

static int
smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait)
{
    struct smu_softc *sc;
    uint8_t cmd_code;
    int error;

    sc = device_get_softc(dev);
    cmd_code = cmd->cmd;

    mtx_lock(&sc->sc_mtx);
    if (sc->sc_cur_cmd != NULL) {
        STAILQ_INSERT_TAIL(&sc->sc_cmdq, cmd, cmd_q);
    } else
        smu_send_cmd(dev, cmd);
    mtx_unlock(&sc->sc_mtx);

    if (!wait)
        return (0);

    if (sc->sc_doorbellirqid < 0) {
        /* Poll if the IRQ has not been set up yet */
        do {
            DELAY(50);
            smu_doorbell_intr(dev);
        } while (sc->sc_cur_cmd != NULL);
    } else {
        /* smu_doorbell_intr will wake us when the command is ACK'ed */
        error = tsleep(cmd, 0, "smu", 800 * hz / 1000);
        if (error != 0)
            smu_doorbell_intr(dev);    /* One last chance */

        if (error != 0) {
            mtx_lock(&sc->sc_mtx);
            if (cmd->cmd == cmd_code) {    /* Never processed */
            /* Abort this command if we timed out */
            if (sc->sc_cur_cmd == cmd)
                sc->sc_cur_cmd = NULL;
            else
                STAILQ_REMOVE(&sc->sc_cmdq, cmd, smu_cmd,
                    cmd_q);
            mtx_unlock(&sc->sc_mtx);
            return (error);
            }
            error = 0;
            mtx_unlock(&sc->sc_mtx);
        }
    }

    /* SMU acks the command by inverting the command bits */
    if (cmd->cmd == ((~cmd_code) & 0xff))
        error = 0;
    else
        error = EIO;

    return (error);
}

static int
smu_get_datablock(device_t dev, int8_t id, uint8_t *buf, size_t len)
{
    struct smu_cmd cmd;
    uint8_t addr[4];

    cmd.cmd = SMU_PARTITION;
    cmd.len = 2;
    cmd.data[0] = SMU_PARTITION_LATEST;
    cmd.data[1] = id;

    smu_run_cmd(dev, &cmd, 1);

    addr[0] = addr[1] = 0;
    addr[2] = cmd.data[0];
    addr[3] = cmd.data[1];

    cmd.cmd = SMU_MISC;
    cmd.len = 7;
    cmd.data[0] = SMU_MISC_GET_DATA;
    cmd.data[1] = sizeof(addr);
    memcpy(&cmd.data[2], addr, sizeof(addr));
    cmd.data[6] = len;

    smu_run_cmd(dev, &cmd, 1);
    memcpy(buf, cmd.data, len);
    return (0);
}

static void
smu_slew_cpu_voltage(device_t dev, int to)
{
    struct smu_cmd cmd;

    cmd.cmd = SMU_POWER;
    cmd.len = 8;
    cmd.data[0] = 'V';
    cmd.data[1] = 'S';
    cmd.data[2] = 'L';
    cmd.data[3] = 'E';
    cmd.data[4] = 'W';
    cmd.data[5] = 0xff;
    cmd.data[6] = 1;
    cmd.data[7] = to;

    smu_run_cmd(dev, &cmd, 1);
}

static void
smu_cpufreq_pre_change(device_t dev, const struct cf_level *level)
{
    /*
     * Make sure the CPU voltage is raised before we raise
     * the clock.
     */

    if (level->rel_set[0].freq == 10000 /* max */)
        smu_slew_cpu_voltage(dev, 0);
}

static void
smu_cpufreq_post_change(device_t dev, const struct cf_level *level)
{
    /* We are safe to reduce CPU voltage after a downward transition */

    if (level->rel_set[0].freq < 10000 /* max */)
        smu_slew_cpu_voltage(dev, 1); /* XXX: 1/4 voltage for 970MP? */
}

/* Routines for probing the SMU doorbell GPIO */
static int doorbell_probe(device_t dev);
static int doorbell_attach(device_t dev);

static device_method_t  doorbell_methods[] = {
    /* Device interface */
    DEVMETHOD(device_probe,        doorbell_probe),
    DEVMETHOD(device_attach,    doorbell_attach),
    { 0, 0 },
};

static driver_t doorbell_driver = {
    "smudoorbell",
    doorbell_methods,
    0
};

static devclass_t doorbell_devclass;

DRIVER_MODULE(smudoorbell, macgpio, doorbell_driver, doorbell_devclass, 0,
0);

static int
doorbell_probe(device_t dev)
{
    const char *name = ofw_bus_get_name(dev);

    if (strcmp(name, "smu-doorbell") != 0)
        return (ENXIO);

    device_set_desc(dev, "SMU Doorbell GPIO");
    device_quiet(dev);
    return (0);
}

static int
doorbell_attach(device_t dev)
{
    smu_doorbell = dev;
    return (0);
}

/*
 * Sensor and fan management
 */

static int
smu_fan_check_old_style(struct smu_fan *fan)
{
    device_t smu = fan->dev;
    struct smu_softc *sc = device_get_softc(smu);
    struct smu_cmd cmd;
    int error;

    if (sc->old_style_fans != -1)
        return (sc->old_style_fans);

    /*
     * Apple has two fan control mechanisms. We can't distinguish
     * them except by seeing if the new one fails. If the new one
     * fails, use the old one.
     */

    cmd.cmd = SMU_FAN;
    cmd.len = 2;
    cmd.data[0] = 0x31;
    cmd.data[1] = fan->reg;

    do {
        error = smu_run_cmd(smu, &cmd, 1);
    } while (error == EWOULDBLOCK);

    sc->old_style_fans = (error != 0);

    return (sc->old_style_fans);
}

static int
smu_fan_set_rpm(struct smu_fan *fan, int rpm)
{
    device_t smu = fan->dev;
    struct smu_cmd cmd;
    int error;

    cmd.cmd = SMU_FAN;
    error = EIO;

    /* Clamp to allowed range */
    rpm = max(fan->fan.min_rpm, rpm);
    rpm = min(fan->fan.max_rpm, rpm);

    smu_fan_check_old_style(fan);

    if (!fan->old_style) {
        cmd.len = 4;
        cmd.data[0] = 0x30;
        cmd.data[1] = fan->reg;
        cmd.data[2] = (rpm >> 8) & 0xff;
        cmd.data[3] = rpm & 0xff;

        error = smu_run_cmd(smu, &cmd, 1);
        if (error && error != EWOULDBLOCK)
            fan->old_style = 1;
    } else {
        cmd.len = 14;
        cmd.data[0] = 0x00; /* RPM fan. */
        cmd.data[1] = 1 << fan->reg;
        cmd.data[2 + 2*fan->reg] = (rpm >> 8) & 0xff;
        cmd.data[3 + 2*fan->reg] = rpm & 0xff;
        error = smu_run_cmd(smu, &cmd, 1);
    }

    if (error == 0)
        fan->setpoint = rpm;

    return (error);
}

static int
smu_fan_read_rpm(struct smu_fan *fan)
{
    device_t smu = fan->dev;
    struct smu_cmd cmd;
    int rpm, error;

    smu_fan_check_old_style(fan);

    if (!fan->old_style) {
        cmd.cmd = SMU_FAN;
        cmd.len = 2;
        cmd.data[0] = 0x31;
        cmd.data[1] = fan->reg;

        error = smu_run_cmd(smu, &cmd, 1);
        if (error && error != EWOULDBLOCK)
            fan->old_style = 1;

        rpm = (cmd.data[0] << 8) | cmd.data[1];
    }

    if (fan->old_style) {
        cmd.cmd = SMU_FAN;
        cmd.len = 1;
        cmd.data[0] = SMU_RPM_STATUS;

        error = smu_run_cmd(smu, &cmd, 1);
        if (error)
            return (error);

        rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2];
    }

    return (rpm);
}
static int
smu_fan_set_pwm(struct smu_fan *fan, int pwm)
{
    device_t smu = fan->dev;
    struct smu_cmd cmd;
    int error;

    cmd.cmd = SMU_FAN;
    error = EIO;

    /* Clamp to allowed range */
    pwm = max(fan->fan.min_rpm, pwm);
    pwm = min(fan->fan.max_rpm, pwm);

    /*
     * Apple has two fan control mechanisms. We can't distinguish
     * them except by seeing if the new one fails. If the new one
     * fails, use the old one.
     */

    if (!fan->old_style) {
        cmd.len = 4;
        cmd.data[0] = 0x30;
        cmd.data[1] = fan->reg;
        cmd.data[2] = (pwm >> 8) & 0xff;
        cmd.data[3] = pwm & 0xff;

        error = smu_run_cmd(smu, &cmd, 1);
        if (error && error != EWOULDBLOCK)
            fan->old_style = 1;
    }

    if (fan->old_style) {
        cmd.len = 14;
        cmd.data[0] = 0x10; /* PWM fan. */
        cmd.data[1] = 1 << fan->reg;
        cmd.data[2 + 2*fan->reg] = (pwm >> 8) & 0xff;
        cmd.data[3 + 2*fan->reg] = pwm & 0xff;
        error = smu_run_cmd(smu, &cmd, 1);
    }

    if (error == 0)
        fan->setpoint = pwm;

    return (error);
}

static int
smu_fan_read_pwm(struct smu_fan *fan, int *pwm, int *rpm)
{
    device_t smu = fan->dev;
    struct smu_cmd cmd;
    int error;

    if (!fan->old_style) {
        cmd.cmd = SMU_FAN;
        cmd.len = 2;
        cmd.data[0] = 0x31;
        cmd.data[1] = fan->reg;

        error = smu_run_cmd(smu, &cmd, 1);
        if (error && error != EWOULDBLOCK)
            fan->old_style = 1;

        *rpm = (cmd.data[0] << 8) | cmd.data[1];
    }

    if (fan->old_style) {
        cmd.cmd = SMU_FAN;
        cmd.len = 1;
        cmd.data[0] = SMU_PWM_STATUS;

        error = smu_run_cmd(smu, &cmd, 1);
        if (error)
            return (error);

        *rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2];
    }
    if (fan->old_style) {
        cmd.cmd = SMU_FAN;
        cmd.len = 14;
        cmd.data[0] = SMU_PWM_SETPOINT;
        cmd.data[1] = 1 << fan->reg;

        error = smu_run_cmd(smu, &cmd, 1);
        if (error)
            return (error);

        *pwm = cmd.data[fan->reg*2+2];
    }
    return (0);
}

static int
smu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS)
{
    device_t smu;
    struct smu_softc *sc;
    struct smu_fan *fan;
    int pwm = 0, rpm, error = 0;

    smu = arg1;
    sc = device_get_softc(smu);
    fan = &sc->sc_fans[arg2 & 0xff];

    if (fan->type == SMU_FAN_RPM) {
        rpm = smu_fan_read_rpm(fan);
        if (rpm < 0)
            return (rpm);

        error = sysctl_handle_int(oidp, &rpm, 0, req);
    } else {
        error = smu_fan_read_pwm(fan, &pwm, &rpm);
        if (error < 0)
            return (EIO);

        switch (arg2 & 0xff00) {
        case SMU_PWM_SYSCTL_PWM:
            error = sysctl_handle_int(oidp, &pwm, 0, req);
            break;
        case SMU_PWM_SYSCTL_RPM:
            error = sysctl_handle_int(oidp, &rpm, 0, req);
            break;
        default:
            /* This should never happen */
            return (EINVAL);
        };
    }
    /* We can only read the RPM from a PWM controlled fan, so return. */
    if ((arg2 & 0xff00) == SMU_PWM_SYSCTL_RPM)
        return (0);

    if (error || !req->newptr)
        return (error);

    sc->sc_lastuserchange = time_uptime;

    if (fan->type == SMU_FAN_RPM)
        return (smu_fan_set_rpm(fan, rpm));
    else
        return (smu_fan_set_pwm(fan, pwm));
}

static void
smu_fill_fan_prop(device_t dev, phandle_t child, int id)
{
    struct smu_fan *fan;
    struct smu_softc *sc;
    char type[32];

    sc = device_get_softc(dev);
    fan = &sc->sc_fans[id];

    OF_getprop(child, "device_type", type, sizeof(type));
    /* We have either RPM or PWM controlled fans. */
    if (strcmp(type, "fan-rpm-control") == 0)
        fan->type = SMU_FAN_RPM;
    else
        fan->type = SMU_FAN_PWM;

    fan->dev = dev;
    fan->old_style = 0;
    OF_getprop(child, "reg", &fan->reg,
           sizeof(cell_t));
    OF_getprop(child, "min-value", &fan->fan.min_rpm,
           sizeof(int));
    OF_getprop(child, "max-value", &fan->fan.max_rpm,
           sizeof(int));
    OF_getprop(child, "zone", &fan->fan.zone,
           sizeof(int));

    if (OF_getprop(child, "unmanaged-value",
               &fan->fan.default_rpm,
               sizeof(int)) != sizeof(int))
        fan->fan.default_rpm = fan->fan.max_rpm;

    OF_getprop(child, "location", fan->fan.name,
           sizeof(fan->fan.name));

    if (fan->type == SMU_FAN_RPM)
        fan->setpoint = smu_fan_read_rpm(fan);
    else
        smu_fan_read_pwm(fan, &fan->setpoint, &fan->rpm);
}

/* On the first call count the number of fans. In the second call,
 * after allocating the fan struct, fill the properties of the fans.
 */
static int
smu_count_fans(device_t dev)
{
    struct smu_softc *sc;
    phandle_t child, node, root;
    int nfans = 0;

    node = ofw_bus_get_node(dev);
    sc = device_get_softc(dev);

    /* First find the fanroots and count the number of fans. */
    for (root = OF_child(node); root != 0; root = OF_peer(root)) {
        char name[32];
        memset(name, 0, sizeof(name));
        OF_getprop(root, "name", name, sizeof(name));
        if (strncmp(name, "rpm-fans", 9) == 0 ||
            strncmp(name, "pwm-fans", 9) == 0 ||
            strncmp(name, "fans", 5) == 0)
            for (child = OF_child(root); child != 0;
                 child = OF_peer(child)) {
                nfans++;
                /* When allocated, fill the fan properties. */
                if (sc->sc_fans != NULL) {
                    smu_fill_fan_prop(dev, child,
                              nfans - 1);
                }
            }
    }
    if (nfans == 0) {
        device_printf(dev, "WARNING: No fans detected!\n");
        return (0);
    }
    return (nfans);
}

static void
smu_attach_fans(device_t dev, phandle_t fanroot)
{
    struct smu_fan *fan;
    struct smu_softc *sc;
    struct sysctl_oid *oid, *fanroot_oid;
    struct sysctl_ctx_list *ctx;
    char sysctl_name[32];
    int i, j;

    sc = device_get_softc(dev);

    /* Get the number of fans. */
    sc->sc_nfans = smu_count_fans(dev);
    if (sc->sc_nfans == 0)
        return;

    /* Now we're able to allocate memory for the fans struct. */
    sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct smu_fan), M_SMU,
        M_WAITOK | M_ZERO);

    /* Now fill in the properties. */
    smu_count_fans(dev);

    /* Register fans with pmac_thermal */
    for (i = 0; i < sc->sc_nfans; i++)
        pmac_thermal_fan_register(&sc->sc_fans[i].fan);

    ctx = device_get_sysctl_ctx(dev);
    fanroot_oid = SYSCTL_ADD_NODE(ctx,
        SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans",
        CTLFLAG_RD, 0, "SMU Fan Information");

    /* Add sysctls */
    for (i = 0; i < sc->sc_nfans; i++) {
        fan = &sc->sc_fans[i];
        for (j = 0; j < strlen(fan->fan.name); j++) {
            sysctl_name[j] = tolower(fan->fan.name[j]);
            if (isspace(sysctl_name[j]))
                sysctl_name[j] = '_';
        }
        sysctl_name[j] = 0;
        if (fan->type == SMU_FAN_RPM) {
            oid = SYSCTL_ADD_NODE(ctx,
                          SYSCTL_CHILDREN(fanroot_oid),
                          OID_AUTO, sysctl_name,
                          CTLFLAG_RD, 0, "Fan Information");
            SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
                       "minrpm", CTLFLAG_RD,
                       &fan->fan.min_rpm, 0,
                       "Minimum allowed RPM");
            SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
                       "maxrpm", CTLFLAG_RD,
                       &fan->fan.max_rpm, 0,
                       "Maximum allowed RPM");
            SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
                    "rpm",CTLTYPE_INT | CTLFLAG_RW |
                    CTLFLAG_MPSAFE, dev, i,
                    smu_fanrpm_sysctl, "I", "Fan RPM");

            fan->fan.read = (int (*)(struct pmac_fan *))smu_fan_read_rpm;
            fan->fan.set = (int (*)(struct pmac_fan *, int))smu_fan_set_rpm;

        } else {
            oid = SYSCTL_ADD_NODE(ctx,
                          SYSCTL_CHILDREN(fanroot_oid),
                          OID_AUTO, sysctl_name,
                          CTLFLAG_RD, 0, "Fan Information");
            SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
                       "minpwm", CTLFLAG_RD,
                       &fan->fan.min_rpm, 0,
                       "Minimum allowed PWM in %");
            SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
                       "maxpwm", CTLFLAG_RD,
                       &fan->fan.max_rpm, 0,
                       "Maximum allowed PWM in %");
            SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
                    "pwm",CTLTYPE_INT | CTLFLAG_RW |
                    CTLFLAG_MPSAFE, dev,
                    SMU_PWM_SYSCTL_PWM | i,
                    smu_fanrpm_sysctl, "I", "Fan PWM in %");
            SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
                    "rpm",CTLTYPE_INT | CTLFLAG_RD |
                    CTLFLAG_MPSAFE, dev,
                    SMU_PWM_SYSCTL_RPM | i,
                    smu_fanrpm_sysctl, "I", "Fan RPM");
            fan->fan.read = NULL;
            fan->fan.set = (int (*)(struct pmac_fan *, int))smu_fan_set_pwm;

        }
        if (bootverbose)
            device_printf(dev, "Fan: %s type: %d\n",
                      fan->fan.name, fan->type);
    }
}

static int
smu_sensor_read(struct smu_sensor *sens)
{
    device_t smu = sens->dev;
    struct smu_cmd cmd;
    struct smu_softc *sc;
    int64_t value;
    int error;

    cmd.cmd = SMU_ADC;
    cmd.len = 1;
    cmd.data[0] = sens->reg;
    error = 0;

    error = smu_run_cmd(smu, &cmd, 1);
    if (error != 0)
        return (-1);

    sc = device_get_softc(smu);
    value = (cmd.data[0] << 8) | cmd.data[1];

    switch (sens->type) {
    case SMU_TEMP_SENSOR:
        value *= sc->sc_cpu_diode_scale;
        value >>= 3;
        value += ((int64_t)sc->sc_cpu_diode_offset) << 9;
        value <<= 1;

        /* Convert from 16.16 fixed point degC into integer 0.1 K. */
        value = 10*(value >> 16) + ((10*(value & 0xffff)) >> 16) + 2732;
        break;
    case SMU_VOLTAGE_SENSOR:
        value *= sc->sc_cpu_volt_scale;
        value += sc->sc_cpu_volt_offset;
        value <<= 4;

        /* Convert from 16.16 fixed point V into mV. */
        value *= 15625;
        value /= 1024;
        value /= 1000;
        break;
    case SMU_CURRENT_SENSOR:
        value *= sc->sc_cpu_curr_scale;
        value += sc->sc_cpu_curr_offset;
        value <<= 4;

        /* Convert from 16.16 fixed point A into mA. */
        value *= 15625;
        value /= 1024;
        value /= 1000;
        break;
    case SMU_POWER_SENSOR:
        value *= sc->sc_slots_pow_scale;
        value += sc->sc_slots_pow_offset;
        value <<= 4;

        /* Convert from 16.16 fixed point W into mW. */
        value *= 15625;
        value /= 1024;
        value /= 1000;
        break;
    }

    return (value);
}

static int
smu_sensor_sysctl(SYSCTL_HANDLER_ARGS)
{
    device_t smu;
    struct smu_softc *sc;
    struct smu_sensor *sens;
    int value, error;

    smu = arg1;
    sc = device_get_softc(smu);
    sens = &sc->sc_sensors[arg2];

    value = smu_sensor_read(sens);
    if (value < 0)
        return (EBUSY);

    error = sysctl_handle_int(oidp, &value, 0, req);

    return (error);
}

static void
smu_attach_sensors(device_t dev, phandle_t sensroot)
{
    struct smu_sensor *sens;
    struct smu_softc *sc;
    struct sysctl_oid *sensroot_oid;
    struct sysctl_ctx_list *ctx;
    phandle_t child;
    char type[32];
    int i;

    sc = device_get_softc(dev);
    sc->sc_nsensors = 0;

    for (child = OF_child(sensroot); child != 0; child = OF_peer(child))
        sc->sc_nsensors++;

    if (sc->sc_nsensors == 0) {
        device_printf(dev, "WARNING: No sensors detected!\n");
        return;
    }

    sc->sc_sensors = malloc(sc->sc_nsensors * sizeof(struct smu_sensor),
        M_SMU, M_WAITOK | M_ZERO);

    sens = sc->sc_sensors;
    sc->sc_nsensors = 0;

    ctx = device_get_sysctl_ctx(dev);
    sensroot_oid = SYSCTL_ADD_NODE(ctx,
        SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensors",
        CTLFLAG_RD, 0, "SMU Sensor Information");

    for (child = OF_child(sensroot); child != 0; child = OF_peer(child)) {
        char sysctl_name[40], sysctl_desc[40];
        const char *units;

        sens->dev = dev;
        OF_getprop(child, "device_type", type, sizeof(type));

        if (strcmp(type, "current-sensor") == 0) {
            sens->type = SMU_CURRENT_SENSOR;
            units = "mA";
        } else if (strcmp(type, "temp-sensor") == 0) {
            sens->type = SMU_TEMP_SENSOR;
            units = "C";
        } else if (strcmp(type, "voltage-sensor") == 0) {
            sens->type = SMU_VOLTAGE_SENSOR;
            units = "mV";
        } else if (strcmp(type, "power-sensor") == 0) {
            sens->type = SMU_POWER_SENSOR;
            units = "mW";
        } else {
            continue;
        }

        OF_getprop(child, "reg", &sens->reg, sizeof(cell_t));
        OF_getprop(child, "zone", &sens->therm.zone, sizeof(int));
        OF_getprop(child, "location", sens->therm.name,
            sizeof(sens->therm.name));

        for (i = 0; i < strlen(sens->therm.name); i++) {
            sysctl_name[i] = tolower(sens->therm.name[i]);
            if (isspace(sysctl_name[i]))
                sysctl_name[i] = '_';
        }
        sysctl_name[i] = 0;

        sprintf(sysctl_desc,"%s (%s)", sens->therm.name, units);

        SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(sensroot_oid), OID_AUTO,
            sysctl_name, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
            dev, sc->sc_nsensors, smu_sensor_sysctl,
            (sens->type == SMU_TEMP_SENSOR) ? "IK" : "I", sysctl_desc);

        if (sens->type == SMU_TEMP_SENSOR) {
            /* Make up some numbers */
            sens->therm.target_temp = 500 + 2732; /* 50 C */
            sens->therm.max_temp = 900 + 2732; /* 90 C */

            sens->therm.read =
                (int (*)(struct pmac_therm *))smu_sensor_read;
            pmac_thermal_sensor_register(&sens->therm);
        }

        sens++;
        sc->sc_nsensors++;
    }
}

static void
smu_set_sleepled(void *xdev, int onoff)
{
    static struct smu_cmd cmd;
    device_t smu = xdev;

    cmd.cmd = SMU_MISC;
    cmd.len = 3;
    cmd.data[0] = SMU_MISC_LED_CTRL;
    cmd.data[1] = 0;
    cmd.data[2] = onoff;

    smu_run_cmd(smu, &cmd, 0);
}

static int
smu_server_mode(SYSCTL_HANDLER_ARGS)
{
    struct smu_cmd cmd;
    u_int server_mode;
    device_t smu = arg1;
    int error;

    cmd.cmd = SMU_POWER_EVENTS;
    cmd.len = 1;
    cmd.data[0] = SMU_PWR_GET_POWERUP;

    error = smu_run_cmd(smu, &cmd, 1);

    if (error)
        return (error);

    server_mode = (cmd.data[1] & SMU_WAKEUP_AC_INSERT) ? 1 : 0;

    error = sysctl_handle_int(oidp, &server_mode, 0, req);

    if (error || !req->newptr)
        return (error);

    if (server_mode == 1)
        cmd.data[0] = SMU_PWR_SET_POWERUP;
    else if (server_mode == 0)
        cmd.data[0] = SMU_PWR_CLR_POWERUP;
    else
        return (EINVAL);

    cmd.len = 3;
    cmd.data[1] = 0;
    cmd.data[2] = SMU_WAKEUP_AC_INSERT;

    return (smu_run_cmd(smu, &cmd, 1));
}

static void
smu_shutdown(void *xdev, int howto)
{
    device_t smu = xdev;
    struct smu_cmd cmd;

    cmd.cmd = SMU_POWER;
    if (howto & RB_HALT)
        strcpy(cmd.data, "SHUTDOWN");
    else
        strcpy(cmd.data, "RESTART");

    cmd.len = strlen(cmd.data);

    smu_run_cmd(smu, &cmd, 1);

    for (;;);
}

static int
smu_gettime(device_t dev, struct timespec *ts)
{
    struct smu_cmd cmd;
    struct clocktime ct;

    cmd.cmd = SMU_RTC;
    cmd.len = 1;
    cmd.data[0] = SMU_RTC_GET;

    if (smu_run_cmd(dev, &cmd, 1) != 0)
        return (ENXIO);

    ct.nsec    = 0;
    ct.sec    = bcd2bin(cmd.data[0]);
    ct.min    = bcd2bin(cmd.data[1]);
    ct.hour    = bcd2bin(cmd.data[2]);
    ct.dow    = bcd2bin(cmd.data[3]);
    ct.day    = bcd2bin(cmd.data[4]);
    ct.mon    = bcd2bin(cmd.data[5]);
    ct.year    = bcd2bin(cmd.data[6]) + 2000;

    return (clock_ct_to_ts(&ct, ts));
}

static int
smu_settime(device_t dev, struct timespec *ts)
{
    static struct smu_cmd cmd;
    struct clocktime ct;

    cmd.cmd = SMU_RTC;
    cmd.len = 8;
    cmd.data[0] = SMU_RTC_SET;

    clock_ts_to_ct(ts, &ct);

    cmd.data[1] = bin2bcd(ct.sec);
    cmd.data[2] = bin2bcd(ct.min);
    cmd.data[3] = bin2bcd(ct.hour);
    cmd.data[4] = bin2bcd(ct.dow);
    cmd.data[5] = bin2bcd(ct.day);
    cmd.data[6] = bin2bcd(ct.mon);
    cmd.data[7] = bin2bcd(ct.year - 2000);

    return (smu_run_cmd(dev, &cmd, 0));
}

/* SMU I2C Interface */

static int smuiic_probe(device_t dev);
static int smuiic_attach(device_t dev);
static int smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t
nmsgs);
static phandle_t smuiic_get_node(device_t bus, device_t dev);

static device_method_t smuiic_methods[] = {
    /* device interface */
    DEVMETHOD(device_probe,         smuiic_probe),
    DEVMETHOD(device_attach,        smuiic_attach),

    /* iicbus interface */
    DEVMETHOD(iicbus_callback,      iicbus_null_callback),
    DEVMETHOD(iicbus_transfer,      smuiic_transfer),

    /* ofw_bus interface */
    DEVMETHOD(ofw_bus_get_node,     smuiic_get_node),

    { 0, 0 }
};

struct smuiic_softc {
    struct mtx    sc_mtx;
    volatile int    sc_iic_inuse;
    int        sc_busno;
};

static driver_t smuiic_driver = {
    "iichb",
    smuiic_methods,
    sizeof(struct smuiic_softc)
};
static devclass_t smuiic_devclass;

DRIVER_MODULE(smuiic, smu, smuiic_driver, smuiic_devclass, 0, 0);

static void
smu_attach_i2c(device_t smu, phandle_t i2croot)
{
    phandle_t child;
    device_t cdev;
    struct ofw_bus_devinfo *dinfo;
    char name[32];

    for (child = OF_child(i2croot); child != 0; child = OF_peer(child)) {
        if (OF_getprop(child, "name", name, sizeof(name)) <= 0)
            continue;

        if (strcmp(name, "i2c-bus") != 0 && strcmp(name, "i2c") != 0)
            continue;

        dinfo = malloc(sizeof(struct ofw_bus_devinfo), M_SMU,
            M_WAITOK | M_ZERO);
        if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
            free(dinfo, M_SMU);
            continue;
        }

        cdev = device_add_child(smu, NULL, -1);
        if (cdev == NULL) {
            device_printf(smu, "<%s>: device_add_child failed\n",
                dinfo->obd_name);
            ofw_bus_gen_destroy_devinfo(dinfo);
            free(dinfo, M_SMU);
            continue;
        }
        device_set_ivars(cdev, dinfo);
    }
}

static int
smuiic_probe(device_t dev)
{
    const char *name;

    name = ofw_bus_get_name(dev);
    if (name == NULL)
        return (ENXIO);

    if (strcmp(name, "i2c-bus") == 0 || strcmp(name, "i2c") == 0) {
        device_set_desc(dev, "SMU I2C controller");
        return (0);
    }

    return (ENXIO);
}

static int
smuiic_attach(device_t dev)
{
    struct smuiic_softc *sc = device_get_softc(dev);
    mtx_init(&sc->sc_mtx, "smuiic", NULL, MTX_DEF);
    sc->sc_iic_inuse = 0;

    /* Get our bus number */
    OF_getprop(ofw_bus_get_node(dev), "reg", &sc->sc_busno,
        sizeof(sc->sc_busno));

    /* Add the IIC bus layer */
    device_add_child(dev, "iicbus", -1);

    return (bus_generic_attach(dev));
}

static int
smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
{
    struct smuiic_softc *sc = device_get_softc(dev);
    struct smu_cmd cmd;
    int i, j, error;

    mtx_lock(&sc->sc_mtx);
    while (sc->sc_iic_inuse)
        mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 100);

    sc->sc_iic_inuse = 1;
    error = 0;

    for (i = 0; i < nmsgs; i++) {
        cmd.cmd = SMU_I2C;
        cmd.data[0] = sc->sc_busno;
        if (msgs[i].flags & IIC_M_NOSTOP)
            cmd.data[1] = SMU_I2C_COMBINED;
        else
            cmd.data[1] = SMU_I2C_SIMPLE;

        cmd.data[2] = msgs[i].slave;
        if (msgs[i].flags & IIC_M_RD)
            cmd.data[2] |= 1;

        if (msgs[i].flags & IIC_M_NOSTOP) {
            KASSERT(msgs[i].len < 4,
                ("oversize I2C combined message"));

            cmd.data[3] = min(msgs[i].len, 3);
            memcpy(&cmd.data[4], msgs[i].buf, min(msgs[i].len, 3));
            i++; /* Advance to next part of message */
        } else {
            cmd.data[3] = 0;
            memset(&cmd.data[4], 0, 3);
        }

        cmd.data[7] = msgs[i].slave;
        if (msgs[i].flags & IIC_M_RD)
            cmd.data[7] |= 1;

        cmd.data[8] = msgs[i].len;
        if (msgs[i].flags & IIC_M_RD) {
            memset(&cmd.data[9], 0xff, msgs[i].len);
            cmd.len = 9;
        } else {
            memcpy(&cmd.data[9], msgs[i].buf, msgs[i].len);
            cmd.len = 9 + msgs[i].len;
        }

        mtx_unlock(&sc->sc_mtx);
        smu_run_cmd(device_get_parent(dev), &cmd, 1);
        mtx_lock(&sc->sc_mtx);

        for (j = 0; j < 10; j++) {
            cmd.cmd = SMU_I2C;
            cmd.len = 1;
            cmd.data[0] = 0;
            memset(&cmd.data[1], 0xff, msgs[i].len);

            mtx_unlock(&sc->sc_mtx);
            smu_run_cmd(device_get_parent(dev), &cmd, 1);
            mtx_lock(&sc->sc_mtx);

            if (!(cmd.data[0] & 0x80))
                break;

            mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 10);
        }

        if (cmd.data[0] & 0x80) {
            error = EIO;
            msgs[i].len = 0;
            goto exit;
        }
        memcpy(msgs[i].buf, &cmd.data[1], msgs[i].len);
        msgs[i].len = cmd.len - 1;
    }

    exit:
    sc->sc_iic_inuse = 0;
    mtx_unlock(&sc->sc_mtx);
    wakeup(sc);
    return (error);
}

static phandle_t
smuiic_get_node(device_t bus, device_t dev)
{

    return (ofw_bus_get_node(bus));
}



On Mon, Mar 13, 2017 at 11:39 AM, TCH <[hidden email]> wrote:

> Hi.
>
> I've just installed OpenBSD on my PowerMac 11,2. The install was
> successfully done, but when i try to boot it, then in the middle of the
> boot, it stops with the following message:
>
> smu0 at mainbus0: cannot map smu-doorbell gpio
>
> and then it stops and freezes. Slowly after this, the fans in the
> machine are roars up and they begin to blow like hell.
>
> Any ideas on this?
>
> - TCH
>
>
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

Super Bisquit
Now, port this over to OpenBSD and you may have a solution.


On Mon, Mar 13, 2017 at 3:16 PM, Joe Nosay <[hidden email]> wrote:

> ftp://ftp.stu.edu.tw/BSD/OpenBSD/src/sys/arch/macppc/dev/smu.c
> and for cross reference
>
> /*-
>  * Copyright (c) 2009 Nathan Whitehorn
>  * 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.
>  *
>  * 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.
>  *
>  */
>
> #include <sys/cdefs.h>
> __FBSDID("$FreeBSD: head/sys/powerpc/powermac/smu.c 273377 2014-10-21
> 07:31:21Z hselasky $");
>
> #include <sys/param.h>
> #include <sys/bus.h>
> #include <sys/systm.h>
> #include <sys/module.h>
> #include <sys/conf.h>
> #include <sys/cpu.h>
> #include <sys/clock.h>
> #include <sys/ctype.h>
> #include <sys/kernel.h>
> #include <sys/kthread.h>
> #include <sys/reboot.h>
> #include <sys/rman.h>
> #include <sys/sysctl.h>
> #include <sys/unistd.h>
>
> #include <machine/bus.h>
> #include <machine/intr_machdep.h>
> #include <machine/md_var.h>
>
> #include <dev/iicbus/iicbus.h>
> #include <dev/iicbus/iiconf.h>
> #include <dev/led/led.h>
> #include <dev/ofw/openfirm.h>
> #include <dev/ofw/ofw_bus.h>
> #include <dev/ofw/ofw_bus_subr.h>
> #include <powerpc/powermac/macgpiovar.h>
> #include <powerpc/powermac/powermac_thermal.h>
>
> #include "clock_if.h"
> #include "iicbus_if.h"
>
> struct smu_cmd {
>     volatile uint8_t cmd;
>     uint8_t        len;
>     uint8_t        data[254];
>
>     STAILQ_ENTRY(smu_cmd) cmd_q;
> };
>
> STAILQ_HEAD(smu_cmdq, smu_cmd);
>
> struct smu_fan {
>     struct pmac_fan fan;
>     device_t dev;
>     cell_t    reg;
>
>     enum {
>         SMU_FAN_RPM,
>         SMU_FAN_PWM
>     } type;
>     int    setpoint;
>     int    old_style;
>     int     rpm;
> };
>
> /* We can read the PWM and the RPM from a PWM controlled fan.
>  * Offer both values via sysctl.
>  */
> enum {
>     SMU_PWM_SYSCTL_PWM   = 1 << 8,
>     SMU_PWM_SYSCTL_RPM   = 2 << 8
> };
>
> struct smu_sensor {
>     struct pmac_therm therm;
>     device_t dev;
>
>     cell_t    reg;
>     enum {
>         SMU_CURRENT_SENSOR,
>         SMU_VOLTAGE_SENSOR,
>         SMU_POWER_SENSOR,
>         SMU_TEMP_SENSOR
>     } type;
> };
>
> struct smu_softc {
>     device_t    sc_dev;
>     struct mtx    sc_mtx;
>
>     struct resource    *sc_memr;
>     int        sc_memrid;
>     int        sc_u3;
>
>     bus_dma_tag_t    sc_dmatag;
>     bus_space_tag_t    sc_bt;
>     bus_space_handle_t sc_mailbox;
>
>     struct smu_cmd    *sc_cmd, *sc_cur_cmd;
>     bus_addr_t    sc_cmd_phys;
>     bus_dmamap_t    sc_cmd_dmamap;
>     struct smu_cmdq    sc_cmdq;
>
>     struct smu_fan    *sc_fans;
>     int        sc_nfans;
>     int        old_style_fans;
>     struct smu_sensor *sc_sensors;
>     int        sc_nsensors;
>
>     int        sc_doorbellirqid;
>     struct resource    *sc_doorbellirq;
>     void        *sc_doorbellirqcookie;
>
>     struct proc    *sc_fanmgt_proc;
>     time_t        sc_lastuserchange;
>
>     /* Calibration data */
>     uint16_t    sc_cpu_diode_scale;
>     int16_t        sc_cpu_diode_offset;
>
>     uint16_t    sc_cpu_volt_scale;
>     int16_t        sc_cpu_volt_offset;
>     uint16_t    sc_cpu_curr_scale;
>     int16_t        sc_cpu_curr_offset;
>
>     uint16_t    sc_slots_pow_scale;
>     int16_t        sc_slots_pow_offset;
>
>     struct cdev     *sc_leddev;
> };
>
> /* regular bus attachment functions */
>
> static int    smu_probe(device_t);
> static int    smu_attach(device_t);
> static const struct ofw_bus_devinfo *
>     smu_get_devinfo(device_t bus, device_t dev);
>
> /* cpufreq notification hooks */
>
> static void    smu_cpufreq_pre_change(device_t, const struct cf_level
> *level);
> static void    smu_cpufreq_post_change(device_t, const struct cf_level
> *level);
>
> /* clock interface */
> static int    smu_gettime(device_t dev, struct timespec *ts);
> static int    smu_settime(device_t dev, struct timespec *ts);
>
> /* utility functions */
> static int    smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait);
> static int    smu_get_datablock(device_t dev, int8_t id, uint8_t *buf,
>             size_t len);
> static void    smu_attach_i2c(device_t dev, phandle_t i2croot);
> static void    smu_attach_fans(device_t dev, phandle_t fanroot);
> static void    smu_attach_sensors(device_t dev, phandle_t sensroot);
> static void    smu_set_sleepled(void *xdev, int onoff);
> static int    smu_server_mode(SYSCTL_HANDLER_ARGS);
> static void    smu_doorbell_intr(void *xdev);
> static void    smu_shutdown(void *xdev, int howto);
>
> /* where to find the doorbell GPIO */
>
> static device_t    smu_doorbell = NULL;
>
> static device_method_t  smu_methods[] = {
>     /* Device interface */
>     DEVMETHOD(device_probe,        smu_probe),
>     DEVMETHOD(device_attach,    smu_attach),
>
>     /* Clock interface */
>     DEVMETHOD(clock_gettime,    smu_gettime),
>     DEVMETHOD(clock_settime,    smu_settime),
>
>     /* ofw_bus interface */
>     DEVMETHOD(bus_child_pnpinfo_str,ofw_bus_gen_child_pnpinfo_str),
>     DEVMETHOD(ofw_bus_get_devinfo,    smu_get_devinfo),
>     DEVMETHOD(ofw_bus_get_compat,    ofw_bus_gen_get_compat),
>     DEVMETHOD(ofw_bus_get_model,    ofw_bus_gen_get_model),
>     DEVMETHOD(ofw_bus_get_name,    ofw_bus_gen_get_name),
>     DEVMETHOD(ofw_bus_get_node,    ofw_bus_gen_get_node),
>     DEVMETHOD(ofw_bus_get_type,    ofw_bus_gen_get_type),
>
>     { 0, 0 },
> };
>
> static driver_t smu_driver = {
>     "smu",
>     smu_methods,
>     sizeof(struct smu_softc)
> };
>
> static devclass_t smu_devclass;
>
> DRIVER_MODULE(smu, ofwbus, smu_driver, smu_devclass, 0, 0);
> static MALLOC_DEFINE(M_SMU, "smu", "SMU Sensor Information");
>
> #define SMU_MAILBOX        0x8000860c
> #define SMU_FANMGT_INTERVAL    1000 /* ms */
>
> /* Command types */
> #define SMU_ADC            0xd8
> #define SMU_FAN            0x4a
> #define SMU_RPM_STATUS        0x01
> #define SMU_RPM_SETPOINT    0x02
> #define SMU_PWM_STATUS        0x11
> #define SMU_PWM_SETPOINT    0x12
> #define SMU_I2C            0x9a
> #define  SMU_I2C_SIMPLE        0x00
> #define  SMU_I2C_NORMAL        0x01
> #define  SMU_I2C_COMBINED    0x02
> #define SMU_MISC        0xee
> #define  SMU_MISC_GET_DATA    0x02
> #define  SMU_MISC_LED_CTRL    0x04
> #define SMU_POWER        0xaa
> #define SMU_POWER_EVENTS    0x8f
> #define  SMU_PWR_GET_POWERUP    0x00
> #define  SMU_PWR_SET_POWERUP    0x01
> #define  SMU_PWR_CLR_POWERUP    0x02
> #define SMU_RTC            0x8e
> #define  SMU_RTC_GET        0x81
> #define  SMU_RTC_SET        0x80
>
> /* Power event types */
> #define SMU_WAKEUP_KEYPRESS    0x01
> #define SMU_WAKEUP_AC_INSERT    0x02
> #define SMU_WAKEUP_AC_CHANGE    0x04
> #define SMU_WAKEUP_RING        0x10
>
> /* Data blocks */
> #define SMU_CPUTEMP_CAL        0x18
> #define SMU_CPUVOLT_CAL        0x21
> #define SMU_SLOTPW_CAL        0x78
>
> /* Partitions */
> #define SMU_PARTITION        0x3e
> #define SMU_PARTITION_LATEST    0x01
> #define SMU_PARTITION_BASE    0x02
> #define SMU_PARTITION_UPDATE    0x03
>
> static int
> smu_probe(device_t dev)
> {
>     const char *name = ofw_bus_get_name(dev);
>
>     if (strcmp(name, "smu") != 0)
>         return (ENXIO);
>
>     device_set_desc(dev, "Apple System Management Unit");
>     return (0);
> }
>
> static void
> smu_phys_callback(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
> {
>     struct smu_softc *sc = xsc;
>
>     sc->sc_cmd_phys = segs[0].ds_addr;
> }
>
> static int
> smu_attach(device_t dev)
> {
>     struct smu_softc *sc;
>     phandle_t    node, child;
>     uint8_t        data[12];
>
>     sc = device_get_softc(dev);
>
>     mtx_init(&sc->sc_mtx, "smu", NULL, MTX_DEF);
>     sc->sc_cur_cmd = NULL;
>     sc->sc_doorbellirqid = -1;
>
>     sc->sc_u3 = 0;
>     if (OF_finddevice("/u3") != -1)
>         sc->sc_u3 = 1;
>
>     /*
>      * Map the mailbox area. This should be determined from firmware,
>      * but I have not found a simple way to do that.
>      */
>     bus_dma_tag_create(NULL, 16, 0, BUS_SPACE_MAXADDR_32BIT,
>         BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE, 0, NULL,
>         NULL, &(sc->sc_dmatag));
>     sc->sc_bt = &bs_le_tag;
>     bus_space_map(sc->sc_bt, SMU_MAILBOX, 4, 0, &sc->sc_mailbox);
>
>     /*
>      * Allocate the command buffer. This can be anywhere in the low 4 GB
>      * of memory.
>      */
>     bus_dmamem_alloc(sc->sc_dmatag, (void **)&sc->sc_cmd, BUS_DMA_WAITOK
> |
>         BUS_DMA_ZERO, &sc->sc_cmd_dmamap);
>     bus_dmamap_load(sc->sc_dmatag, sc->sc_cmd_dmamap,
>         sc->sc_cmd, PAGE_SIZE, smu_phys_callback, sc, 0);
>     STAILQ_INIT(&sc->sc_cmdq);
>
>     /*
>      * Set up handlers to change CPU voltage when CPU frequency is changed.
>      */
>     EVENTHANDLER_REGISTER(cpufreq_pre_change, smu_cpufreq_pre_change, dev,
>         EVENTHANDLER_PRI_ANY);
>     EVENTHANDLER_REGISTER(cpufreq_post_change, smu_cpufreq_post_change,
> dev,
>         EVENTHANDLER_PRI_ANY);
>
>     node = ofw_bus_get_node(dev);
>
>     /* Some SMUs have RPM and PWM controlled fans which do not sit
>      * under the same node. So we have to attach them separately.
>      */
>     smu_attach_fans(dev, node);
>
>     /*
>      * Now detect and attach the other child devices.
>      */
>     for (child = OF_child(node); child != 0; child = OF_peer(child)) {
>         char name[32];
>         memset(name, 0, sizeof(name));
>         OF_getprop(child, "name", name, sizeof(name));
>
>         if (strncmp(name, "sensors", 8) == 0)
>             smu_attach_sensors(dev, child);
>
>         if (strncmp(name, "smu-i2c-control", 15) == 0)
>             smu_attach_i2c(dev, child);
>     }
>
>     /* Some SMUs have the I2C children directly under the bus. */
>     smu_attach_i2c(dev, node);
>
>     /*
>      * Collect calibration constants.
>      */
>     smu_get_datablock(dev, SMU_CPUTEMP_CAL, data, sizeof(data));
>     sc->sc_cpu_diode_scale = (data[4] << 8) + data[5];
>     sc->sc_cpu_diode_offset = (data[6] << 8) + data[7];
>
>     smu_get_datablock(dev, SMU_CPUVOLT_CAL, data, sizeof(data));
>     sc->sc_cpu_volt_scale = (data[4] << 8) + data[5];
>     sc->sc_cpu_volt_offset = (data[6] << 8) + data[7];
>     sc->sc_cpu_curr_scale = (data[8] << 8) + data[9];
>     sc->sc_cpu_curr_offset = (data[10] << 8) + data[11];
>
>     smu_get_datablock(dev, SMU_SLOTPW_CAL, data, sizeof(data));
>     sc->sc_slots_pow_scale = (data[4] << 8) + data[5];
>     sc->sc_slots_pow_offset = (data[6] << 8) + data[7];
>
>     /*
>      * Set up LED interface
>      */
>     sc->sc_leddev = led_create(smu_set_sleepled, dev, "sleepled");
>
>     /*
>      * Reset on power loss behavior
>      */
>
>     SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
>             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
>         "server_mode", CTLTYPE_INT | CTLFLAG_RW, dev, 0,
>         smu_server_mode, "I", "Enable reboot after power failure");
>
>     /*
>      * Set up doorbell interrupt.
>      */
>     sc->sc_doorbellirqid = 0;
>     sc->sc_doorbellirq = bus_alloc_resource_any(smu_doorbell, SYS_RES_IRQ,
>         &sc->sc_doorbellirqid, RF_ACTIVE);
>     bus_setup_intr(smu_doorbell, sc->sc_doorbellirq,
>         INTR_TYPE_MISC | INTR_MPSAFE, NULL, smu_doorbell_intr, dev,
>         &sc->sc_doorbellirqcookie);
>     powerpc_config_intr(rman_get_start(sc->sc_doorbellirq),
>         INTR_TRIGGER_EDGE, INTR_POLARITY_LOW);
>
>     /*
>      * Connect RTC interface.
>      */
>     clock_register(dev, 1000);
>
>     /*
>      * Learn about shutdown events
>      */
>     EVENTHANDLER_REGISTER(shutdown_final, smu_shutdown, dev,
>         SHUTDOWN_PRI_LAST);
>
>     return (bus_generic_attach(dev));
> }
>
> static const struct ofw_bus_devinfo *
> smu_get_devinfo(device_t bus, device_t dev)
> {
>
>     return (device_get_ivars(dev));
> }
>
> static void
> smu_send_cmd(device_t dev, struct smu_cmd *cmd)
> {
>     struct smu_softc *sc;
>
>     sc = device_get_softc(dev);
>
>     mtx_assert(&sc->sc_mtx, MA_OWNED);
>
>     if (sc->sc_u3)
>         powerpc_pow_enabled = 0; /* SMU cannot work if we go to NAP */
>
>     sc->sc_cur_cmd = cmd;
>
>     /* Copy the command to the mailbox */
>     sc->sc_cmd->cmd = cmd->cmd;
>     sc->sc_cmd->len = cmd->len;
>     memcpy(sc->sc_cmd->data, cmd->data, sizeof(cmd->data));
>     bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap,
> BUS_DMASYNC_PREWRITE);
>     bus_space_write_4(sc->sc_bt, sc->sc_mailbox, 0, sc->sc_cmd_phys);
>
>     /* Flush the cacheline it is in -- SMU bypasses the cache */
>     __asm __volatile("sync; dcbf 0,%0; sync" :: "r"(sc->sc_cmd): "memory");
>
>     /* Ring SMU doorbell */
>     macgpio_write(smu_doorbell, GPIO_DDR_OUTPUT);
> }
>
> static void
> smu_doorbell_intr(void *xdev)
> {
>     device_t smu;
>     struct smu_softc *sc;
>     int doorbell_ack;
>
>     smu = xdev;
>     doorbell_ack = macgpio_read(smu_doorbell);
>     sc = device_get_softc(smu);
>
>     if (doorbell_ack != (GPIO_DDR_OUTPUT | GPIO_LEVEL_RO | GPIO_DATA))
>         return;
>
>     mtx_lock(&sc->sc_mtx);
>
>     if (sc->sc_cur_cmd == NULL)    /* spurious */
>         goto done;
>
>     /* Check result. First invalidate the cache again... */
>     __asm __volatile("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory");
>
>     bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap,
> BUS_DMASYNC_POSTREAD);
>
>     sc->sc_cur_cmd->cmd = sc->sc_cmd->cmd;
>     sc->sc_cur_cmd->len = sc->sc_cmd->len;
>     memcpy(sc->sc_cur_cmd->data, sc->sc_cmd->data,
>         sizeof(sc->sc_cmd->data));
>     wakeup(sc->sc_cur_cmd);
>     sc->sc_cur_cmd = NULL;
>     if (sc->sc_u3)
>         powerpc_pow_enabled = 1;
>
>     done:
>     /* Queue next command if one is pending */
>     if (STAILQ_FIRST(&sc->sc_cmdq) != NULL) {
>         sc->sc_cur_cmd = STAILQ_FIRST(&sc->sc_cmdq);
>         STAILQ_REMOVE_HEAD(&sc->sc_cmdq, cmd_q);
>         smu_send_cmd(smu, sc->sc_cur_cmd);
>     }
>
>     mtx_unlock(&sc->sc_mtx);
> }
>
> static int
> smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait)
> {
>     struct smu_softc *sc;
>     uint8_t cmd_code;
>     int error;
>
>     sc = device_get_softc(dev);
>     cmd_code = cmd->cmd;
>
>     mtx_lock(&sc->sc_mtx);
>     if (sc->sc_cur_cmd != NULL) {
>         STAILQ_INSERT_TAIL(&sc->sc_cmdq, cmd, cmd_q);
>     } else
>         smu_send_cmd(dev, cmd);
>     mtx_unlock(&sc->sc_mtx);
>
>     if (!wait)
>         return (0);
>
>     if (sc->sc_doorbellirqid < 0) {
>         /* Poll if the IRQ has not been set up yet */
>         do {
>             DELAY(50);
>             smu_doorbell_intr(dev);
>         } while (sc->sc_cur_cmd != NULL);
>     } else {
>         /* smu_doorbell_intr will wake us when the command is ACK'ed */
>         error = tsleep(cmd, 0, "smu", 800 * hz / 1000);
>         if (error != 0)
>             smu_doorbell_intr(dev);    /* One last chance */
>
>         if (error != 0) {
>             mtx_lock(&sc->sc_mtx);
>             if (cmd->cmd == cmd_code) {    /* Never processed */
>             /* Abort this command if we timed out */
>             if (sc->sc_cur_cmd == cmd)
>                 sc->sc_cur_cmd = NULL;
>             else
>                 STAILQ_REMOVE(&sc->sc_cmdq, cmd, smu_cmd,
>                     cmd_q);
>             mtx_unlock(&sc->sc_mtx);
>             return (error);
>             }
>             error = 0;
>             mtx_unlock(&sc->sc_mtx);
>         }
>     }
>
>     /* SMU acks the command by inverting the command bits */
>     if (cmd->cmd == ((~cmd_code) & 0xff))
>         error = 0;
>     else
>         error = EIO;
>
>     return (error);
> }
>
> static int
> smu_get_datablock(device_t dev, int8_t id, uint8_t *buf, size_t len)
> {
>     struct smu_cmd cmd;
>     uint8_t addr[4];
>
>     cmd.cmd = SMU_PARTITION;
>     cmd.len = 2;
>     cmd.data[0] = SMU_PARTITION_LATEST;
>     cmd.data[1] = id;
>
>     smu_run_cmd(dev, &cmd, 1);
>
>     addr[0] = addr[1] = 0;
>     addr[2] = cmd.data[0];
>     addr[3] = cmd.data[1];
>
>     cmd.cmd = SMU_MISC;
>     cmd.len = 7;
>     cmd.data[0] = SMU_MISC_GET_DATA;
>     cmd.data[1] = sizeof(addr);
>     memcpy(&cmd.data[2], addr, sizeof(addr));
>     cmd.data[6] = len;
>
>     smu_run_cmd(dev, &cmd, 1);
>     memcpy(buf, cmd.data, len);
>     return (0);
> }
>
> static void
> smu_slew_cpu_voltage(device_t dev, int to)
> {
>     struct smu_cmd cmd;
>
>     cmd.cmd = SMU_POWER;
>     cmd.len = 8;
>     cmd.data[0] = 'V';
>     cmd.data[1] = 'S';
>     cmd.data[2] = 'L';
>     cmd.data[3] = 'E';
>     cmd.data[4] = 'W';
>     cmd.data[5] = 0xff;
>     cmd.data[6] = 1;
>     cmd.data[7] = to;
>
>     smu_run_cmd(dev, &cmd, 1);
> }
>
> static void
> smu_cpufreq_pre_change(device_t dev, const struct cf_level *level)
> {
>     /*
>      * Make sure the CPU voltage is raised before we raise
>      * the clock.
>      */
>
>     if (level->rel_set[0].freq == 10000 /* max */)
>         smu_slew_cpu_voltage(dev, 0);
> }
>
> static void
> smu_cpufreq_post_change(device_t dev, const struct cf_level *level)
> {
>     /* We are safe to reduce CPU voltage after a downward transition */
>
>     if (level->rel_set[0].freq < 10000 /* max */)
>         smu_slew_cpu_voltage(dev, 1); /* XXX: 1/4 voltage for 970MP? */
> }
>
> /* Routines for probing the SMU doorbell GPIO */
> static int doorbell_probe(device_t dev);
> static int doorbell_attach(device_t dev);
>
> static device_method_t  doorbell_methods[] = {
>     /* Device interface */
>     DEVMETHOD(device_probe,        doorbell_probe),
>     DEVMETHOD(device_attach,    doorbell_attach),
>     { 0, 0 },
> };
>
> static driver_t doorbell_driver = {
>     "smudoorbell",
>     doorbell_methods,
>     0
> };
>
> static devclass_t doorbell_devclass;
>
> DRIVER_MODULE(smudoorbell, macgpio, doorbell_driver, doorbell_devclass, 0,
> 0);
>
> static int
> doorbell_probe(device_t dev)
> {
>     const char *name = ofw_bus_get_name(dev);
>
>     if (strcmp(name, "smu-doorbell") != 0)
>         return (ENXIO);
>
>     device_set_desc(dev, "SMU Doorbell GPIO");
>     device_quiet(dev);
>     return (0);
> }
>
> static int
> doorbell_attach(device_t dev)
> {
>     smu_doorbell = dev;
>     return (0);
> }
>
> /*
>  * Sensor and fan management
>  */
>
> static int
> smu_fan_check_old_style(struct smu_fan *fan)
> {
>     device_t smu = fan->dev;
>     struct smu_softc *sc = device_get_softc(smu);
>     struct smu_cmd cmd;
>     int error;
>
>     if (sc->old_style_fans != -1)
>         return (sc->old_style_fans);
>
>     /*
>      * Apple has two fan control mechanisms. We can't distinguish
>      * them except by seeing if the new one fails. If the new one
>      * fails, use the old one.
>      */
>
>     cmd.cmd = SMU_FAN;
>     cmd.len = 2;
>     cmd.data[0] = 0x31;
>     cmd.data[1] = fan->reg;
>
>     do {
>         error = smu_run_cmd(smu, &cmd, 1);
>     } while (error == EWOULDBLOCK);
>
>     sc->old_style_fans = (error != 0);
>
>     return (sc->old_style_fans);
> }
>
> static int
> smu_fan_set_rpm(struct smu_fan *fan, int rpm)
> {
>     device_t smu = fan->dev;
>     struct smu_cmd cmd;
>     int error;
>
>     cmd.cmd = SMU_FAN;
>     error = EIO;
>
>     /* Clamp to allowed range */
>     rpm = max(fan->fan.min_rpm, rpm);
>     rpm = min(fan->fan.max_rpm, rpm);
>
>     smu_fan_check_old_style(fan);
>
>     if (!fan->old_style) {
>         cmd.len = 4;
>         cmd.data[0] = 0x30;
>         cmd.data[1] = fan->reg;
>         cmd.data[2] = (rpm >> 8) & 0xff;
>         cmd.data[3] = rpm & 0xff;
>
>         error = smu_run_cmd(smu, &cmd, 1);
>         if (error && error != EWOULDBLOCK)
>             fan->old_style = 1;
>     } else {
>         cmd.len = 14;
>         cmd.data[0] = 0x00; /* RPM fan. */
>         cmd.data[1] = 1 << fan->reg;
>         cmd.data[2 + 2*fan->reg] = (rpm >> 8) & 0xff;
>         cmd.data[3 + 2*fan->reg] = rpm & 0xff;
>         error = smu_run_cmd(smu, &cmd, 1);
>     }
>
>     if (error == 0)
>         fan->setpoint = rpm;
>
>     return (error);
> }
>
> static int
> smu_fan_read_rpm(struct smu_fan *fan)
> {
>     device_t smu = fan->dev;
>     struct smu_cmd cmd;
>     int rpm, error;
>
>     smu_fan_check_old_style(fan);
>
>     if (!fan->old_style) {
>         cmd.cmd = SMU_FAN;
>         cmd.len = 2;
>         cmd.data[0] = 0x31;
>         cmd.data[1] = fan->reg;
>
>         error = smu_run_cmd(smu, &cmd, 1);
>         if (error && error != EWOULDBLOCK)
>             fan->old_style = 1;
>
>         rpm = (cmd.data[0] << 8) | cmd.data[1];
>     }
>
>     if (fan->old_style) {
>         cmd.cmd = SMU_FAN;
>         cmd.len = 1;
>         cmd.data[0] = SMU_RPM_STATUS;
>
>         error = smu_run_cmd(smu, &cmd, 1);
>         if (error)
>             return (error);
>
>         rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2];
>     }
>
>     return (rpm);
> }
> static int
> smu_fan_set_pwm(struct smu_fan *fan, int pwm)
> {
>     device_t smu = fan->dev;
>     struct smu_cmd cmd;
>     int error;
>
>     cmd.cmd = SMU_FAN;
>     error = EIO;
>
>     /* Clamp to allowed range */
>     pwm = max(fan->fan.min_rpm, pwm);
>     pwm = min(fan->fan.max_rpm, pwm);
>
>     /*
>      * Apple has two fan control mechanisms. We can't distinguish
>      * them except by seeing if the new one fails. If the new one
>      * fails, use the old one.
>      */
>
>     if (!fan->old_style) {
>         cmd.len = 4;
>         cmd.data[0] = 0x30;
>         cmd.data[1] = fan->reg;
>         cmd.data[2] = (pwm >> 8) & 0xff;
>         cmd.data[3] = pwm & 0xff;
>
>         error = smu_run_cmd(smu, &cmd, 1);
>         if (error && error != EWOULDBLOCK)
>             fan->old_style = 1;
>     }
>
>     if (fan->old_style) {
>         cmd.len = 14;
>         cmd.data[0] = 0x10; /* PWM fan. */
>         cmd.data[1] = 1 << fan->reg;
>         cmd.data[2 + 2*fan->reg] = (pwm >> 8) & 0xff;
>         cmd.data[3 + 2*fan->reg] = pwm & 0xff;
>         error = smu_run_cmd(smu, &cmd, 1);
>     }
>
>     if (error == 0)
>         fan->setpoint = pwm;
>
>     return (error);
> }
>
> static int
> smu_fan_read_pwm(struct smu_fan *fan, int *pwm, int *rpm)
> {
>     device_t smu = fan->dev;
>     struct smu_cmd cmd;
>     int error;
>
>     if (!fan->old_style) {
>         cmd.cmd = SMU_FAN;
>         cmd.len = 2;
>         cmd.data[0] = 0x31;
>         cmd.data[1] = fan->reg;
>
>         error = smu_run_cmd(smu, &cmd, 1);
>         if (error && error != EWOULDBLOCK)
>             fan->old_style = 1;
>
>         *rpm = (cmd.data[0] << 8) | cmd.data[1];
>     }
>
>     if (fan->old_style) {
>         cmd.cmd = SMU_FAN;
>         cmd.len = 1;
>         cmd.data[0] = SMU_PWM_STATUS;
>
>         error = smu_run_cmd(smu, &cmd, 1);
>         if (error)
>             return (error);
>
>         *rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2];
>     }
>     if (fan->old_style) {
>         cmd.cmd = SMU_FAN;
>         cmd.len = 14;
>         cmd.data[0] = SMU_PWM_SETPOINT;
>         cmd.data[1] = 1 << fan->reg;
>
>         error = smu_run_cmd(smu, &cmd, 1);
>         if (error)
>             return (error);
>
>         *pwm = cmd.data[fan->reg*2+2];
>     }
>     return (0);
> }
>
> static int
> smu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS)
> {
>     device_t smu;
>     struct smu_softc *sc;
>     struct smu_fan *fan;
>     int pwm = 0, rpm, error = 0;
>
>     smu = arg1;
>     sc = device_get_softc(smu);
>     fan = &sc->sc_fans[arg2 & 0xff];
>
>     if (fan->type == SMU_FAN_RPM) {
>         rpm = smu_fan_read_rpm(fan);
>         if (rpm < 0)
>             return (rpm);
>
>         error = sysctl_handle_int(oidp, &rpm, 0, req);
>     } else {
>         error = smu_fan_read_pwm(fan, &pwm, &rpm);
>         if (error < 0)
>             return (EIO);
>
>         switch (arg2 & 0xff00) {
>         case SMU_PWM_SYSCTL_PWM:
>             error = sysctl_handle_int(oidp, &pwm, 0, req);
>             break;
>         case SMU_PWM_SYSCTL_RPM:
>             error = sysctl_handle_int(oidp, &rpm, 0, req);
>             break;
>         default:
>             /* This should never happen */
>             return (EINVAL);
>         };
>     }
>     /* We can only read the RPM from a PWM controlled fan, so return. */
>     if ((arg2 & 0xff00) == SMU_PWM_SYSCTL_RPM)
>         return (0);
>
>     if (error || !req->newptr)
>         return (error);
>
>     sc->sc_lastuserchange = time_uptime;
>
>     if (fan->type == SMU_FAN_RPM)
>         return (smu_fan_set_rpm(fan, rpm));
>     else
>         return (smu_fan_set_pwm(fan, pwm));
> }
>
> static void
> smu_fill_fan_prop(device_t dev, phandle_t child, int id)
> {
>     struct smu_fan *fan;
>     struct smu_softc *sc;
>     char type[32];
>
>     sc = device_get_softc(dev);
>     fan = &sc->sc_fans[id];
>
>     OF_getprop(child, "device_type", type, sizeof(type));
>     /* We have either RPM or PWM controlled fans. */
>     if (strcmp(type, "fan-rpm-control") == 0)
>         fan->type = SMU_FAN_RPM;
>     else
>         fan->type = SMU_FAN_PWM;
>
>     fan->dev = dev;
>     fan->old_style = 0;
>     OF_getprop(child, "reg", &fan->reg,
>            sizeof(cell_t));
>     OF_getprop(child, "min-value", &fan->fan.min_rpm,
>            sizeof(int));
>     OF_getprop(child, "max-value", &fan->fan.max_rpm,
>            sizeof(int));
>     OF_getprop(child, "zone", &fan->fan.zone,
>            sizeof(int));
>
>     if (OF_getprop(child, "unmanaged-value",
>                &fan->fan.default_rpm,
>                sizeof(int)) != sizeof(int))
>         fan->fan.default_rpm = fan->fan.max_rpm;
>
>     OF_getprop(child, "location", fan->fan.name,
>            sizeof(fan->fan.name));
>
>     if (fan->type == SMU_FAN_RPM)
>         fan->setpoint = smu_fan_read_rpm(fan);
>     else
>         smu_fan_read_pwm(fan, &fan->setpoint, &fan->rpm);
> }
>
> /* On the first call count the number of fans. In the second call,
>  * after allocating the fan struct, fill the properties of the fans.
>  */
> static int
> smu_count_fans(device_t dev)
> {
>     struct smu_softc *sc;
>     phandle_t child, node, root;
>     int nfans = 0;
>
>     node = ofw_bus_get_node(dev);
>     sc = device_get_softc(dev);
>
>     /* First find the fanroots and count the number of fans. */
>     for (root = OF_child(node); root != 0; root = OF_peer(root)) {
>         char name[32];
>         memset(name, 0, sizeof(name));
>         OF_getprop(root, "name", name, sizeof(name));
>         if (strncmp(name, "rpm-fans", 9) == 0 ||
>             strncmp(name, "pwm-fans", 9) == 0 ||
>             strncmp(name, "fans", 5) == 0)
>             for (child = OF_child(root); child != 0;
>                  child = OF_peer(child)) {
>                 nfans++;
>                 /* When allocated, fill the fan properties. */
>                 if (sc->sc_fans != NULL) {
>                     smu_fill_fan_prop(dev, child,
>                               nfans - 1);
>                 }
>             }
>     }
>     if (nfans == 0) {
>         device_printf(dev, "WARNING: No fans detected!\n");
>         return (0);
>     }
>     return (nfans);
> }
>
> static void
> smu_attach_fans(device_t dev, phandle_t fanroot)
> {
>     struct smu_fan *fan;
>     struct smu_softc *sc;
>     struct sysctl_oid *oid, *fanroot_oid;
>     struct sysctl_ctx_list *ctx;
>     char sysctl_name[32];
>     int i, j;
>
>     sc = device_get_softc(dev);
>
>     /* Get the number of fans. */
>     sc->sc_nfans = smu_count_fans(dev);
>     if (sc->sc_nfans == 0)
>         return;
>
>     /* Now we're able to allocate memory for the fans struct. */
>     sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct smu_fan), M_SMU,
>         M_WAITOK | M_ZERO);
>
>     /* Now fill in the properties. */
>     smu_count_fans(dev);
>
>     /* Register fans with pmac_thermal */
>     for (i = 0; i < sc->sc_nfans; i++)
>         pmac_thermal_fan_register(&sc->sc_fans[i].fan);
>
>     ctx = device_get_sysctl_ctx(dev);
>     fanroot_oid = SYSCTL_ADD_NODE(ctx,
>         SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans",
>         CTLFLAG_RD, 0, "SMU Fan Information");
>
>     /* Add sysctls */
>     for (i = 0; i < sc->sc_nfans; i++) {
>         fan = &sc->sc_fans[i];
>         for (j = 0; j < strlen(fan->fan.name); j++) {
>             sysctl_name[j] = tolower(fan->fan.name[j]);
>             if (isspace(sysctl_name[j]))
>                 sysctl_name[j] = '_';
>         }
>         sysctl_name[j] = 0;
>         if (fan->type == SMU_FAN_RPM) {
>             oid = SYSCTL_ADD_NODE(ctx,
>                           SYSCTL_CHILDREN(fanroot_oid),
>                           OID_AUTO, sysctl_name,
>                           CTLFLAG_RD, 0, "Fan Information");
>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>                        "minrpm", CTLFLAG_RD,
>                        &fan->fan.min_rpm, 0,
>                        "Minimum allowed RPM");
>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>                        "maxrpm", CTLFLAG_RD,
>                        &fan->fan.max_rpm, 0,
>                        "Maximum allowed RPM");
>             SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>                     "rpm",CTLTYPE_INT | CTLFLAG_RW |
>                     CTLFLAG_MPSAFE, dev, i,
>                     smu_fanrpm_sysctl, "I", "Fan RPM");
>
>             fan->fan.read = (int (*)(struct pmac_fan *))smu_fan_read_rpm;
>             fan->fan.set = (int (*)(struct pmac_fan *,
> int))smu_fan_set_rpm;
>
>         } else {
>             oid = SYSCTL_ADD_NODE(ctx,
>                           SYSCTL_CHILDREN(fanroot_oid),
>                           OID_AUTO, sysctl_name,
>                           CTLFLAG_RD, 0, "Fan Information");
>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>                        "minpwm", CTLFLAG_RD,
>                        &fan->fan.min_rpm, 0,
>                        "Minimum allowed PWM in %");
>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>                        "maxpwm", CTLFLAG_RD,
>                        &fan->fan.max_rpm, 0,
>                        "Maximum allowed PWM in %");
>             SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>                     "pwm",CTLTYPE_INT | CTLFLAG_RW |
>                     CTLFLAG_MPSAFE, dev,
>                     SMU_PWM_SYSCTL_PWM | i,
>                     smu_fanrpm_sysctl, "I", "Fan PWM in %");
>             SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>                     "rpm",CTLTYPE_INT | CTLFLAG_RD |
>                     CTLFLAG_MPSAFE, dev,
>                     SMU_PWM_SYSCTL_RPM | i,
>                     smu_fanrpm_sysctl, "I", "Fan RPM");
>             fan->fan.read = NULL;
>             fan->fan.set = (int (*)(struct pmac_fan *,
> int))smu_fan_set_pwm;
>
>         }
>         if (bootverbose)
>             device_printf(dev, "Fan: %s type: %d\n",
>                       fan->fan.name, fan->type);
>     }
> }
>
> static int
> smu_sensor_read(struct smu_sensor *sens)
> {
>     device_t smu = sens->dev;
>     struct smu_cmd cmd;
>     struct smu_softc *sc;
>     int64_t value;
>     int error;
>
>     cmd.cmd = SMU_ADC;
>     cmd.len = 1;
>     cmd.data[0] = sens->reg;
>     error = 0;
>
>     error = smu_run_cmd(smu, &cmd, 1);
>     if (error != 0)
>         return (-1);
>
>     sc = device_get_softc(smu);
>     value = (cmd.data[0] << 8) | cmd.data[1];
>
>     switch (sens->type) {
>     case SMU_TEMP_SENSOR:
>         value *= sc->sc_cpu_diode_scale;
>         value >>= 3;
>         value += ((int64_t)sc->sc_cpu_diode_offset) << 9;
>         value <<= 1;
>
>         /* Convert from 16.16 fixed point degC into integer 0.1 K. */
>         value = 10*(value >> 16) + ((10*(value & 0xffff)) >> 16) + 2732;
>         break;
>     case SMU_VOLTAGE_SENSOR:
>         value *= sc->sc_cpu_volt_scale;
>         value += sc->sc_cpu_volt_offset;
>         value <<= 4;
>
>         /* Convert from 16.16 fixed point V into mV. */
>         value *= 15625;
>         value /= 1024;
>         value /= 1000;
>         break;
>     case SMU_CURRENT_SENSOR:
>         value *= sc->sc_cpu_curr_scale;
>         value += sc->sc_cpu_curr_offset;
>         value <<= 4;
>
>         /* Convert from 16.16 fixed point A into mA. */
>         value *= 15625;
>         value /= 1024;
>         value /= 1000;
>         break;
>     case SMU_POWER_SENSOR:
>         value *= sc->sc_slots_pow_scale;
>         value += sc->sc_slots_pow_offset;
>         value <<= 4;
>
>         /* Convert from 16.16 fixed point W into mW. */
>         value *= 15625;
>         value /= 1024;
>         value /= 1000;
>         break;
>     }
>
>     return (value);
> }
>
> static int
> smu_sensor_sysctl(SYSCTL_HANDLER_ARGS)
> {
>     device_t smu;
>     struct smu_softc *sc;
>     struct smu_sensor *sens;
>     int value, error;
>
>     smu = arg1;
>     sc = device_get_softc(smu);
>     sens = &sc->sc_sensors[arg2];
>
>     value = smu_sensor_read(sens);
>     if (value < 0)
>         return (EBUSY);
>
>     error = sysctl_handle_int(oidp, &value, 0, req);
>
>     return (error);
> }
>
> static void
> smu_attach_sensors(device_t dev, phandle_t sensroot)
> {
>     struct smu_sensor *sens;
>     struct smu_softc *sc;
>     struct sysctl_oid *sensroot_oid;
>     struct sysctl_ctx_list *ctx;
>     phandle_t child;
>     char type[32];
>     int i;
>
>     sc = device_get_softc(dev);
>     sc->sc_nsensors = 0;
>
>     for (child = OF_child(sensroot); child != 0; child = OF_peer(child))
>         sc->sc_nsensors++;
>
>     if (sc->sc_nsensors == 0) {
>         device_printf(dev, "WARNING: No sensors detected!\n");
>         return;
>     }
>
>     sc->sc_sensors = malloc(sc->sc_nsensors * sizeof(struct smu_sensor),
>         M_SMU, M_WAITOK | M_ZERO);
>
>     sens = sc->sc_sensors;
>     sc->sc_nsensors = 0;
>
>     ctx = device_get_sysctl_ctx(dev);
>     sensroot_oid = SYSCTL_ADD_NODE(ctx,
>         SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensors",
>         CTLFLAG_RD, 0, "SMU Sensor Information");
>
>     for (child = OF_child(sensroot); child != 0; child = OF_peer(child)) {
>         char sysctl_name[40], sysctl_desc[40];
>         const char *units;
>
>         sens->dev = dev;
>         OF_getprop(child, "device_type", type, sizeof(type));
>
>         if (strcmp(type, "current-sensor") == 0) {
>             sens->type = SMU_CURRENT_SENSOR;
>             units = "mA";
>         } else if (strcmp(type, "temp-sensor") == 0) {
>             sens->type = SMU_TEMP_SENSOR;
>             units = "C";
>         } else if (strcmp(type, "voltage-sensor") == 0) {
>             sens->type = SMU_VOLTAGE_SENSOR;
>             units = "mV";
>         } else if (strcmp(type, "power-sensor") == 0) {
>             sens->type = SMU_POWER_SENSOR;
>             units = "mW";
>         } else {
>             continue;
>         }
>
>         OF_getprop(child, "reg", &sens->reg, sizeof(cell_t));
>         OF_getprop(child, "zone", &sens->therm.zone, sizeof(int));
>         OF_getprop(child, "location", sens->therm.name,
>             sizeof(sens->therm.name));
>
>         for (i = 0; i < strlen(sens->therm.name); i++) {
>             sysctl_name[i] = tolower(sens->therm.name[i]);
>             if (isspace(sysctl_name[i]))
>                 sysctl_name[i] = '_';
>         }
>         sysctl_name[i] = 0;
>
>         sprintf(sysctl_desc,"%s (%s)", sens->therm.name, units);
>
>         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(sensroot_oid), OID_AUTO,
>             sysctl_name, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
>             dev, sc->sc_nsensors, smu_sensor_sysctl,
>             (sens->type == SMU_TEMP_SENSOR) ? "IK" : "I", sysctl_desc);
>
>         if (sens->type == SMU_TEMP_SENSOR) {
>             /* Make up some numbers */
>             sens->therm.target_temp = 500 + 2732; /* 50 C */
>             sens->therm.max_temp = 900 + 2732; /* 90 C */
>
>             sens->therm.read =
>                 (int (*)(struct pmac_therm *))smu_sensor_read;
>             pmac_thermal_sensor_register(&sens->therm);
>         }
>
>         sens++;
>         sc->sc_nsensors++;
>     }
> }
>
> static void
> smu_set_sleepled(void *xdev, int onoff)
> {
>     static struct smu_cmd cmd;
>     device_t smu = xdev;
>
>     cmd.cmd = SMU_MISC;
>     cmd.len = 3;
>     cmd.data[0] = SMU_MISC_LED_CTRL;
>     cmd.data[1] = 0;
>     cmd.data[2] = onoff;
>
>     smu_run_cmd(smu, &cmd, 0);
> }
>
> static int
> smu_server_mode(SYSCTL_HANDLER_ARGS)
> {
>     struct smu_cmd cmd;
>     u_int server_mode;
>     device_t smu = arg1;
>     int error;
>
>     cmd.cmd = SMU_POWER_EVENTS;
>     cmd.len = 1;
>     cmd.data[0] = SMU_PWR_GET_POWERUP;
>
>     error = smu_run_cmd(smu, &cmd, 1);
>
>     if (error)
>         return (error);
>
>     server_mode = (cmd.data[1] & SMU_WAKEUP_AC_INSERT) ? 1 : 0;
>
>     error = sysctl_handle_int(oidp, &server_mode, 0, req);
>
>     if (error || !req->newptr)
>         return (error);
>
>     if (server_mode == 1)
>         cmd.data[0] = SMU_PWR_SET_POWERUP;
>     else if (server_mode == 0)
>         cmd.data[0] = SMU_PWR_CLR_POWERUP;
>     else
>         return (EINVAL);
>
>     cmd.len = 3;
>     cmd.data[1] = 0;
>     cmd.data[2] = SMU_WAKEUP_AC_INSERT;
>
>     return (smu_run_cmd(smu, &cmd, 1));
> }
>
> static void
> smu_shutdown(void *xdev, int howto)
> {
>     device_t smu = xdev;
>     struct smu_cmd cmd;
>
>     cmd.cmd = SMU_POWER;
>     if (howto & RB_HALT)
>         strcpy(cmd.data, "SHUTDOWN");
>     else
>         strcpy(cmd.data, "RESTART");
>
>     cmd.len = strlen(cmd.data);
>
>     smu_run_cmd(smu, &cmd, 1);
>
>     for (;;);
> }
>
> static int
> smu_gettime(device_t dev, struct timespec *ts)
> {
>     struct smu_cmd cmd;
>     struct clocktime ct;
>
>     cmd.cmd = SMU_RTC;
>     cmd.len = 1;
>     cmd.data[0] = SMU_RTC_GET;
>
>     if (smu_run_cmd(dev, &cmd, 1) != 0)
>         return (ENXIO);
>
>     ct.nsec    = 0;
>     ct.sec    = bcd2bin(cmd.data[0]);
>     ct.min    = bcd2bin(cmd.data[1]);
>     ct.hour    = bcd2bin(cmd.data[2]);
>     ct.dow    = bcd2bin(cmd.data[3]);
>     ct.day    = bcd2bin(cmd.data[4]);
>     ct.mon    = bcd2bin(cmd.data[5]);
>     ct.year    = bcd2bin(cmd.data[6]) + 2000;
>
>     return (clock_ct_to_ts(&ct, ts));
> }
>
> static int
> smu_settime(device_t dev, struct timespec *ts)
> {
>     static struct smu_cmd cmd;
>     struct clocktime ct;
>
>     cmd.cmd = SMU_RTC;
>     cmd.len = 8;
>     cmd.data[0] = SMU_RTC_SET;
>
>     clock_ts_to_ct(ts, &ct);
>
>     cmd.data[1] = bin2bcd(ct.sec);
>     cmd.data[2] = bin2bcd(ct.min);
>     cmd.data[3] = bin2bcd(ct.hour);
>     cmd.data[4] = bin2bcd(ct.dow);
>     cmd.data[5] = bin2bcd(ct.day);
>     cmd.data[6] = bin2bcd(ct.mon);
>     cmd.data[7] = bin2bcd(ct.year - 2000);
>
>     return (smu_run_cmd(dev, &cmd, 0));
> }
>
> /* SMU I2C Interface */
>
> static int smuiic_probe(device_t dev);
> static int smuiic_attach(device_t dev);
> static int smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t
> nmsgs);
> static phandle_t smuiic_get_node(device_t bus, device_t dev);
>
> static device_method_t smuiic_methods[] = {
>     /* device interface */
>     DEVMETHOD(device_probe,         smuiic_probe),
>     DEVMETHOD(device_attach,        smuiic_attach),
>
>     /* iicbus interface */
>     DEVMETHOD(iicbus_callback,      iicbus_null_callback),
>     DEVMETHOD(iicbus_transfer,      smuiic_transfer),
>
>     /* ofw_bus interface */
>     DEVMETHOD(ofw_bus_get_node,     smuiic_get_node),
>
>     { 0, 0 }
> };
>
> struct smuiic_softc {
>     struct mtx    sc_mtx;
>     volatile int    sc_iic_inuse;
>     int        sc_busno;
> };
>
> static driver_t smuiic_driver = {
>     "iichb",
>     smuiic_methods,
>     sizeof(struct smuiic_softc)
> };
> static devclass_t smuiic_devclass;
>
> DRIVER_MODULE(smuiic, smu, smuiic_driver, smuiic_devclass, 0, 0);
>
> static void
> smu_attach_i2c(device_t smu, phandle_t i2croot)
> {
>     phandle_t child;
>     device_t cdev;
>     struct ofw_bus_devinfo *dinfo;
>     char name[32];
>
>     for (child = OF_child(i2croot); child != 0; child = OF_peer(child)) {
>         if (OF_getprop(child, "name", name, sizeof(name)) <= 0)
>             continue;
>
>         if (strcmp(name, "i2c-bus") != 0 && strcmp(name, "i2c") != 0)
>             continue;
>
>         dinfo = malloc(sizeof(struct ofw_bus_devinfo), M_SMU,
>             M_WAITOK | M_ZERO);
>         if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
>             free(dinfo, M_SMU);
>             continue;
>         }
>
>         cdev = device_add_child(smu, NULL, -1);
>         if (cdev == NULL) {
>             device_printf(smu, "<%s>: device_add_child failed\n",
>                 dinfo->obd_name);
>             ofw_bus_gen_destroy_devinfo(dinfo);
>             free(dinfo, M_SMU);
>             continue;
>         }
>         device_set_ivars(cdev, dinfo);
>     }
> }
>
> static int
> smuiic_probe(device_t dev)
> {
>     const char *name;
>
>     name = ofw_bus_get_name(dev);
>     if (name == NULL)
>         return (ENXIO);
>
>     if (strcmp(name, "i2c-bus") == 0 || strcmp(name, "i2c") == 0) {
>         device_set_desc(dev, "SMU I2C controller");
>         return (0);
>     }
>
>     return (ENXIO);
> }
>
> static int
> smuiic_attach(device_t dev)
> {
>     struct smuiic_softc *sc = device_get_softc(dev);
>     mtx_init(&sc->sc_mtx, "smuiic", NULL, MTX_DEF);
>     sc->sc_iic_inuse = 0;
>
>     /* Get our bus number */
>     OF_getprop(ofw_bus_get_node(dev), "reg", &sc->sc_busno,
>         sizeof(sc->sc_busno));
>
>     /* Add the IIC bus layer */
>     device_add_child(dev, "iicbus", -1);
>
>     return (bus_generic_attach(dev));
> }
>
> static int
> smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
> {
>     struct smuiic_softc *sc = device_get_softc(dev);
>     struct smu_cmd cmd;
>     int i, j, error;
>
>     mtx_lock(&sc->sc_mtx);
>     while (sc->sc_iic_inuse)
>         mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 100);
>
>     sc->sc_iic_inuse = 1;
>     error = 0;
>
>     for (i = 0; i < nmsgs; i++) {
>         cmd.cmd = SMU_I2C;
>         cmd.data[0] = sc->sc_busno;
>         if (msgs[i].flags & IIC_M_NOSTOP)
>             cmd.data[1] = SMU_I2C_COMBINED;
>         else
>             cmd.data[1] = SMU_I2C_SIMPLE;
>
>         cmd.data[2] = msgs[i].slave;
>         if (msgs[i].flags & IIC_M_RD)
>             cmd.data[2] |= 1;
>
>         if (msgs[i].flags & IIC_M_NOSTOP) {
>             KASSERT(msgs[i].len < 4,
>                 ("oversize I2C combined message"));
>
>             cmd.data[3] = min(msgs[i].len, 3);
>             memcpy(&cmd.data[4], msgs[i].buf, min(msgs[i].len, 3));
>             i++; /* Advance to next part of message */
>         } else {
>             cmd.data[3] = 0;
>             memset(&cmd.data[4], 0, 3);
>         }
>
>         cmd.data[7] = msgs[i].slave;
>         if (msgs[i].flags & IIC_M_RD)
>             cmd.data[7] |= 1;
>
>         cmd.data[8] = msgs[i].len;
>         if (msgs[i].flags & IIC_M_RD) {
>             memset(&cmd.data[9], 0xff, msgs[i].len);
>             cmd.len = 9;
>         } else {
>             memcpy(&cmd.data[9], msgs[i].buf, msgs[i].len);
>             cmd.len = 9 + msgs[i].len;
>         }
>
>         mtx_unlock(&sc->sc_mtx);
>         smu_run_cmd(device_get_parent(dev), &cmd, 1);
>         mtx_lock(&sc->sc_mtx);
>
>         for (j = 0; j < 10; j++) {
>             cmd.cmd = SMU_I2C;
>             cmd.len = 1;
>             cmd.data[0] = 0;
>             memset(&cmd.data[1], 0xff, msgs[i].len);
>
>             mtx_unlock(&sc->sc_mtx);
>             smu_run_cmd(device_get_parent(dev), &cmd, 1);
>             mtx_lock(&sc->sc_mtx);
>
>             if (!(cmd.data[0] & 0x80))
>                 break;
>
>             mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 10);
>         }
>
>         if (cmd.data[0] & 0x80) {
>             error = EIO;
>             msgs[i].len = 0;
>             goto exit;
>         }
>         memcpy(msgs[i].buf, &cmd.data[1], msgs[i].len);
>         msgs[i].len = cmd.len - 1;
>     }
>
>     exit:
>     sc->sc_iic_inuse = 0;
>     mtx_unlock(&sc->sc_mtx);
>     wakeup(sc);
>     return (error);
> }
>
> static phandle_t
> smuiic_get_node(device_t bus, device_t dev)
> {
>
>     return (ofw_bus_get_node(bus));
> }
>
>
>
> On Mon, Mar 13, 2017 at 11:39 AM, TCH <[hidden email]> wrote:
>
>> Hi.
>>
>> I've just installed OpenBSD on my PowerMac 11,2. The install was
>> successfully done, but when i try to boot it, then in the middle of the
>> boot, it stops with the following message:
>>
>> smu0 at mainbus0: cannot map smu-doorbell gpio
>>
>> and then it stops and freezes. Slowly after this, the fans in the
>> machine are roars up and they begin to blow like hell.
>>
>> Any ideas on this?
>>
>> - TCH
>>
>>
>
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

Peter Kay-5
OpenBSD current as of a couple of weeks ago boots just fine on my Dual
core 2.3GHz G5.

How much memory is in it, and is it correctly installed (in pairs,
from the centre outwards) ?

On 13 March 2017 at 19:17, Joe Nosay <[hidden email]> wrote:

> Now, port this over to OpenBSD and you may have a solution.
>
>
> On Mon, Mar 13, 2017 at 3:16 PM, Joe Nosay <[hidden email]> wrote:
>
>> ftp://ftp.stu.edu.tw/BSD/OpenBSD/src/sys/arch/macppc/dev/smu.c
>> and for cross reference
>>
>> /*-
>>  * Copyright (c) 2009 Nathan Whitehorn
>>  * 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.
>>  *
>>  * 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.
>>  *
>>  */
>>
>> #include <sys/cdefs.h>
>> __FBSDID("$FreeBSD: head/sys/powerpc/powermac/smu.c 273377 2014-10-21
>> 07:31:21Z hselasky $");
>>
>> #include <sys/param.h>
>> #include <sys/bus.h>
>> #include <sys/systm.h>
>> #include <sys/module.h>
>> #include <sys/conf.h>
>> #include <sys/cpu.h>
>> #include <sys/clock.h>
>> #include <sys/ctype.h>
>> #include <sys/kernel.h>
>> #include <sys/kthread.h>
>> #include <sys/reboot.h>
>> #include <sys/rman.h>
>> #include <sys/sysctl.h>
>> #include <sys/unistd.h>
>>
>> #include <machine/bus.h>
>> #include <machine/intr_machdep.h>
>> #include <machine/md_var.h>
>>
>> #include <dev/iicbus/iicbus.h>
>> #include <dev/iicbus/iiconf.h>
>> #include <dev/led/led.h>
>> #include <dev/ofw/openfirm.h>
>> #include <dev/ofw/ofw_bus.h>
>> #include <dev/ofw/ofw_bus_subr.h>
>> #include <powerpc/powermac/macgpiovar.h>
>> #include <powerpc/powermac/powermac_thermal.h>
>>
>> #include "clock_if.h"
>> #include "iicbus_if.h"
>>
>> struct smu_cmd {
>>     volatile uint8_t cmd;
>>     uint8_t        len;
>>     uint8_t        data[254];
>>
>>     STAILQ_ENTRY(smu_cmd) cmd_q;
>> };
>>
>> STAILQ_HEAD(smu_cmdq, smu_cmd);
>>
>> struct smu_fan {
>>     struct pmac_fan fan;
>>     device_t dev;
>>     cell_t    reg;
>>
>>     enum {
>>         SMU_FAN_RPM,
>>         SMU_FAN_PWM
>>     } type;
>>     int    setpoint;
>>     int    old_style;
>>     int     rpm;
>> };
>>
>> /* We can read the PWM and the RPM from a PWM controlled fan.
>>  * Offer both values via sysctl.
>>  */
>> enum {
>>     SMU_PWM_SYSCTL_PWM   = 1 << 8,
>>     SMU_PWM_SYSCTL_RPM   = 2 << 8
>> };
>>
>> struct smu_sensor {
>>     struct pmac_therm therm;
>>     device_t dev;
>>
>>     cell_t    reg;
>>     enum {
>>         SMU_CURRENT_SENSOR,
>>         SMU_VOLTAGE_SENSOR,
>>         SMU_POWER_SENSOR,
>>         SMU_TEMP_SENSOR
>>     } type;
>> };
>>
>> struct smu_softc {
>>     device_t    sc_dev;
>>     struct mtx    sc_mtx;
>>
>>     struct resource    *sc_memr;
>>     int        sc_memrid;
>>     int        sc_u3;
>>
>>     bus_dma_tag_t    sc_dmatag;
>>     bus_space_tag_t    sc_bt;
>>     bus_space_handle_t sc_mailbox;
>>
>>     struct smu_cmd    *sc_cmd, *sc_cur_cmd;
>>     bus_addr_t    sc_cmd_phys;
>>     bus_dmamap_t    sc_cmd_dmamap;
>>     struct smu_cmdq    sc_cmdq;
>>
>>     struct smu_fan    *sc_fans;
>>     int        sc_nfans;
>>     int        old_style_fans;
>>     struct smu_sensor *sc_sensors;
>>     int        sc_nsensors;
>>
>>     int        sc_doorbellirqid;
>>     struct resource    *sc_doorbellirq;
>>     void        *sc_doorbellirqcookie;
>>
>>     struct proc    *sc_fanmgt_proc;
>>     time_t        sc_lastuserchange;
>>
>>     /* Calibration data */
>>     uint16_t    sc_cpu_diode_scale;
>>     int16_t        sc_cpu_diode_offset;
>>
>>     uint16_t    sc_cpu_volt_scale;
>>     int16_t        sc_cpu_volt_offset;
>>     uint16_t    sc_cpu_curr_scale;
>>     int16_t        sc_cpu_curr_offset;
>>
>>     uint16_t    sc_slots_pow_scale;
>>     int16_t        sc_slots_pow_offset;
>>
>>     struct cdev     *sc_leddev;
>> };
>>
>> /* regular bus attachment functions */
>>
>> static int    smu_probe(device_t);
>> static int    smu_attach(device_t);
>> static const struct ofw_bus_devinfo *
>>     smu_get_devinfo(device_t bus, device_t dev);
>>
>> /* cpufreq notification hooks */
>>
>> static void    smu_cpufreq_pre_change(device_t, const struct cf_level
>> *level);
>> static void    smu_cpufreq_post_change(device_t, const struct cf_level
>> *level);
>>
>> /* clock interface */
>> static int    smu_gettime(device_t dev, struct timespec *ts);
>> static int    smu_settime(device_t dev, struct timespec *ts);
>>
>> /* utility functions */
>> static int    smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait);
>> static int    smu_get_datablock(device_t dev, int8_t id, uint8_t *buf,
>>             size_t len);
>> static void    smu_attach_i2c(device_t dev, phandle_t i2croot);
>> static void    smu_attach_fans(device_t dev, phandle_t fanroot);
>> static void    smu_attach_sensors(device_t dev, phandle_t sensroot);
>> static void    smu_set_sleepled(void *xdev, int onoff);
>> static int    smu_server_mode(SYSCTL_HANDLER_ARGS);
>> static void    smu_doorbell_intr(void *xdev);
>> static void    smu_shutdown(void *xdev, int howto);
>>
>> /* where to find the doorbell GPIO */
>>
>> static device_t    smu_doorbell = NULL;
>>
>> static device_method_t  smu_methods[] = {
>>     /* Device interface */
>>     DEVMETHOD(device_probe,        smu_probe),
>>     DEVMETHOD(device_attach,    smu_attach),
>>
>>     /* Clock interface */
>>     DEVMETHOD(clock_gettime,    smu_gettime),
>>     DEVMETHOD(clock_settime,    smu_settime),
>>
>>     /* ofw_bus interface */
>>     DEVMETHOD(bus_child_pnpinfo_str,ofw_bus_gen_child_pnpinfo_str),
>>     DEVMETHOD(ofw_bus_get_devinfo,    smu_get_devinfo),
>>     DEVMETHOD(ofw_bus_get_compat,    ofw_bus_gen_get_compat),
>>     DEVMETHOD(ofw_bus_get_model,    ofw_bus_gen_get_model),
>>     DEVMETHOD(ofw_bus_get_name,    ofw_bus_gen_get_name),
>>     DEVMETHOD(ofw_bus_get_node,    ofw_bus_gen_get_node),
>>     DEVMETHOD(ofw_bus_get_type,    ofw_bus_gen_get_type),
>>
>>     { 0, 0 },
>> };
>>
>> static driver_t smu_driver = {
>>     "smu",
>>     smu_methods,
>>     sizeof(struct smu_softc)
>> };
>>
>> static devclass_t smu_devclass;
>>
>> DRIVER_MODULE(smu, ofwbus, smu_driver, smu_devclass, 0, 0);
>> static MALLOC_DEFINE(M_SMU, "smu", "SMU Sensor Information");
>>
>> #define SMU_MAILBOX        0x8000860c
>> #define SMU_FANMGT_INTERVAL    1000 /* ms */
>>
>> /* Command types */
>> #define SMU_ADC            0xd8
>> #define SMU_FAN            0x4a
>> #define SMU_RPM_STATUS        0x01
>> #define SMU_RPM_SETPOINT    0x02
>> #define SMU_PWM_STATUS        0x11
>> #define SMU_PWM_SETPOINT    0x12
>> #define SMU_I2C            0x9a
>> #define  SMU_I2C_SIMPLE        0x00
>> #define  SMU_I2C_NORMAL        0x01
>> #define  SMU_I2C_COMBINED    0x02
>> #define SMU_MISC        0xee
>> #define  SMU_MISC_GET_DATA    0x02
>> #define  SMU_MISC_LED_CTRL    0x04
>> #define SMU_POWER        0xaa
>> #define SMU_POWER_EVENTS    0x8f
>> #define  SMU_PWR_GET_POWERUP    0x00
>> #define  SMU_PWR_SET_POWERUP    0x01
>> #define  SMU_PWR_CLR_POWERUP    0x02
>> #define SMU_RTC            0x8e
>> #define  SMU_RTC_GET        0x81
>> #define  SMU_RTC_SET        0x80
>>
>> /* Power event types */
>> #define SMU_WAKEUP_KEYPRESS    0x01
>> #define SMU_WAKEUP_AC_INSERT    0x02
>> #define SMU_WAKEUP_AC_CHANGE    0x04
>> #define SMU_WAKEUP_RING        0x10
>>
>> /* Data blocks */
>> #define SMU_CPUTEMP_CAL        0x18
>> #define SMU_CPUVOLT_CAL        0x21
>> #define SMU_SLOTPW_CAL        0x78
>>
>> /* Partitions */
>> #define SMU_PARTITION        0x3e
>> #define SMU_PARTITION_LATEST    0x01
>> #define SMU_PARTITION_BASE    0x02
>> #define SMU_PARTITION_UPDATE    0x03
>>
>> static int
>> smu_probe(device_t dev)
>> {
>>     const char *name = ofw_bus_get_name(dev);
>>
>>     if (strcmp(name, "smu") != 0)
>>         return (ENXIO);
>>
>>     device_set_desc(dev, "Apple System Management Unit");
>>     return (0);
>> }
>>
>> static void
>> smu_phys_callback(void *xsc, bus_dma_segment_t *segs, int nsegs, int error)
>> {
>>     struct smu_softc *sc = xsc;
>>
>>     sc->sc_cmd_phys = segs[0].ds_addr;
>> }
>>
>> static int
>> smu_attach(device_t dev)
>> {
>>     struct smu_softc *sc;
>>     phandle_t    node, child;
>>     uint8_t        data[12];
>>
>>     sc = device_get_softc(dev);
>>
>>     mtx_init(&sc->sc_mtx, "smu", NULL, MTX_DEF);
>>     sc->sc_cur_cmd = NULL;
>>     sc->sc_doorbellirqid = -1;
>>
>>     sc->sc_u3 = 0;
>>     if (OF_finddevice("/u3") != -1)
>>         sc->sc_u3 = 1;
>>
>>     /*
>>      * Map the mailbox area. This should be determined from firmware,
>>      * but I have not found a simple way to do that.
>>      */
>>     bus_dma_tag_create(NULL, 16, 0, BUS_SPACE_MAXADDR_32BIT,
>>         BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE, 0, NULL,
>>         NULL, &(sc->sc_dmatag));
>>     sc->sc_bt = &bs_le_tag;
>>     bus_space_map(sc->sc_bt, SMU_MAILBOX, 4, 0, &sc->sc_mailbox);
>>
>>     /*
>>      * Allocate the command buffer. This can be anywhere in the low 4 GB
>>      * of memory.
>>      */
>>     bus_dmamem_alloc(sc->sc_dmatag, (void **)&sc->sc_cmd, BUS_DMA_WAITOK
>> |
>>         BUS_DMA_ZERO, &sc->sc_cmd_dmamap);
>>     bus_dmamap_load(sc->sc_dmatag, sc->sc_cmd_dmamap,
>>         sc->sc_cmd, PAGE_SIZE, smu_phys_callback, sc, 0);
>>     STAILQ_INIT(&sc->sc_cmdq);
>>
>>     /*
>>      * Set up handlers to change CPU voltage when CPU frequency is changed.
>>      */
>>     EVENTHANDLER_REGISTER(cpufreq_pre_change, smu_cpufreq_pre_change, dev,
>>         EVENTHANDLER_PRI_ANY);
>>     EVENTHANDLER_REGISTER(cpufreq_post_change, smu_cpufreq_post_change,
>> dev,
>>         EVENTHANDLER_PRI_ANY);
>>
>>     node = ofw_bus_get_node(dev);
>>
>>     /* Some SMUs have RPM and PWM controlled fans which do not sit
>>      * under the same node. So we have to attach them separately.
>>      */
>>     smu_attach_fans(dev, node);
>>
>>     /*
>>      * Now detect and attach the other child devices.
>>      */
>>     for (child = OF_child(node); child != 0; child = OF_peer(child)) {
>>         char name[32];
>>         memset(name, 0, sizeof(name));
>>         OF_getprop(child, "name", name, sizeof(name));
>>
>>         if (strncmp(name, "sensors", 8) == 0)
>>             smu_attach_sensors(dev, child);
>>
>>         if (strncmp(name, "smu-i2c-control", 15) == 0)
>>             smu_attach_i2c(dev, child);
>>     }
>>
>>     /* Some SMUs have the I2C children directly under the bus. */
>>     smu_attach_i2c(dev, node);
>>
>>     /*
>>      * Collect calibration constants.
>>      */
>>     smu_get_datablock(dev, SMU_CPUTEMP_CAL, data, sizeof(data));
>>     sc->sc_cpu_diode_scale = (data[4] << 8) + data[5];
>>     sc->sc_cpu_diode_offset = (data[6] << 8) + data[7];
>>
>>     smu_get_datablock(dev, SMU_CPUVOLT_CAL, data, sizeof(data));
>>     sc->sc_cpu_volt_scale = (data[4] << 8) + data[5];
>>     sc->sc_cpu_volt_offset = (data[6] << 8) + data[7];
>>     sc->sc_cpu_curr_scale = (data[8] << 8) + data[9];
>>     sc->sc_cpu_curr_offset = (data[10] << 8) + data[11];
>>
>>     smu_get_datablock(dev, SMU_SLOTPW_CAL, data, sizeof(data));
>>     sc->sc_slots_pow_scale = (data[4] << 8) + data[5];
>>     sc->sc_slots_pow_offset = (data[6] << 8) + data[7];
>>
>>     /*
>>      * Set up LED interface
>>      */
>>     sc->sc_leddev = led_create(smu_set_sleepled, dev, "sleepled");
>>
>>     /*
>>      * Reset on power loss behavior
>>      */
>>
>>     SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
>>             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
>>         "server_mode", CTLTYPE_INT | CTLFLAG_RW, dev, 0,
>>         smu_server_mode, "I", "Enable reboot after power failure");
>>
>>     /*
>>      * Set up doorbell interrupt.
>>      */
>>     sc->sc_doorbellirqid = 0;
>>     sc->sc_doorbellirq = bus_alloc_resource_any(smu_doorbell, SYS_RES_IRQ,
>>         &sc->sc_doorbellirqid, RF_ACTIVE);
>>     bus_setup_intr(smu_doorbell, sc->sc_doorbellirq,
>>         INTR_TYPE_MISC | INTR_MPSAFE, NULL, smu_doorbell_intr, dev,
>>         &sc->sc_doorbellirqcookie);
>>     powerpc_config_intr(rman_get_start(sc->sc_doorbellirq),
>>         INTR_TRIGGER_EDGE, INTR_POLARITY_LOW);
>>
>>     /*
>>      * Connect RTC interface.
>>      */
>>     clock_register(dev, 1000);
>>
>>     /*
>>      * Learn about shutdown events
>>      */
>>     EVENTHANDLER_REGISTER(shutdown_final, smu_shutdown, dev,
>>         SHUTDOWN_PRI_LAST);
>>
>>     return (bus_generic_attach(dev));
>> }
>>
>> static const struct ofw_bus_devinfo *
>> smu_get_devinfo(device_t bus, device_t dev)
>> {
>>
>>     return (device_get_ivars(dev));
>> }
>>
>> static void
>> smu_send_cmd(device_t dev, struct smu_cmd *cmd)
>> {
>>     struct smu_softc *sc;
>>
>>     sc = device_get_softc(dev);
>>
>>     mtx_assert(&sc->sc_mtx, MA_OWNED);
>>
>>     if (sc->sc_u3)
>>         powerpc_pow_enabled = 0; /* SMU cannot work if we go to NAP */
>>
>>     sc->sc_cur_cmd = cmd;
>>
>>     /* Copy the command to the mailbox */
>>     sc->sc_cmd->cmd = cmd->cmd;
>>     sc->sc_cmd->len = cmd->len;
>>     memcpy(sc->sc_cmd->data, cmd->data, sizeof(cmd->data));
>>     bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap,
>> BUS_DMASYNC_PREWRITE);
>>     bus_space_write_4(sc->sc_bt, sc->sc_mailbox, 0, sc->sc_cmd_phys);
>>
>>     /* Flush the cacheline it is in -- SMU bypasses the cache */
>>     __asm __volatile("sync; dcbf 0,%0; sync" :: "r"(sc->sc_cmd): "memory");
>>
>>     /* Ring SMU doorbell */
>>     macgpio_write(smu_doorbell, GPIO_DDR_OUTPUT);
>> }
>>
>> static void
>> smu_doorbell_intr(void *xdev)
>> {
>>     device_t smu;
>>     struct smu_softc *sc;
>>     int doorbell_ack;
>>
>>     smu = xdev;
>>     doorbell_ack = macgpio_read(smu_doorbell);
>>     sc = device_get_softc(smu);
>>
>>     if (doorbell_ack != (GPIO_DDR_OUTPUT | GPIO_LEVEL_RO | GPIO_DATA))
>>         return;
>>
>>     mtx_lock(&sc->sc_mtx);
>>
>>     if (sc->sc_cur_cmd == NULL)    /* spurious */
>>         goto done;
>>
>>     /* Check result. First invalidate the cache again... */
>>     __asm __volatile("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory");
>>
>>     bus_dmamap_sync(sc->sc_dmatag, sc->sc_cmd_dmamap,
>> BUS_DMASYNC_POSTREAD);
>>
>>     sc->sc_cur_cmd->cmd = sc->sc_cmd->cmd;
>>     sc->sc_cur_cmd->len = sc->sc_cmd->len;
>>     memcpy(sc->sc_cur_cmd->data, sc->sc_cmd->data,
>>         sizeof(sc->sc_cmd->data));
>>     wakeup(sc->sc_cur_cmd);
>>     sc->sc_cur_cmd = NULL;
>>     if (sc->sc_u3)
>>         powerpc_pow_enabled = 1;
>>
>>     done:
>>     /* Queue next command if one is pending */
>>     if (STAILQ_FIRST(&sc->sc_cmdq) != NULL) {
>>         sc->sc_cur_cmd = STAILQ_FIRST(&sc->sc_cmdq);
>>         STAILQ_REMOVE_HEAD(&sc->sc_cmdq, cmd_q);
>>         smu_send_cmd(smu, sc->sc_cur_cmd);
>>     }
>>
>>     mtx_unlock(&sc->sc_mtx);
>> }
>>
>> static int
>> smu_run_cmd(device_t dev, struct smu_cmd *cmd, int wait)
>> {
>>     struct smu_softc *sc;
>>     uint8_t cmd_code;
>>     int error;
>>
>>     sc = device_get_softc(dev);
>>     cmd_code = cmd->cmd;
>>
>>     mtx_lock(&sc->sc_mtx);
>>     if (sc->sc_cur_cmd != NULL) {
>>         STAILQ_INSERT_TAIL(&sc->sc_cmdq, cmd, cmd_q);
>>     } else
>>         smu_send_cmd(dev, cmd);
>>     mtx_unlock(&sc->sc_mtx);
>>
>>     if (!wait)
>>         return (0);
>>
>>     if (sc->sc_doorbellirqid < 0) {
>>         /* Poll if the IRQ has not been set up yet */
>>         do {
>>             DELAY(50);
>>             smu_doorbell_intr(dev);
>>         } while (sc->sc_cur_cmd != NULL);
>>     } else {
>>         /* smu_doorbell_intr will wake us when the command is ACK'ed */
>>         error = tsleep(cmd, 0, "smu", 800 * hz / 1000);
>>         if (error != 0)
>>             smu_doorbell_intr(dev);    /* One last chance */
>>
>>         if (error != 0) {
>>             mtx_lock(&sc->sc_mtx);
>>             if (cmd->cmd == cmd_code) {    /* Never processed */
>>             /* Abort this command if we timed out */
>>             if (sc->sc_cur_cmd == cmd)
>>                 sc->sc_cur_cmd = NULL;
>>             else
>>                 STAILQ_REMOVE(&sc->sc_cmdq, cmd, smu_cmd,
>>                     cmd_q);
>>             mtx_unlock(&sc->sc_mtx);
>>             return (error);
>>             }
>>             error = 0;
>>             mtx_unlock(&sc->sc_mtx);
>>         }
>>     }
>>
>>     /* SMU acks the command by inverting the command bits */
>>     if (cmd->cmd == ((~cmd_code) & 0xff))
>>         error = 0;
>>     else
>>         error = EIO;
>>
>>     return (error);
>> }
>>
>> static int
>> smu_get_datablock(device_t dev, int8_t id, uint8_t *buf, size_t len)
>> {
>>     struct smu_cmd cmd;
>>     uint8_t addr[4];
>>
>>     cmd.cmd = SMU_PARTITION;
>>     cmd.len = 2;
>>     cmd.data[0] = SMU_PARTITION_LATEST;
>>     cmd.data[1] = id;
>>
>>     smu_run_cmd(dev, &cmd, 1);
>>
>>     addr[0] = addr[1] = 0;
>>     addr[2] = cmd.data[0];
>>     addr[3] = cmd.data[1];
>>
>>     cmd.cmd = SMU_MISC;
>>     cmd.len = 7;
>>     cmd.data[0] = SMU_MISC_GET_DATA;
>>     cmd.data[1] = sizeof(addr);
>>     memcpy(&cmd.data[2], addr, sizeof(addr));
>>     cmd.data[6] = len;
>>
>>     smu_run_cmd(dev, &cmd, 1);
>>     memcpy(buf, cmd.data, len);
>>     return (0);
>> }
>>
>> static void
>> smu_slew_cpu_voltage(device_t dev, int to)
>> {
>>     struct smu_cmd cmd;
>>
>>     cmd.cmd = SMU_POWER;
>>     cmd.len = 8;
>>     cmd.data[0] = 'V';
>>     cmd.data[1] = 'S';
>>     cmd.data[2] = 'L';
>>     cmd.data[3] = 'E';
>>     cmd.data[4] = 'W';
>>     cmd.data[5] = 0xff;
>>     cmd.data[6] = 1;
>>     cmd.data[7] = to;
>>
>>     smu_run_cmd(dev, &cmd, 1);
>> }
>>
>> static void
>> smu_cpufreq_pre_change(device_t dev, const struct cf_level *level)
>> {
>>     /*
>>      * Make sure the CPU voltage is raised before we raise
>>      * the clock.
>>      */
>>
>>     if (level->rel_set[0].freq == 10000 /* max */)
>>         smu_slew_cpu_voltage(dev, 0);
>> }
>>
>> static void
>> smu_cpufreq_post_change(device_t dev, const struct cf_level *level)
>> {
>>     /* We are safe to reduce CPU voltage after a downward transition */
>>
>>     if (level->rel_set[0].freq < 10000 /* max */)
>>         smu_slew_cpu_voltage(dev, 1); /* XXX: 1/4 voltage for 970MP? */
>> }
>>
>> /* Routines for probing the SMU doorbell GPIO */
>> static int doorbell_probe(device_t dev);
>> static int doorbell_attach(device_t dev);
>>
>> static device_method_t  doorbell_methods[] = {
>>     /* Device interface */
>>     DEVMETHOD(device_probe,        doorbell_probe),
>>     DEVMETHOD(device_attach,    doorbell_attach),
>>     { 0, 0 },
>> };
>>
>> static driver_t doorbell_driver = {
>>     "smudoorbell",
>>     doorbell_methods,
>>     0
>> };
>>
>> static devclass_t doorbell_devclass;
>>
>> DRIVER_MODULE(smudoorbell, macgpio, doorbell_driver, doorbell_devclass, 0,
>> 0);
>>
>> static int
>> doorbell_probe(device_t dev)
>> {
>>     const char *name = ofw_bus_get_name(dev);
>>
>>     if (strcmp(name, "smu-doorbell") != 0)
>>         return (ENXIO);
>>
>>     device_set_desc(dev, "SMU Doorbell GPIO");
>>     device_quiet(dev);
>>     return (0);
>> }
>>
>> static int
>> doorbell_attach(device_t dev)
>> {
>>     smu_doorbell = dev;
>>     return (0);
>> }
>>
>> /*
>>  * Sensor and fan management
>>  */
>>
>> static int
>> smu_fan_check_old_style(struct smu_fan *fan)
>> {
>>     device_t smu = fan->dev;
>>     struct smu_softc *sc = device_get_softc(smu);
>>     struct smu_cmd cmd;
>>     int error;
>>
>>     if (sc->old_style_fans != -1)
>>         return (sc->old_style_fans);
>>
>>     /*
>>      * Apple has two fan control mechanisms. We can't distinguish
>>      * them except by seeing if the new one fails. If the new one
>>      * fails, use the old one.
>>      */
>>
>>     cmd.cmd = SMU_FAN;
>>     cmd.len = 2;
>>     cmd.data[0] = 0x31;
>>     cmd.data[1] = fan->reg;
>>
>>     do {
>>         error = smu_run_cmd(smu, &cmd, 1);
>>     } while (error == EWOULDBLOCK);
>>
>>     sc->old_style_fans = (error != 0);
>>
>>     return (sc->old_style_fans);
>> }
>>
>> static int
>> smu_fan_set_rpm(struct smu_fan *fan, int rpm)
>> {
>>     device_t smu = fan->dev;
>>     struct smu_cmd cmd;
>>     int error;
>>
>>     cmd.cmd = SMU_FAN;
>>     error = EIO;
>>
>>     /* Clamp to allowed range */
>>     rpm = max(fan->fan.min_rpm, rpm);
>>     rpm = min(fan->fan.max_rpm, rpm);
>>
>>     smu_fan_check_old_style(fan);
>>
>>     if (!fan->old_style) {
>>         cmd.len = 4;
>>         cmd.data[0] = 0x30;
>>         cmd.data[1] = fan->reg;
>>         cmd.data[2] = (rpm >> 8) & 0xff;
>>         cmd.data[3] = rpm & 0xff;
>>
>>         error = smu_run_cmd(smu, &cmd, 1);
>>         if (error && error != EWOULDBLOCK)
>>             fan->old_style = 1;
>>     } else {
>>         cmd.len = 14;
>>         cmd.data[0] = 0x00; /* RPM fan. */
>>         cmd.data[1] = 1 << fan->reg;
>>         cmd.data[2 + 2*fan->reg] = (rpm >> 8) & 0xff;
>>         cmd.data[3 + 2*fan->reg] = rpm & 0xff;
>>         error = smu_run_cmd(smu, &cmd, 1);
>>     }
>>
>>     if (error == 0)
>>         fan->setpoint = rpm;
>>
>>     return (error);
>> }
>>
>> static int
>> smu_fan_read_rpm(struct smu_fan *fan)
>> {
>>     device_t smu = fan->dev;
>>     struct smu_cmd cmd;
>>     int rpm, error;
>>
>>     smu_fan_check_old_style(fan);
>>
>>     if (!fan->old_style) {
>>         cmd.cmd = SMU_FAN;
>>         cmd.len = 2;
>>         cmd.data[0] = 0x31;
>>         cmd.data[1] = fan->reg;
>>
>>         error = smu_run_cmd(smu, &cmd, 1);
>>         if (error && error != EWOULDBLOCK)
>>             fan->old_style = 1;
>>
>>         rpm = (cmd.data[0] << 8) | cmd.data[1];
>>     }
>>
>>     if (fan->old_style) {
>>         cmd.cmd = SMU_FAN;
>>         cmd.len = 1;
>>         cmd.data[0] = SMU_RPM_STATUS;
>>
>>         error = smu_run_cmd(smu, &cmd, 1);
>>         if (error)
>>             return (error);
>>
>>         rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2];
>>     }
>>
>>     return (rpm);
>> }
>> static int
>> smu_fan_set_pwm(struct smu_fan *fan, int pwm)
>> {
>>     device_t smu = fan->dev;
>>     struct smu_cmd cmd;
>>     int error;
>>
>>     cmd.cmd = SMU_FAN;
>>     error = EIO;
>>
>>     /* Clamp to allowed range */
>>     pwm = max(fan->fan.min_rpm, pwm);
>>     pwm = min(fan->fan.max_rpm, pwm);
>>
>>     /*
>>      * Apple has two fan control mechanisms. We can't distinguish
>>      * them except by seeing if the new one fails. If the new one
>>      * fails, use the old one.
>>      */
>>
>>     if (!fan->old_style) {
>>         cmd.len = 4;
>>         cmd.data[0] = 0x30;
>>         cmd.data[1] = fan->reg;
>>         cmd.data[2] = (pwm >> 8) & 0xff;
>>         cmd.data[3] = pwm & 0xff;
>>
>>         error = smu_run_cmd(smu, &cmd, 1);
>>         if (error && error != EWOULDBLOCK)
>>             fan->old_style = 1;
>>     }
>>
>>     if (fan->old_style) {
>>         cmd.len = 14;
>>         cmd.data[0] = 0x10; /* PWM fan. */
>>         cmd.data[1] = 1 << fan->reg;
>>         cmd.data[2 + 2*fan->reg] = (pwm >> 8) & 0xff;
>>         cmd.data[3 + 2*fan->reg] = pwm & 0xff;
>>         error = smu_run_cmd(smu, &cmd, 1);
>>     }
>>
>>     if (error == 0)
>>         fan->setpoint = pwm;
>>
>>     return (error);
>> }
>>
>> static int
>> smu_fan_read_pwm(struct smu_fan *fan, int *pwm, int *rpm)
>> {
>>     device_t smu = fan->dev;
>>     struct smu_cmd cmd;
>>     int error;
>>
>>     if (!fan->old_style) {
>>         cmd.cmd = SMU_FAN;
>>         cmd.len = 2;
>>         cmd.data[0] = 0x31;
>>         cmd.data[1] = fan->reg;
>>
>>         error = smu_run_cmd(smu, &cmd, 1);
>>         if (error && error != EWOULDBLOCK)
>>             fan->old_style = 1;
>>
>>         *rpm = (cmd.data[0] << 8) | cmd.data[1];
>>     }
>>
>>     if (fan->old_style) {
>>         cmd.cmd = SMU_FAN;
>>         cmd.len = 1;
>>         cmd.data[0] = SMU_PWM_STATUS;
>>
>>         error = smu_run_cmd(smu, &cmd, 1);
>>         if (error)
>>             return (error);
>>
>>         *rpm = (cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2];
>>     }
>>     if (fan->old_style) {
>>         cmd.cmd = SMU_FAN;
>>         cmd.len = 14;
>>         cmd.data[0] = SMU_PWM_SETPOINT;
>>         cmd.data[1] = 1 << fan->reg;
>>
>>         error = smu_run_cmd(smu, &cmd, 1);
>>         if (error)
>>             return (error);
>>
>>         *pwm = cmd.data[fan->reg*2+2];
>>     }
>>     return (0);
>> }
>>
>> static int
>> smu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS)
>> {
>>     device_t smu;
>>     struct smu_softc *sc;
>>     struct smu_fan *fan;
>>     int pwm = 0, rpm, error = 0;
>>
>>     smu = arg1;
>>     sc = device_get_softc(smu);
>>     fan = &sc->sc_fans[arg2 & 0xff];
>>
>>     if (fan->type == SMU_FAN_RPM) {
>>         rpm = smu_fan_read_rpm(fan);
>>         if (rpm < 0)
>>             return (rpm);
>>
>>         error = sysctl_handle_int(oidp, &rpm, 0, req);
>>     } else {
>>         error = smu_fan_read_pwm(fan, &pwm, &rpm);
>>         if (error < 0)
>>             return (EIO);
>>
>>         switch (arg2 & 0xff00) {
>>         case SMU_PWM_SYSCTL_PWM:
>>             error = sysctl_handle_int(oidp, &pwm, 0, req);
>>             break;
>>         case SMU_PWM_SYSCTL_RPM:
>>             error = sysctl_handle_int(oidp, &rpm, 0, req);
>>             break;
>>         default:
>>             /* This should never happen */
>>             return (EINVAL);
>>         };
>>     }
>>     /* We can only read the RPM from a PWM controlled fan, so return. */
>>     if ((arg2 & 0xff00) == SMU_PWM_SYSCTL_RPM)
>>         return (0);
>>
>>     if (error || !req->newptr)
>>         return (error);
>>
>>     sc->sc_lastuserchange = time_uptime;
>>
>>     if (fan->type == SMU_FAN_RPM)
>>         return (smu_fan_set_rpm(fan, rpm));
>>     else
>>         return (smu_fan_set_pwm(fan, pwm));
>> }
>>
>> static void
>> smu_fill_fan_prop(device_t dev, phandle_t child, int id)
>> {
>>     struct smu_fan *fan;
>>     struct smu_softc *sc;
>>     char type[32];
>>
>>     sc = device_get_softc(dev);
>>     fan = &sc->sc_fans[id];
>>
>>     OF_getprop(child, "device_type", type, sizeof(type));
>>     /* We have either RPM or PWM controlled fans. */
>>     if (strcmp(type, "fan-rpm-control") == 0)
>>         fan->type = SMU_FAN_RPM;
>>     else
>>         fan->type = SMU_FAN_PWM;
>>
>>     fan->dev = dev;
>>     fan->old_style = 0;
>>     OF_getprop(child, "reg", &fan->reg,
>>            sizeof(cell_t));
>>     OF_getprop(child, "min-value", &fan->fan.min_rpm,
>>            sizeof(int));
>>     OF_getprop(child, "max-value", &fan->fan.max_rpm,
>>            sizeof(int));
>>     OF_getprop(child, "zone", &fan->fan.zone,
>>            sizeof(int));
>>
>>     if (OF_getprop(child, "unmanaged-value",
>>                &fan->fan.default_rpm,
>>                sizeof(int)) != sizeof(int))
>>         fan->fan.default_rpm = fan->fan.max_rpm;
>>
>>     OF_getprop(child, "location", fan->fan.name,
>>            sizeof(fan->fan.name));
>>
>>     if (fan->type == SMU_FAN_RPM)
>>         fan->setpoint = smu_fan_read_rpm(fan);
>>     else
>>         smu_fan_read_pwm(fan, &fan->setpoint, &fan->rpm);
>> }
>>
>> /* On the first call count the number of fans. In the second call,
>>  * after allocating the fan struct, fill the properties of the fans.
>>  */
>> static int
>> smu_count_fans(device_t dev)
>> {
>>     struct smu_softc *sc;
>>     phandle_t child, node, root;
>>     int nfans = 0;
>>
>>     node = ofw_bus_get_node(dev);
>>     sc = device_get_softc(dev);
>>
>>     /* First find the fanroots and count the number of fans. */
>>     for (root = OF_child(node); root != 0; root = OF_peer(root)) {
>>         char name[32];
>>         memset(name, 0, sizeof(name));
>>         OF_getprop(root, "name", name, sizeof(name));
>>         if (strncmp(name, "rpm-fans", 9) == 0 ||
>>             strncmp(name, "pwm-fans", 9) == 0 ||
>>             strncmp(name, "fans", 5) == 0)
>>             for (child = OF_child(root); child != 0;
>>                  child = OF_peer(child)) {
>>                 nfans++;
>>                 /* When allocated, fill the fan properties. */
>>                 if (sc->sc_fans != NULL) {
>>                     smu_fill_fan_prop(dev, child,
>>                               nfans - 1);
>>                 }
>>             }
>>     }
>>     if (nfans == 0) {
>>         device_printf(dev, "WARNING: No fans detected!\n");
>>         return (0);
>>     }
>>     return (nfans);
>> }
>>
>> static void
>> smu_attach_fans(device_t dev, phandle_t fanroot)
>> {
>>     struct smu_fan *fan;
>>     struct smu_softc *sc;
>>     struct sysctl_oid *oid, *fanroot_oid;
>>     struct sysctl_ctx_list *ctx;
>>     char sysctl_name[32];
>>     int i, j;
>>
>>     sc = device_get_softc(dev);
>>
>>     /* Get the number of fans. */
>>     sc->sc_nfans = smu_count_fans(dev);
>>     if (sc->sc_nfans == 0)
>>         return;
>>
>>     /* Now we're able to allocate memory for the fans struct. */
>>     sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct smu_fan), M_SMU,
>>         M_WAITOK | M_ZERO);
>>
>>     /* Now fill in the properties. */
>>     smu_count_fans(dev);
>>
>>     /* Register fans with pmac_thermal */
>>     for (i = 0; i < sc->sc_nfans; i++)
>>         pmac_thermal_fan_register(&sc->sc_fans[i].fan);
>>
>>     ctx = device_get_sysctl_ctx(dev);
>>     fanroot_oid = SYSCTL_ADD_NODE(ctx,
>>         SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans",
>>         CTLFLAG_RD, 0, "SMU Fan Information");
>>
>>     /* Add sysctls */
>>     for (i = 0; i < sc->sc_nfans; i++) {
>>         fan = &sc->sc_fans[i];
>>         for (j = 0; j < strlen(fan->fan.name); j++) {
>>             sysctl_name[j] = tolower(fan->fan.name[j]);
>>             if (isspace(sysctl_name[j]))
>>                 sysctl_name[j] = '_';
>>         }
>>         sysctl_name[j] = 0;
>>         if (fan->type == SMU_FAN_RPM) {
>>             oid = SYSCTL_ADD_NODE(ctx,
>>                           SYSCTL_CHILDREN(fanroot_oid),
>>                           OID_AUTO, sysctl_name,
>>                           CTLFLAG_RD, 0, "Fan Information");
>>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>>                        "minrpm", CTLFLAG_RD,
>>                        &fan->fan.min_rpm, 0,
>>                        "Minimum allowed RPM");
>>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>>                        "maxrpm", CTLFLAG_RD,
>>                        &fan->fan.max_rpm, 0,
>>                        "Maximum allowed RPM");
>>             SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>>                     "rpm",CTLTYPE_INT | CTLFLAG_RW |
>>                     CTLFLAG_MPSAFE, dev, i,
>>                     smu_fanrpm_sysctl, "I", "Fan RPM");
>>
>>             fan->fan.read = (int (*)(struct pmac_fan *))smu_fan_read_rpm;
>>             fan->fan.set = (int (*)(struct pmac_fan *,
>> int))smu_fan_set_rpm;
>>
>>         } else {
>>             oid = SYSCTL_ADD_NODE(ctx,
>>                           SYSCTL_CHILDREN(fanroot_oid),
>>                           OID_AUTO, sysctl_name,
>>                           CTLFLAG_RD, 0, "Fan Information");
>>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>>                        "minpwm", CTLFLAG_RD,
>>                        &fan->fan.min_rpm, 0,
>>                        "Minimum allowed PWM in %");
>>             SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>>                        "maxpwm", CTLFLAG_RD,
>>                        &fan->fan.max_rpm, 0,
>>                        "Maximum allowed PWM in %");
>>             SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>>                     "pwm",CTLTYPE_INT | CTLFLAG_RW |
>>                     CTLFLAG_MPSAFE, dev,
>>                     SMU_PWM_SYSCTL_PWM | i,
>>                     smu_fanrpm_sysctl, "I", "Fan PWM in %");
>>             SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
>>                     "rpm",CTLTYPE_INT | CTLFLAG_RD |
>>                     CTLFLAG_MPSAFE, dev,
>>                     SMU_PWM_SYSCTL_RPM | i,
>>                     smu_fanrpm_sysctl, "I", "Fan RPM");
>>             fan->fan.read = NULL;
>>             fan->fan.set = (int (*)(struct pmac_fan *,
>> int))smu_fan_set_pwm;
>>
>>         }
>>         if (bootverbose)
>>             device_printf(dev, "Fan: %s type: %d\n",
>>                       fan->fan.name, fan->type);
>>     }
>> }
>>
>> static int
>> smu_sensor_read(struct smu_sensor *sens)
>> {
>>     device_t smu = sens->dev;
>>     struct smu_cmd cmd;
>>     struct smu_softc *sc;
>>     int64_t value;
>>     int error;
>>
>>     cmd.cmd = SMU_ADC;
>>     cmd.len = 1;
>>     cmd.data[0] = sens->reg;
>>     error = 0;
>>
>>     error = smu_run_cmd(smu, &cmd, 1);
>>     if (error != 0)
>>         return (-1);
>>
>>     sc = device_get_softc(smu);
>>     value = (cmd.data[0] << 8) | cmd.data[1];
>>
>>     switch (sens->type) {
>>     case SMU_TEMP_SENSOR:
>>         value *= sc->sc_cpu_diode_scale;
>>         value >>= 3;
>>         value += ((int64_t)sc->sc_cpu_diode_offset) << 9;
>>         value <<= 1;
>>
>>         /* Convert from 16.16 fixed point degC into integer 0.1 K. */
>>         value = 10*(value >> 16) + ((10*(value & 0xffff)) >> 16) + 2732;
>>         break;
>>     case SMU_VOLTAGE_SENSOR:
>>         value *= sc->sc_cpu_volt_scale;
>>         value += sc->sc_cpu_volt_offset;
>>         value <<= 4;
>>
>>         /* Convert from 16.16 fixed point V into mV. */
>>         value *= 15625;
>>         value /= 1024;
>>         value /= 1000;
>>         break;
>>     case SMU_CURRENT_SENSOR:
>>         value *= sc->sc_cpu_curr_scale;
>>         value += sc->sc_cpu_curr_offset;
>>         value <<= 4;
>>
>>         /* Convert from 16.16 fixed point A into mA. */
>>         value *= 15625;
>>         value /= 1024;
>>         value /= 1000;
>>         break;
>>     case SMU_POWER_SENSOR:
>>         value *= sc->sc_slots_pow_scale;
>>         value += sc->sc_slots_pow_offset;
>>         value <<= 4;
>>
>>         /* Convert from 16.16 fixed point W into mW. */
>>         value *= 15625;
>>         value /= 1024;
>>         value /= 1000;
>>         break;
>>     }
>>
>>     return (value);
>> }
>>
>> static int
>> smu_sensor_sysctl(SYSCTL_HANDLER_ARGS)
>> {
>>     device_t smu;
>>     struct smu_softc *sc;
>>     struct smu_sensor *sens;
>>     int value, error;
>>
>>     smu = arg1;
>>     sc = device_get_softc(smu);
>>     sens = &sc->sc_sensors[arg2];
>>
>>     value = smu_sensor_read(sens);
>>     if (value < 0)
>>         return (EBUSY);
>>
>>     error = sysctl_handle_int(oidp, &value, 0, req);
>>
>>     return (error);
>> }
>>
>> static void
>> smu_attach_sensors(device_t dev, phandle_t sensroot)
>> {
>>     struct smu_sensor *sens;
>>     struct smu_softc *sc;
>>     struct sysctl_oid *sensroot_oid;
>>     struct sysctl_ctx_list *ctx;
>>     phandle_t child;
>>     char type[32];
>>     int i;
>>
>>     sc = device_get_softc(dev);
>>     sc->sc_nsensors = 0;
>>
>>     for (child = OF_child(sensroot); child != 0; child = OF_peer(child))
>>         sc->sc_nsensors++;
>>
>>     if (sc->sc_nsensors == 0) {
>>         device_printf(dev, "WARNING: No sensors detected!\n");
>>         return;
>>     }
>>
>>     sc->sc_sensors = malloc(sc->sc_nsensors * sizeof(struct smu_sensor),
>>         M_SMU, M_WAITOK | M_ZERO);
>>
>>     sens = sc->sc_sensors;
>>     sc->sc_nsensors = 0;
>>
>>     ctx = device_get_sysctl_ctx(dev);
>>     sensroot_oid = SYSCTL_ADD_NODE(ctx,
>>         SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "sensors",
>>         CTLFLAG_RD, 0, "SMU Sensor Information");
>>
>>     for (child = OF_child(sensroot); child != 0; child = OF_peer(child)) {
>>         char sysctl_name[40], sysctl_desc[40];
>>         const char *units;
>>
>>         sens->dev = dev;
>>         OF_getprop(child, "device_type", type, sizeof(type));
>>
>>         if (strcmp(type, "current-sensor") == 0) {
>>             sens->type = SMU_CURRENT_SENSOR;
>>             units = "mA";
>>         } else if (strcmp(type, "temp-sensor") == 0) {
>>             sens->type = SMU_TEMP_SENSOR;
>>             units = "C";
>>         } else if (strcmp(type, "voltage-sensor") == 0) {
>>             sens->type = SMU_VOLTAGE_SENSOR;
>>             units = "mV";
>>         } else if (strcmp(type, "power-sensor") == 0) {
>>             sens->type = SMU_POWER_SENSOR;
>>             units = "mW";
>>         } else {
>>             continue;
>>         }
>>
>>         OF_getprop(child, "reg", &sens->reg, sizeof(cell_t));
>>         OF_getprop(child, "zone", &sens->therm.zone, sizeof(int));
>>         OF_getprop(child, "location", sens->therm.name,
>>             sizeof(sens->therm.name));
>>
>>         for (i = 0; i < strlen(sens->therm.name); i++) {
>>             sysctl_name[i] = tolower(sens->therm.name[i]);
>>             if (isspace(sysctl_name[i]))
>>                 sysctl_name[i] = '_';
>>         }
>>         sysctl_name[i] = 0;
>>
>>         sprintf(sysctl_desc,"%s (%s)", sens->therm.name, units);
>>
>>         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(sensroot_oid), OID_AUTO,
>>             sysctl_name, CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
>>             dev, sc->sc_nsensors, smu_sensor_sysctl,
>>             (sens->type == SMU_TEMP_SENSOR) ? "IK" : "I", sysctl_desc);
>>
>>         if (sens->type == SMU_TEMP_SENSOR) {
>>             /* Make up some numbers */
>>             sens->therm.target_temp = 500 + 2732; /* 50 C */
>>             sens->therm.max_temp = 900 + 2732; /* 90 C */
>>
>>             sens->therm.read =
>>                 (int (*)(struct pmac_therm *))smu_sensor_read;
>>             pmac_thermal_sensor_register(&sens->therm);
>>         }
>>
>>         sens++;
>>         sc->sc_nsensors++;
>>     }
>> }
>>
>> static void
>> smu_set_sleepled(void *xdev, int onoff)
>> {
>>     static struct smu_cmd cmd;
>>     device_t smu = xdev;
>>
>>     cmd.cmd = SMU_MISC;
>>     cmd.len = 3;
>>     cmd.data[0] = SMU_MISC_LED_CTRL;
>>     cmd.data[1] = 0;
>>     cmd.data[2] = onoff;
>>
>>     smu_run_cmd(smu, &cmd, 0);
>> }
>>
>> static int
>> smu_server_mode(SYSCTL_HANDLER_ARGS)
>> {
>>     struct smu_cmd cmd;
>>     u_int server_mode;
>>     device_t smu = arg1;
>>     int error;
>>
>>     cmd.cmd = SMU_POWER_EVENTS;
>>     cmd.len = 1;
>>     cmd.data[0] = SMU_PWR_GET_POWERUP;
>>
>>     error = smu_run_cmd(smu, &cmd, 1);
>>
>>     if (error)
>>         return (error);
>>
>>     server_mode = (cmd.data[1] & SMU_WAKEUP_AC_INSERT) ? 1 : 0;
>>
>>     error = sysctl_handle_int(oidp, &server_mode, 0, req);
>>
>>     if (error || !req->newptr)
>>         return (error);
>>
>>     if (server_mode == 1)
>>         cmd.data[0] = SMU_PWR_SET_POWERUP;
>>     else if (server_mode == 0)
>>         cmd.data[0] = SMU_PWR_CLR_POWERUP;
>>     else
>>         return (EINVAL);
>>
>>     cmd.len = 3;
>>     cmd.data[1] = 0;
>>     cmd.data[2] = SMU_WAKEUP_AC_INSERT;
>>
>>     return (smu_run_cmd(smu, &cmd, 1));
>> }
>>
>> static void
>> smu_shutdown(void *xdev, int howto)
>> {
>>     device_t smu = xdev;
>>     struct smu_cmd cmd;
>>
>>     cmd.cmd = SMU_POWER;
>>     if (howto & RB_HALT)
>>         strcpy(cmd.data, "SHUTDOWN");
>>     else
>>         strcpy(cmd.data, "RESTART");
>>
>>     cmd.len = strlen(cmd.data);
>>
>>     smu_run_cmd(smu, &cmd, 1);
>>
>>     for (;;);
>> }
>>
>> static int
>> smu_gettime(device_t dev, struct timespec *ts)
>> {
>>     struct smu_cmd cmd;
>>     struct clocktime ct;
>>
>>     cmd.cmd = SMU_RTC;
>>     cmd.len = 1;
>>     cmd.data[0] = SMU_RTC_GET;
>>
>>     if (smu_run_cmd(dev, &cmd, 1) != 0)
>>         return (ENXIO);
>>
>>     ct.nsec    = 0;
>>     ct.sec    = bcd2bin(cmd.data[0]);
>>     ct.min    = bcd2bin(cmd.data[1]);
>>     ct.hour    = bcd2bin(cmd.data[2]);
>>     ct.dow    = bcd2bin(cmd.data[3]);
>>     ct.day    = bcd2bin(cmd.data[4]);
>>     ct.mon    = bcd2bin(cmd.data[5]);
>>     ct.year    = bcd2bin(cmd.data[6]) + 2000;
>>
>>     return (clock_ct_to_ts(&ct, ts));
>> }
>>
>> static int
>> smu_settime(device_t dev, struct timespec *ts)
>> {
>>     static struct smu_cmd cmd;
>>     struct clocktime ct;
>>
>>     cmd.cmd = SMU_RTC;
>>     cmd.len = 8;
>>     cmd.data[0] = SMU_RTC_SET;
>>
>>     clock_ts_to_ct(ts, &ct);
>>
>>     cmd.data[1] = bin2bcd(ct.sec);
>>     cmd.data[2] = bin2bcd(ct.min);
>>     cmd.data[3] = bin2bcd(ct.hour);
>>     cmd.data[4] = bin2bcd(ct.dow);
>>     cmd.data[5] = bin2bcd(ct.day);
>>     cmd.data[6] = bin2bcd(ct.mon);
>>     cmd.data[7] = bin2bcd(ct.year - 2000);
>>
>>     return (smu_run_cmd(dev, &cmd, 0));
>> }
>>
>> /* SMU I2C Interface */
>>
>> static int smuiic_probe(device_t dev);
>> static int smuiic_attach(device_t dev);
>> static int smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t
>> nmsgs);
>> static phandle_t smuiic_get_node(device_t bus, device_t dev);
>>
>> static device_method_t smuiic_methods[] = {
>>     /* device interface */
>>     DEVMETHOD(device_probe,         smuiic_probe),
>>     DEVMETHOD(device_attach,        smuiic_attach),
>>
>>     /* iicbus interface */
>>     DEVMETHOD(iicbus_callback,      iicbus_null_callback),
>>     DEVMETHOD(iicbus_transfer,      smuiic_transfer),
>>
>>     /* ofw_bus interface */
>>     DEVMETHOD(ofw_bus_get_node,     smuiic_get_node),
>>
>>     { 0, 0 }
>> };
>>
>> struct smuiic_softc {
>>     struct mtx    sc_mtx;
>>     volatile int    sc_iic_inuse;
>>     int        sc_busno;
>> };
>>
>> static driver_t smuiic_driver = {
>>     "iichb",
>>     smuiic_methods,
>>     sizeof(struct smuiic_softc)
>> };
>> static devclass_t smuiic_devclass;
>>
>> DRIVER_MODULE(smuiic, smu, smuiic_driver, smuiic_devclass, 0, 0);
>>
>> static void
>> smu_attach_i2c(device_t smu, phandle_t i2croot)
>> {
>>     phandle_t child;
>>     device_t cdev;
>>     struct ofw_bus_devinfo *dinfo;
>>     char name[32];
>>
>>     for (child = OF_child(i2croot); child != 0; child = OF_peer(child)) {
>>         if (OF_getprop(child, "name", name, sizeof(name)) <= 0)
>>             continue;
>>
>>         if (strcmp(name, "i2c-bus") != 0 && strcmp(name, "i2c") != 0)
>>             continue;
>>
>>         dinfo = malloc(sizeof(struct ofw_bus_devinfo), M_SMU,
>>             M_WAITOK | M_ZERO);
>>         if (ofw_bus_gen_setup_devinfo(dinfo, child) != 0) {
>>             free(dinfo, M_SMU);
>>             continue;
>>         }
>>
>>         cdev = device_add_child(smu, NULL, -1);
>>         if (cdev == NULL) {
>>             device_printf(smu, "<%s>: device_add_child failed\n",
>>                 dinfo->obd_name);
>>             ofw_bus_gen_destroy_devinfo(dinfo);
>>             free(dinfo, M_SMU);
>>             continue;
>>         }
>>         device_set_ivars(cdev, dinfo);
>>     }
>> }
>>
>> static int
>> smuiic_probe(device_t dev)
>> {
>>     const char *name;
>>
>>     name = ofw_bus_get_name(dev);
>>     if (name == NULL)
>>         return (ENXIO);
>>
>>     if (strcmp(name, "i2c-bus") == 0 || strcmp(name, "i2c") == 0) {
>>         device_set_desc(dev, "SMU I2C controller");
>>         return (0);
>>     }
>>
>>     return (ENXIO);
>> }
>>
>> static int
>> smuiic_attach(device_t dev)
>> {
>>     struct smuiic_softc *sc = device_get_softc(dev);
>>     mtx_init(&sc->sc_mtx, "smuiic", NULL, MTX_DEF);
>>     sc->sc_iic_inuse = 0;
>>
>>     /* Get our bus number */
>>     OF_getprop(ofw_bus_get_node(dev), "reg", &sc->sc_busno,
>>         sizeof(sc->sc_busno));
>>
>>     /* Add the IIC bus layer */
>>     device_add_child(dev, "iicbus", -1);
>>
>>     return (bus_generic_attach(dev));
>> }
>>
>> static int
>> smuiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
>> {
>>     struct smuiic_softc *sc = device_get_softc(dev);
>>     struct smu_cmd cmd;
>>     int i, j, error;
>>
>>     mtx_lock(&sc->sc_mtx);
>>     while (sc->sc_iic_inuse)
>>         mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 100);
>>
>>     sc->sc_iic_inuse = 1;
>>     error = 0;
>>
>>     for (i = 0; i < nmsgs; i++) {
>>         cmd.cmd = SMU_I2C;
>>         cmd.data[0] = sc->sc_busno;
>>         if (msgs[i].flags & IIC_M_NOSTOP)
>>             cmd.data[1] = SMU_I2C_COMBINED;
>>         else
>>             cmd.data[1] = SMU_I2C_SIMPLE;
>>
>>         cmd.data[2] = msgs[i].slave;
>>         if (msgs[i].flags & IIC_M_RD)
>>             cmd.data[2] |= 1;
>>
>>         if (msgs[i].flags & IIC_M_NOSTOP) {
>>             KASSERT(msgs[i].len < 4,
>>                 ("oversize I2C combined message"));
>>
>>             cmd.data[3] = min(msgs[i].len, 3);
>>             memcpy(&cmd.data[4], msgs[i].buf, min(msgs[i].len, 3));
>>             i++; /* Advance to next part of message */
>>         } else {
>>             cmd.data[3] = 0;
>>             memset(&cmd.data[4], 0, 3);
>>         }
>>
>>         cmd.data[7] = msgs[i].slave;
>>         if (msgs[i].flags & IIC_M_RD)
>>             cmd.data[7] |= 1;
>>
>>         cmd.data[8] = msgs[i].len;
>>         if (msgs[i].flags & IIC_M_RD) {
>>             memset(&cmd.data[9], 0xff, msgs[i].len);
>>             cmd.len = 9;
>>         } else {
>>             memcpy(&cmd.data[9], msgs[i].buf, msgs[i].len);
>>             cmd.len = 9 + msgs[i].len;
>>         }
>>
>>         mtx_unlock(&sc->sc_mtx);
>>         smu_run_cmd(device_get_parent(dev), &cmd, 1);
>>         mtx_lock(&sc->sc_mtx);
>>
>>         for (j = 0; j < 10; j++) {
>>             cmd.cmd = SMU_I2C;
>>             cmd.len = 1;
>>             cmd.data[0] = 0;
>>             memset(&cmd.data[1], 0xff, msgs[i].len);
>>
>>             mtx_unlock(&sc->sc_mtx);
>>             smu_run_cmd(device_get_parent(dev), &cmd, 1);
>>             mtx_lock(&sc->sc_mtx);
>>
>>             if (!(cmd.data[0] & 0x80))
>>                 break;
>>
>>             mtx_sleep(sc, &sc->sc_mtx, 0, "smuiic", 10);
>>         }
>>
>>         if (cmd.data[0] & 0x80) {
>>             error = EIO;
>>             msgs[i].len = 0;
>>             goto exit;
>>         }
>>         memcpy(msgs[i].buf, &cmd.data[1], msgs[i].len);
>>         msgs[i].len = cmd.len - 1;
>>     }
>>
>>     exit:
>>     sc->sc_iic_inuse = 0;
>>     mtx_unlock(&sc->sc_mtx);
>>     wakeup(sc);
>>     return (error);
>> }
>>
>> static phandle_t
>> smuiic_get_node(device_t bus, device_t dev)
>> {
>>
>>     return (ofw_bus_get_node(bus));
>> }
>>
>>
>>
>> On Mon, Mar 13, 2017 at 11:39 AM, TCH <[hidden email]> wrote:
>>
>>> Hi.
>>>
>>> I've just installed OpenBSD on my PowerMac 11,2. The install was
>>> successfully done, but when i try to boot it, then in the middle of the
>>> boot, it stops with the following message:
>>>
>>> smu0 at mainbus0: cannot map smu-doorbell gpio
>>>
>>> and then it stops and freezes. Slowly after this, the fans in the
>>> machine are roars up and they begin to blow like hell.
>>>
>>> Any ideas on this?
>>>
>>> - TCH
>>>
>>>
>>

Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

Bryan Vyhmeister-3
On Mon, Mar 13, 2017 at 10:57:30PM +0000, Peter Kay wrote:
> OpenBSD current as of a couple of weeks ago boots just fine on my Dual
> core 2.3GHz G5.
>
> How much memory is in it, and is it correctly installed (in pairs,

Likewise, my Dual 2.5GHz G5 does boot fine but has some SATA controller
problems sooner or later. I also ran into problems with radeondrm(4)
with my PCIe card but I have not had time to get back to the problem and
try to fix it. My reports are in archives of this list from December of
last year (2016). I have 12GB of memory in mine but only 2GB are
available for use by OpenBSD/macppc.

I only started using the system with -current and I believe more PCIe G5
support arrived after 6.0.

Bryan

TCH
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

TCH
I have an nVidia 6600 and 4 GB RAM. I did not checked if they are
aligned, but since Debian and FreeBSD runs on my machine perfectly, i
think they must be okay.

2017-03-14 2:54 GMT+01:00, Bryan Vyhmeister <[hidden email]>:

> On Mon, Mar 13, 2017 at 10:57:30PM +0000, Peter Kay wrote:
>> OpenBSD current as of a couple of weeks ago boots just fine on my Dual
>> core 2.3GHz G5.
>>
>> How much memory is in it, and is it correctly installed (in pairs,
>
> Likewise, my Dual 2.5GHz G5 does boot fine but has some SATA controller
> problems sooner or later. I also ran into problems with radeondrm(4)
> with my PCIe card but I have not had time to get back to the problem and
> try to fix it. My reports are in archives of this list from December of
> last year (2016). I have 12GB of memory in mine but only 2GB are
> available for use by OpenBSD/macppc.
>
> I only started using the system with -current and I believe more PCIe G5
> support arrived after 6.0.
>
> Bryan
>

Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

Bryan Vyhmeister-3
On Tue, Mar 14, 2017 at 10:49:26AM +0100, TCH wrote:
> I have an nVidia 6600 and 4 GB RAM. I did not checked if they are
> aligned, but since Debian and FreeBSD runs on my machine perfectly, i
> think they must be okay.

I would try -current and see what happens.

Bryan

TCH
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

TCH
You mean this one?

https://ftp.spline.de/pub/OpenBSD/snapshots/macppc/install61.iso

2017-03-14 15:51 GMT+01:00, Bryan Vyhmeister <[hidden email]>:
> On Tue, Mar 14, 2017 at 10:49:26AM +0100, TCH wrote:
>> I have an nVidia 6600 and 4 GB RAM. I did not checked if they are
>> aligned, but since Debian and FreeBSD runs on my machine perfectly, i
>> think they must be okay.
>
> I would try -current and see what happens.
>
> Bryan
>

Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

Bryan Vyhmeister-3
On Tue, Mar 14, 2017 at 04:09:51PM +0100, TCH wrote:
> You mean this one?
>
> https://ftp.spline.de/pub/OpenBSD/snapshots/macppc/install61.iso

Yes, that's the one. There will be a 6.1 release soon (April or May) and
-current is at 6.1-beta right now in preparation for that.

Bryan

TCH
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: OpenBSD 6.0 cannot boot on PowerMac 11,2

TCH
I tried it with the latest snapshot image. The result is the same.
Installs, boots then stuck at the middle of booting.

2017-03-14 16:33 GMT+01:00, Bryan Vyhmeister <[hidden email]>:

> On Tue, Mar 14, 2017 at 04:09:51PM +0100, TCH wrote:
>> You mean this one?
>>
>> https://ftp.spline.de/pub/OpenBSD/snapshots/macppc/install61.iso
>
> Yes, that's the one. There will be a 6.1 release soon (April or May) and
> -current is at 6.1-beta right now in preparation for that.
>
> Bryan
>

Loading...