tda.c revision 1.8
1 /* $NetBSD: tda.c,v 1.8 2013/02/03 10:58:28 jdc Exp $ */ 2 /* $OpenBSD: tda.c,v 1.4 2008/02/27 17:25:00 robert Exp $ */ 3 4 /* 5 * Copyright (c) 2008 Robert Nagy <robert (at) openbsd.org> 6 * Copyright (c) 2008 Mark Kettenis <kettenis (at) openbsd.org> 7 * 8 * Permission to use, copy, modify, and distribute this software for any 9 * purpose with or without fee is hereby granted, provided that the above 10 * copyright notice and this permission notice appear in all copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 #include <sys/cdefs.h> 22 __KERNEL_RCSID(0, "$NetBSD: tda.c,v 1.8 2013/02/03 10:58:28 jdc Exp $"); 23 24 #include <sys/param.h> 25 #include <sys/systm.h> 26 #include <sys/kernel.h> 27 #include <sys/device.h> 28 #include <dev/sysmon/sysmonvar.h> 29 #include <dev/sysmon/sysmon_taskq.h> 30 31 #include <machine/autoconf.h> 32 #include <machine/openfirm.h> 33 34 #include <dev/i2c/i2cvar.h> 35 36 /* fan control registers */ 37 #define TDA_SYSFAN_REG 0xf0 38 #define TDA_CPUFAN_REG 0xf2 39 #define TDA_PSFAN_REG 0xf4 40 41 #define TDA_FANSPEED_MIN 0x0c 42 #define TDA_FANSPEED_MAX 0x3f 43 44 #define TDA_PSFAN_ON 0x1f 45 #define TDA_PSFAN_OFF 0x00 46 47 /* Internal and External temperature sensor numbers */ 48 #define SENSOR_TEMP_EXT 0 49 #define SENSOR_TEMP_INT 1 50 51 /* Fan sensor numbers */ 52 #define SENSOR_FAN_CPU 0 53 #define SENSOR_FAN_SYS 1 54 55 #define CPU_TEMP_MAX (67 * 1000000 + 273150000) 56 #define CPU_TEMP_MIN (57 * 1000000 + 273150000) 57 #define SYS_TEMP_MAX (30 * 1000000 + 273150000) 58 #define SYS_TEMP_MIN (20 * 1000000 + 273150000) 59 60 struct tda_softc { 61 device_t sc_dev; 62 i2c_tag_t sc_tag; 63 i2c_addr_t sc_addr; 64 65 u_int16_t sc_cfan_speed; /* current CPU fan speed */ 66 u_int16_t sc_sfan_speed; /* current SYS fan speed */ 67 68 struct sysmon_envsys *sc_sme; 69 envsys_data_t sc_sensor[2]; 70 71 callout_t sc_timer; 72 }; 73 74 int tda_match(device_t, cfdata_t, void *); 75 void tda_attach(device_t, device_t, void *); 76 static int tda_detach(device_t, int); 77 void tda_refresh(struct sysmon_envsys *, envsys_data_t *); 78 79 void tda_setspeed(struct tda_softc *); 80 static void tda_adjust(void *); 81 static void tda_timeout(void *); 82 83 84 CFATTACH_DECL3_NEW(tda, sizeof(struct tda_softc), 85 tda_match, tda_attach, tda_detach, NULL, NULL, NULL, 86 DVF_DETACH_SHUTDOWN); 87 88 int 89 tda_match(device_t parent, cfdata_t match, void *aux) 90 { 91 struct i2c_attach_args *ia = aux; 92 char name[32]; 93 94 /* Only attach on the Sun Blade 1000/2000. */ 95 if (OF_getprop(findroot(), "name", name, sizeof(name)) <= 0) 96 return (0); 97 if (strcmp(name, "SUNW,Sun-Blade-1000") != 0) 98 return (0); 99 100 /* 101 * No need for "compatible" matching, we know exactly what 102 * firmware calls us. 103 */ 104 if (ia->ia_name == NULL) 105 return(0); 106 return strcmp(ia->ia_name, "fan-control") == 0; 107 } 108 109 void 110 tda_attach(device_t parent, device_t self, void *aux) 111 { 112 struct tda_softc *sc = device_private(self); 113 struct i2c_attach_args *ia = aux; 114 115 sc->sc_dev = self; 116 sc->sc_tag = ia->ia_tag; 117 sc->sc_addr = ia->ia_addr; 118 119 aprint_normal(": %s\n", ia->ia_name); 120 aprint_naive(": Environment sensor\n"); 121 122 /* 123 * Set the fans to maximum speed and save the power levels; 124 * the controller is write-only. 125 */ 126 sc->sc_cfan_speed = sc->sc_sfan_speed = (TDA_FANSPEED_MAX+TDA_FANSPEED_MIN)/2; 127 tda_setspeed(sc); 128 129 callout_init(&sc->sc_timer, CALLOUT_MPSAFE); 130 callout_reset(&sc->sc_timer, hz*20, tda_timeout, sc); 131 132 /* Initialise sensor data */ 133 sc->sc_sensor[SENSOR_FAN_CPU].state = ENVSYS_SINVALID; 134 sc->sc_sensor[SENSOR_FAN_CPU].units = ENVSYS_INTEGER; 135 sc->sc_sensor[SENSOR_FAN_CPU].flags = ENVSYS_FMONNOTSUPP; 136 strlcpy(sc->sc_sensor[SENSOR_FAN_CPU].desc, 137 "fan.cpu",sizeof("fan.cpu")); 138 sc->sc_sensor[SENSOR_FAN_SYS].state = ENVSYS_SINVALID; 139 sc->sc_sensor[SENSOR_FAN_SYS].units = ENVSYS_INTEGER; 140 sc->sc_sensor[SENSOR_FAN_SYS].flags = ENVSYS_FMONNOTSUPP; 141 strlcpy(sc->sc_sensor[SENSOR_FAN_SYS].desc, 142 "fan.sys",sizeof("fan.sys")); 143 sc->sc_sme = sysmon_envsys_create(); 144 if (sysmon_envsys_sensor_attach( 145 sc->sc_sme, &sc->sc_sensor[SENSOR_FAN_CPU])) { 146 sysmon_envsys_destroy(sc->sc_sme); 147 aprint_error_dev(self, 148 "unable to attach cpu fan at sysmon\n"); 149 return; 150 } 151 if (sysmon_envsys_sensor_attach( 152 sc->sc_sme, &sc->sc_sensor[SENSOR_FAN_SYS])) { 153 sysmon_envsys_destroy(sc->sc_sme); 154 aprint_error_dev(self, 155 "unable to attach sys fan at sysmon\n"); 156 return; 157 } 158 sc->sc_sme->sme_name = device_xname(self); 159 sc->sc_sme->sme_cookie = sc; 160 sc->sc_sme->sme_refresh = tda_refresh; 161 if (sysmon_envsys_register(sc->sc_sme)) { 162 aprint_error_dev(self, 163 "unable to register with sysmon\n"); 164 sysmon_envsys_destroy(sc->sc_sme); 165 return; 166 } 167 } 168 169 int 170 tda_detach(device_t self, int flags) 171 { 172 struct tda_softc *sc = device_private(self); 173 174 if (sc->sc_sme != NULL) 175 sysmon_envsys_destroy(sc->sc_sme); 176 177 callout_halt(&sc->sc_timer, NULL); 178 callout_destroy(&sc->sc_timer); 179 180 sc->sc_cfan_speed = sc->sc_sfan_speed = TDA_FANSPEED_MAX; 181 tda_setspeed(sc); 182 return 0; 183 } 184 185 static void 186 tda_timeout(void *v) 187 { 188 struct tda_softc *sc = v; 189 190 sysmon_task_queue_sched(0, tda_adjust, sc); 191 callout_reset(&sc->sc_timer, hz*60, tda_timeout, sc); 192 } 193 194 void 195 tda_setspeed(struct tda_softc *sc) 196 { 197 u_int8_t cmd[2]; 198 199 if (sc->sc_cfan_speed < TDA_FANSPEED_MIN) 200 sc->sc_cfan_speed = TDA_FANSPEED_MIN; 201 if (sc->sc_sfan_speed < TDA_FANSPEED_MIN) 202 sc->sc_sfan_speed = TDA_FANSPEED_MIN; 203 if (sc->sc_cfan_speed > TDA_FANSPEED_MAX) 204 sc->sc_cfan_speed = TDA_FANSPEED_MAX; 205 if (sc->sc_sfan_speed > TDA_FANSPEED_MAX) 206 sc->sc_sfan_speed = TDA_FANSPEED_MAX; 207 208 iic_acquire_bus(sc->sc_tag, 0); 209 210 cmd[0] = TDA_CPUFAN_REG; 211 cmd[1] = sc->sc_cfan_speed; 212 if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 213 sc->sc_addr, &cmd, sizeof(cmd), NULL, 0, 0)) { 214 aprint_error_dev(sc->sc_dev, "cannot write cpu-fan register\n"); 215 iic_release_bus(sc->sc_tag, 0); 216 return; 217 } 218 219 cmd[0] = TDA_SYSFAN_REG; 220 cmd[1] = sc->sc_sfan_speed; 221 if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 222 sc->sc_addr, &cmd, sizeof(cmd), NULL, 0, 0)) { 223 aprint_error_dev(sc->sc_dev, "cannot write system-fan register\n"); 224 iic_release_bus(sc->sc_tag, 0); 225 return; 226 } 227 228 iic_release_bus(sc->sc_tag, 0); 229 230 aprint_debug_dev(sc->sc_dev, "changed fan speed to cpu=%d system=%d\n", 231 sc->sc_cfan_speed, sc->sc_sfan_speed); 232 } 233 234 static bool 235 is_cpu_sensor(const envsys_data_t *edata) 236 { 237 if (edata->units != ENVSYS_STEMP) 238 return false; 239 return strcmp(edata->desc, "external") == 0; 240 } 241 242 static bool 243 is_system_sensor(const envsys_data_t *edata) 244 { 245 if (edata->units != ENVSYS_STEMP) 246 return false; 247 return strcmp(edata->desc, "internal") == 0; 248 } 249 250 static void 251 tda_adjust(void *v) 252 { 253 struct tda_softc *sc = v; 254 u_int64_t ctemp, stemp; 255 u_int16_t cspeed, sspeed; 256 257 /* Default to running the fans at maximum speed. */ 258 sspeed = cspeed = TDA_FANSPEED_MAX; 259 260 /* fetch maximum current temperature */ 261 ctemp = sysmon_envsys_get_max_value(is_cpu_sensor, true); 262 stemp = sysmon_envsys_get_max_value(is_system_sensor, true); 263 264 /* the predicates for selecting sensors must have gone wrong */ 265 if (ctemp == 0 || stemp == 0) { 266 aprint_error_dev(sc->sc_dev, "skipping temp adjustment" 267 " - no sensor values\n"); 268 return; 269 } 270 271 aprint_debug_dev(sc->sc_dev, "current temperature: cpu %" PRIu64 272 " system %" PRIu64 "\n", 273 ctemp, stemp); 274 275 if (ctemp < CPU_TEMP_MIN) 276 cspeed = TDA_FANSPEED_MIN; 277 else if (ctemp < CPU_TEMP_MAX) 278 cspeed = TDA_FANSPEED_MIN + 279 (ctemp - CPU_TEMP_MIN) * 280 (TDA_FANSPEED_MAX - TDA_FANSPEED_MIN) / 281 (CPU_TEMP_MAX - CPU_TEMP_MIN); 282 283 if (stemp < SYS_TEMP_MIN) 284 sspeed = TDA_FANSPEED_MIN; 285 else if (stemp < SYS_TEMP_MAX) 286 sspeed = TDA_FANSPEED_MIN + 287 (stemp - SYS_TEMP_MIN) * 288 (TDA_FANSPEED_MAX - TDA_FANSPEED_MIN) / 289 (SYS_TEMP_MAX - SYS_TEMP_MIN); 290 291 if (sspeed == sc->sc_sfan_speed && cspeed == sc->sc_cfan_speed) 292 return; 293 294 sc->sc_sfan_speed = sspeed; 295 sc->sc_cfan_speed = cspeed; 296 tda_setspeed(sc); 297 } 298 299 void 300 tda_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 301 { 302 struct tda_softc *sc = sme->sme_cookie; 303 u_int16_t speed; 304 305 if (edata->sensor == SENSOR_FAN_CPU) 306 speed = sc->sc_cfan_speed; 307 else 308 speed = sc->sc_sfan_speed; 309 if (!speed) 310 edata->state = ENVSYS_SINVALID; 311 else { 312 edata->value_cur = speed; 313 edata->state = ENVSYS_SVALID; 314 } 315 } 316 317
Indexes created Thu Oct 02 10:09:58 GMT 2025