Now, port this over to OpenBSD and you may have a solution.
On Mon, Mar 13, 2017 at 3:16 PM, Joe Nosay <superbisq...@gmail.com> 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 <t...@amigaspirit.hu> 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 >> >> >
