d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
b83d10091f
freebsd-skq/sys/powerpc/powermac/smu.c
Pedro F. Giffuni 71e3c3083b sys/powerpc: further adoption of SPDX licensing ID tags. 
Mainly focus on files that use BSD 2-Clause license, however the tool I
was using misidentified many licenses so this was mostly a manual - error
prone - task.

The Software Package Data Exchange (SPDX) group provides a specification
to make it easier for automated tools to detect and summarize well known
opensource licenses. We are gradually adopting the specification, noting
that the tags are considered only advisory and do not, in any way,
superceed or replace the license texts.
2017-11-27 15:09:59 +00:00

1582 lines
36 KiB
C
Raw Blame History

/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* 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$");
#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) + 2731;
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 + 2731; /* 50 C */
sens->therm.max_temp = 900 + 2731; /* 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));
}
Reference in New Issue View Git Blame Copy Permalink