From owner-svn-src-all@FreeBSD.ORG Sat Mar 20 14:49:44 2010 Return-Path: Delivered-To: svn-src-all@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:4f8:fff6::34]) by hub.freebsd.org (Postfix) with ESMTP id BE83C106566B; Sat, 20 Mar 2010 14:49:44 +0000 (UTC) (envelope-from nwhitehorn@FreeBSD.org) Received: from svn.freebsd.org (svn.freebsd.org [IPv6:2001:4f8:fff6::2c]) by mx1.freebsd.org (Postfix) with ESMTP id A9C6C8FC16; Sat, 20 Mar 2010 14:49:44 +0000 (UTC) Received: from svn.freebsd.org (localhost [127.0.0.1]) by svn.freebsd.org (8.14.3/8.14.3) with ESMTP id o2KEni1Y003259; Sat, 20 Mar 2010 14:49:44 GMT (envelope-from nwhitehorn@svn.freebsd.org) Received: (from nwhitehorn@localhost) by svn.freebsd.org (8.14.3/8.14.3/Submit) id o2KEnip8003255; Sat, 20 Mar 2010 14:49:44 GMT (envelope-from nwhitehorn@svn.freebsd.org) Message-Id: <201003201449.o2KEnip8003255@svn.freebsd.org> From: Nathan Whitehorn Date: Sat, 20 Mar 2010 14:49:44 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-stable@freebsd.org, svn-src-stable-8@freebsd.org X-SVN-Group: stable-8 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cc: Subject: svn commit: r205373 - in stable/8: share/man/man4/man4.powerpc sys/powerpc/powermac X-BeenThere: svn-src-all@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: "SVN commit messages for the entire src tree \(except for " user" and " projects" \)" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 20 Mar 2010 14:49:44 -0000 Author: nwhitehorn Date: Sat Mar 20 14:49:44 2010 New Revision: 205373 URL: http://svn.freebsd.org/changeset/base/205373 Log: MFC r204082,204179,204180,204218,204241,204247,204270,204692: Provide thermal management and monitoring features in smu(4). This allows fan control and thermal monitoring on SMU-based Apple G5 machines, as well as an led(4) interface to control the sleep LED. Added: stable/8/share/man/man4/man4.powerpc/smu.4 - copied, changed from r204241, head/share/man/man4/man4.powerpc/smu.4 Modified: stable/8/share/man/man4/man4.powerpc/Makefile stable/8/sys/powerpc/powermac/smu.c Directory Properties: stable/8/share/man/man4/ (props changed) stable/8/sys/ (props changed) stable/8/sys/amd64/include/xen/ (props changed) stable/8/sys/cddl/contrib/opensolaris/ (props changed) stable/8/sys/contrib/dev/acpica/ (props changed) stable/8/sys/contrib/pf/ (props changed) stable/8/sys/dev/xen/xenpci/ (props changed) Modified: stable/8/share/man/man4/man4.powerpc/Makefile ============================================================================== --- stable/8/share/man/man4/man4.powerpc/Makefile Sat Mar 20 14:42:16 2010 (r205372) +++ stable/8/share/man/man4/man4.powerpc/Makefile Sat Mar 20 14:49:44 2010 (r205373) @@ -7,6 +7,7 @@ MAN= adb.4 \ cuda.4 \ pmu.4 \ powermac_nvram.4 \ + smu.4 \ snd_ai2s.4 \ snd_davbus.4 \ tsec.4 Copied and modified: stable/8/share/man/man4/man4.powerpc/smu.4 (from r204241, head/share/man/man4/man4.powerpc/smu.4) ============================================================================== --- head/share/man/man4/man4.powerpc/smu.4 Tue Feb 23 04:56:06 2010 (r204241, copy source) +++ stable/8/share/man/man4/man4.powerpc/smu.4 Sat Mar 20 14:49:44 2010 (r205373) @@ -41,7 +41,7 @@ kernel configuration file: .Sh DESCRIPTION The .Nm -driver provides support for the System Management Unit (PMU) found in many +driver provides support for the System Management Unit (SMU) found in many Apple G5 systems. This includes most Power Macintosh G5 and all iMac G5 systems. .Pp @@ -75,6 +75,9 @@ The following sysctls can be used to con power management behavior and to examine current system power and thermal conditions. .Bl -tag -width indent +.It Va dev.smu.%d.server_mode +Restart after power failure behavior (1 causes system to reboot after power +cut, 0 causes system to remain off). .It Va dev.smu.%d.target_temp Target system temperature, in degrees Celsius. The .Nm @@ -112,7 +115,7 @@ annunciator interface at The .Nm device driver appeared in -.Fx 9.0 . +.Fx 8.0 . .Sh AUTHORS .An -nosplit The Modified: stable/8/sys/powerpc/powermac/smu.c ============================================================================== --- stable/8/sys/powerpc/powermac/smu.c Sat Mar 20 14:42:16 2010 (r205372) +++ stable/8/sys/powerpc/powermac/smu.c Sat Mar 20 14:49:44 2010 (r205373) @@ -34,21 +34,53 @@ __FBSDID("$FreeBSD$"); #include #include #include +#include #include +#include +#include #include #include +#include #include +#include #include +#include #include #include #include struct smu_cmd { - uint8_t 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 { + cell_t reg; + cell_t min_rpm; + cell_t max_rpm; + cell_t unmanaged_rpm; + char location[32]; + + int old_style; + int setpoint; +}; + +struct smu_sensor { + cell_t reg; + char location[32]; + enum { + SMU_CURRENT_SENSOR, + SMU_VOLTAGE_SENSOR, + SMU_POWER_SENSOR, + SMU_TEMP_SENSOR + } type; }; struct smu_softc { @@ -62,9 +94,40 @@ struct smu_softc { bus_space_tag_t sc_bt; bus_space_handle_t sc_mailbox; - struct smu_cmd *sc_cmd; + 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; + 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; + + /* Thermal management parameters */ + int sc_target_temp; /* Default 55 C */ + int sc_critical_temp; /* Default 90 C */ + + struct cdev *sc_leddev; }; /* regular bus attachment functions */ @@ -77,6 +140,18 @@ static int smu_attach(device_t); 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); +/* 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_fans(device_t dev, phandle_t fanroot); +static void smu_attach_sensors(device_t dev, phandle_t sensroot); +static void smu_fan_management_proc(void *xdev); +static void smu_manage_fans(device_t smu); +static void smu_set_sleepled(void *xdev, int onoff); +static int smu_server_mode(SYSCTL_HANDLER_ARGS); +static void smu_doorbell_intr(void *xdev); + /* where to find the doorbell GPIO */ static device_t smu_doorbell = NULL; @@ -97,11 +172,43 @@ static driver_t smu_driver = { static devclass_t smu_devclass; DRIVER_MODULE(smu, nexus, smu_driver, smu_devclass, 0, 0); +MALLOC_DEFINE(M_SMU, "smu", "SMU Sensor Information"); -#define SMU_MAILBOX 0x860c +#define SMU_MAILBOX 0x8000860c +#define SMU_FANMGT_INTERVAL 1000 /* ms */ /* Command types */ -#define SMU_POWER 0xaa +#define SMU_ADC 0xd8 +#define SMU_FAN 0x4a +#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 + +/* 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) @@ -127,10 +234,14 @@ 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; /* * Map the mailbox area. This should be determined from firmware, @@ -139,7 +250,7 @@ smu_attach(device_t dev) 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_be_tag; + sc->sc_bt = &bs_le_tag; bus_space_map(sc->sc_bt, SMU_MAILBOX, 4, 0, &sc->sc_mailbox); /* @@ -150,6 +261,7 @@ smu_attach(device_t dev) 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. @@ -159,51 +271,241 @@ smu_attach(device_t dev) EVENTHANDLER_REGISTER(cpufreq_post_change, smu_cpufreq_post_change, dev, EVENTHANDLER_PRI_ANY); + /* + * Detect and attach child devices. + */ + node = ofw_bus_get_node(dev); + 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, "rpm-fans", 9) == 0 || + strncmp(name, "fans", 5) == 0) + smu_attach_fans(dev, child); + + if (strncmp(name, "sensors", 8) == 0) + smu_attach_sensors(dev, child); + } + + /* + * 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 simple-minded thermal management. + */ + sc->sc_target_temp = 55; + sc->sc_critical_temp = 90; + + SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, + "target_temp", CTLTYPE_INT | CTLFLAG_RW, &sc->sc_target_temp, + sizeof(int), "Target temperature (C)"); + SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, + "critical_temp", CTLTYPE_INT | CTLFLAG_RW, + &sc->sc_critical_temp, sizeof(int), "Critical temperature (C)"); + + kproc_create(smu_fan_management_proc, dev, &sc->sc_fanmgt_proc, + RFHIGHPID, 0, "smu_thermal"); + + /* + * 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); + return (0); } -static int -smu_run_cmd(device_t dev, struct smu_cmd *cmd) +static void +smu_send_cmd(device_t dev, struct smu_cmd *cmd) { struct smu_softc *sc; - int doorbell_ack, result; sc = device_get_softc(dev); - mtx_lock(&sc->sc_mtx); + mtx_assert(&sc->sc_mtx, MA_OWNED); + + powerpc_pow_enabled = 0; /* SMU cannot work if we go to NAP */ + sc->sc_cur_cmd = cmd; /* Copy the command to the mailbox */ - memcpy(sc->sc_cmd, cmd, sizeof(*cmd)); + 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); - /* Invalidate the cacheline it is in -- SMU bypasses the cache */ - __asm __volatile("dcbst 0,%0; sync" :: "r"(sc->sc_cmd): "memory"); + /* 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); +} - /* Wait for the doorbell GPIO to go high, signaling completion */ - do { - /* XXX: timeout */ - DELAY(50); - doorbell_ack = macgpio_read(smu_doorbell); - } while (!doorbell_ack); +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; + 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 (sc->sc_cmd->cmd == ~cmd->cmd) - result = 0; + if (cmd->cmd == ((~cmd_code) & 0xff)) + error = 0; else - result = EIO; + error = EIO; - mtx_unlock(&sc->sc_mtx); + 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]; - return (result); + 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 @@ -222,7 +524,7 @@ smu_slew_cpu_voltage(device_t dev, int t cmd.data[6] = 1; cmd.data[7] = to; - smu_run_cmd(dev, &cmd); + smu_run_cmd(dev, &cmd, 1); } static void @@ -286,3 +588,458 @@ doorbell_attach(device_t dev) smu_doorbell = dev; return (0); } + +/* + * Sensor and fan management + */ + +static int +smu_fan_set_rpm(device_t smu, struct smu_fan *fan, int rpm) +{ + struct smu_cmd cmd; + int error; + + cmd.cmd = SMU_FAN; + error = EIO; + + /* Clamp to allowed range */ + rpm = max(fan->min_rpm, rpm); + rpm = min(fan->max_rpm, rpm); + + /* + * 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] = (rpm >> 8) & 0xff; + cmd.data[3] = rpm & 0xff; + + error = smu_run_cmd(smu, &cmd, 1); + if (error) + fan->old_style = 1; + } + + if (fan->old_style) { + cmd.len = 14; + cmd.data[0] = 0; + 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(device_t smu, struct smu_fan *fan) +{ + struct smu_cmd cmd; + + cmd.cmd = SMU_FAN; + cmd.len = 1; + cmd.data[0] = 1; + + smu_run_cmd(smu, &cmd, 1); + + return ((cmd.data[fan->reg*2+1] << 8) | cmd.data[fan->reg*2+2]); +} + +static int +smu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS) +{ + device_t smu; + struct smu_softc *sc; + struct smu_fan *fan; + int rpm, error; + + smu = arg1; + sc = device_get_softc(smu); + fan = &sc->sc_fans[arg2]; + + rpm = smu_fan_read_rpm(smu, fan); + error = sysctl_handle_int(oidp, &rpm, 0, req); + + if (error || !req->newptr) + return (error); + + sc->sc_lastuserchange = time_uptime; + + return (smu_fan_set_rpm(smu, fan, rpm)); +} + +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; + phandle_t child; + char type[32], sysctl_name[32]; + int i; + + sc = device_get_softc(dev); + sc->sc_nfans = 0; + + for (child = OF_child(fanroot); child != 0; child = OF_peer(child)) + sc->sc_nfans++; + + if (sc->sc_nfans == 0) { + device_printf(dev, "WARNING: No fans detected!\n"); + return; + } + + sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct smu_fan), M_SMU, + M_WAITOK | M_ZERO); + + fan = sc->sc_fans; + sc->sc_nfans = 0; + + 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"); + + for (child = OF_child(fanroot); child != 0; child = OF_peer(child)) { + OF_getprop(child, "device_type", type, sizeof(type)); + if (strcmp(type, "fan-rpm-control") != 0) + continue; + + fan->old_style = 0; + OF_getprop(child, "reg", &fan->reg, sizeof(cell_t)); + OF_getprop(child, "min-value", &fan->min_rpm, sizeof(cell_t)); + OF_getprop(child, "max-value", &fan->max_rpm, sizeof(cell_t)); + + if (OF_getprop(child, "unmanaged-value", &fan->unmanaged_rpm, + sizeof(cell_t)) != sizeof(cell_t)) + fan->unmanaged_rpm = fan->max_rpm; + + fan->setpoint = smu_fan_read_rpm(dev, fan); + + OF_getprop(child, "location", fan->location, + sizeof(fan->location)); + + /* Add sysctls */ + for (i = 0; i < strlen(fan->location); i++) { + sysctl_name[i] = tolower(fan->location[i]); + if (isspace(sysctl_name[i])) + sysctl_name[i] = '_'; + } + sysctl_name[i] = 0; + + 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", + CTLTYPE_INT | CTLFLAG_RD, &fan->min_rpm, sizeof(cell_t), + "Minimum allowed RPM"); + SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "maxrpm", + CTLTYPE_INT | CTLFLAG_RD, &fan->max_rpm, sizeof(cell_t), + "Maximum allowed RPM"); + SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "rpm", + CTLTYPE_INT | CTLFLAG_RW, dev, sc->sc_nfans, + smu_fanrpm_sysctl, "I", "Fan RPM"); + + fan++; + sc->sc_nfans++; + } +} + +static int +smu_sensor_read(device_t smu, struct smu_sensor *sens, int *val) +{ + 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 (error); + + 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 C. */ + value >>= 16; + 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; + } + + *val = value; + return (0); +} + +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]; + + error = smu_sensor_read(smu, sens, &value); + if (error != 0) + return (error); + + 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; + + 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, "location", sens->location, + sizeof(sens->location)); + + for (i = 0; i < strlen(sens->location); i++) { + sysctl_name[i] = tolower(sens->location[i]); + if (isspace(sysctl_name[i])) + sysctl_name[i] = '_'; + } + sysctl_name[i] = 0; + + sprintf(sysctl_desc,"%s (%s)", sens->location, units); + + SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(sensroot_oid), OID_AUTO, + sysctl_name, CTLTYPE_INT | CTLFLAG_RD, dev, sc->sc_nsensors, + smu_sensor_sysctl, "I", sysctl_desc); + + sens++; + sc->sc_nsensors++; + } +} + +static void +smu_fan_management_proc(void *xdev) +{ + device_t smu = xdev; + + while(1) { + smu_manage_fans(smu); + pause("smu", SMU_FANMGT_INTERVAL * hz / 1000); + } +} + +static void +smu_manage_fans(device_t smu) +{ + struct smu_softc *sc; + int i, maxtemp, temp, factor, error; + + sc = device_get_softc(smu); + + maxtemp = 0; + for (i = 0; i < sc->sc_nsensors; i++) { + if (sc->sc_sensors[i].type != SMU_TEMP_SENSOR) + continue; + + error = smu_sensor_read(smu, &sc->sc_sensors[i], &temp); + if (error == 0 && temp > maxtemp) + maxtemp = temp; + } + + if (maxtemp < 10) { /* Bail if no good sensors */ + for (i = 0; i < sc->sc_nfans; i++) + smu_fan_set_rpm(smu, &sc->sc_fans[i], + sc->sc_fans[i].unmanaged_rpm); + return; + } + + if (maxtemp > sc->sc_critical_temp) { + device_printf(smu, "WARNING: Current system temperature (%d C) " + "exceeds critical temperature (%d C)! Shutting down!\n", + maxtemp, sc->sc_critical_temp); + shutdown_nice(RB_POWEROFF); + } + + if (maxtemp - sc->sc_target_temp > 20) + device_printf(smu, "WARNING: Current system temperature (%d C) " + "more than 20 degrees over target temperature (%d C)!\n", + maxtemp, sc->sc_target_temp); + + if (time_uptime - sc->sc_lastuserchange < 3) { + /* + * If we have heard from a user process in the last 3 seconds, + * go away. + */ + + return; + } + + if (maxtemp - sc->sc_target_temp > 4) + factor = 110; + else if (maxtemp - sc->sc_target_temp > 1) + factor = 105; + else if (sc->sc_target_temp - maxtemp > 4) + factor = 90; + else if (sc->sc_target_temp - maxtemp > 1) + factor = 95; + else + factor = 100; + + for (i = 0; i < sc->sc_nfans; i++) + smu_fan_set_rpm(smu, &sc->sc_fans[i], + (sc->sc_fans[i].setpoint * factor) / 100); +} + +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)); +} +