1 /* $NetBSD: tda.c,v 1.14 2020/10/31 13:17:34 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.14 2020/10/31 13:17:34 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 DEGC_TO_mK(c) (((c) * 1000000) + 273150000) 56 57 #define CPU_TEMP_MAX DEGC_TO_mK(67) 58 #define CPU_TEMP_MIN DEGC_TO_mK(57) 59 #define SYS_TEMP_MAX DEGC_TO_mK(30) 60 #define SYS_TEMP_MIN DEGC_TO_mK(20) 61 62 struct tda_softc { 63 device_t sc_dev; 64 i2c_tag_t sc_tag; 65 i2c_addr_t sc_addr; 66 67 u_int16_t sc_cfan_speed; /* current CPU fan speed */ 68 u_int16_t sc_sfan_speed; /* current SYS fan speed */ 69 70 struct sysmon_envsys *sc_sme; 71 envsys_data_t sc_sensor[2]; 72 73 callout_t sc_timer; 74 }; 75 76 int tda_match(device_t, cfdata_t, void *); 77 void tda_attach(device_t, device_t, void *); 78 static int tda_detach(device_t, int); 79 void tda_refresh(struct sysmon_envsys *, envsys_data_t *); 80 81 void tda_setspeed(struct tda_softc *); 82 static void tda_adjust(void *); 83 static void tda_timeout(void *); 84 85 86 CFATTACH_DECL3_NEW(tda, sizeof(struct tda_softc), 87 tda_match, tda_attach, tda_detach, NULL, NULL, NULL, 88 DVF_DETACH_SHUTDOWN); 89 90 int 91 tda_match(device_t parent, cfdata_t match, void *aux) 92 { 93 struct i2c_attach_args *ia = aux; 94 95 /* Only attach on the Sun Blade 1000/2000. */ 96 if (strcmp(machine_model, "SUNW,Sun-Blade-1000") != 0) 97 return (0); 98 99 /* 100 * No need for "compatible" matching, we know exactly what 101 * firmware calls us. 102 */ 103 if (ia->ia_name == NULL) 104 return(0); 105 106 return strcmp(ia->ia_name, "fan-control") == 0 ? 107 I2C_MATCH_DIRECT_SPECIFIC : 0; 108 } 109 110 void 111 tda_attach(device_t parent, device_t self, void *aux) 112 { 113 struct tda_softc *sc = device_private(self); 114 struct i2c_attach_args *ia = aux; 115 int rc; 116 117 sc->sc_dev = self; 118 sc->sc_tag = ia->ia_tag; 119 sc->sc_addr = ia->ia_addr; 120 121 aprint_normal(": %s\n", ia->ia_name); 122 aprint_naive(": Environment sensor\n"); 123 124 /* 125 * Set the fans to maximum speed and save the power levels; 126 * the controller is write-only. 127 */ 128 sc->sc_cfan_speed = sc->sc_sfan_speed = (TDA_FANSPEED_MAX+TDA_FANSPEED_MIN)/2; 129 tda_setspeed(sc); 130 131 callout_init(&sc->sc_timer, CALLOUT_MPSAFE); 132 callout_reset(&sc->sc_timer, hz*20, tda_timeout, sc); 133 134 /* Initialise sensor data */ 135 sc->sc_sensor[SENSOR_FAN_CPU].state = ENVSYS_SINVALID; 136 sc->sc_sensor[SENSOR_FAN_CPU].units = ENVSYS_INTEGER; 137 sc->sc_sensor[SENSOR_FAN_CPU].flags = ENVSYS_FMONNOTSUPP; 138 strlcpy(sc->sc_sensor[SENSOR_FAN_CPU].desc, 139 "fan.cpu",sizeof("fan.cpu")); 140 sc->sc_sensor[SENSOR_FAN_SYS].state = ENVSYS_SINVALID; 141 sc->sc_sensor[SENSOR_FAN_SYS].units = ENVSYS_INTEGER; 142 sc->sc_sensor[SENSOR_FAN_SYS].flags = ENVSYS_FMONNOTSUPP; 143 strlcpy(sc->sc_sensor[SENSOR_FAN_SYS].desc, 144 "fan.sys",sizeof("fan.sys")); 145 sc->sc_sme = sysmon_envsys_create(); 146 rc = sysmon_envsys_sensor_attach( 147 sc->sc_sme, &sc->sc_sensor[SENSOR_FAN_CPU]); 148 if (rc) { 149 sysmon_envsys_destroy(sc->sc_sme); 150 aprint_error_dev(self, 151 "unable to attach cpu fan at sysmon, error %d\n", rc); 152 return; 153 } 154 rc = sysmon_envsys_sensor_attach( 155 sc->sc_sme, &sc->sc_sensor[SENSOR_FAN_SYS]); 156 if (rc) { 157 sysmon_envsys_destroy(sc->sc_sme); 158 aprint_error_dev(self, 159 "unable to attach sys fan at sysmon, error %d\n", rc); 160 return; 161 } 162 sc->sc_sme->sme_name = device_xname(self); 163 sc->sc_sme->sme_cookie = sc; 164 sc->sc_sme->sme_refresh = tda_refresh; 165 rc = sysmon_envsys_register(sc->sc_sme); 166 if (rc) { 167 aprint_error_dev(self, 168 "unable to register with sysmon, error %d\n", rc); 169 sysmon_envsys_destroy(sc->sc_sme); 170 return; 171 } 172 } 173 174 int 175 tda_detach(device_t self, int flags) 176 { 177 struct tda_softc *sc = device_private(self); 178 179 if (sc->sc_sme != NULL) 180 sysmon_envsys_unregister(sc->sc_sme); 181 182 callout_halt(&sc->sc_timer, NULL); 183 callout_destroy(&sc->sc_timer); 184 185 sc->sc_cfan_speed = sc->sc_sfan_speed = TDA_FANSPEED_MAX; 186 tda_setspeed(sc); 187 return 0; 188 } 189 190 static void 191 tda_timeout(void *v) 192 { 193 struct tda_softc *sc = v; 194 195 sysmon_task_queue_sched(0, tda_adjust, sc); 196 callout_reset(&sc->sc_timer, hz*60, tda_timeout, sc); 197 } 198 199 void 200 tda_setspeed(struct tda_softc *sc) 201 { 202 u_int8_t cmd[2]; 203 204 if (sc->sc_cfan_speed < TDA_FANSPEED_MIN) 205 sc->sc_cfan_speed = TDA_FANSPEED_MIN; 206 if (sc->sc_sfan_speed < TDA_FANSPEED_MIN) 207 sc->sc_sfan_speed = TDA_FANSPEED_MIN; 208 if (sc->sc_cfan_speed > TDA_FANSPEED_MAX) 209 sc->sc_cfan_speed = TDA_FANSPEED_MAX; 210 if (sc->sc_sfan_speed > TDA_FANSPEED_MAX) 211 sc->sc_sfan_speed = TDA_FANSPEED_MAX; 212 213 iic_acquire_bus(sc->sc_tag, 0); 214 215 cmd[0] = TDA_CPUFAN_REG; 216 cmd[1] = sc->sc_cfan_speed; 217 if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 218 sc->sc_addr, &cmd, sizeof(cmd), NULL, 0, 0)) { 219 aprint_error_dev(sc->sc_dev, "cannot write cpu-fan register\n"); 220 iic_release_bus(sc->sc_tag, 0); 221 return; 222 } 223 224 cmd[0] = TDA_SYSFAN_REG; 225 cmd[1] = sc->sc_sfan_speed; 226 if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 227 sc->sc_addr, &cmd, sizeof(cmd), NULL, 0, 0)) { 228 aprint_error_dev(sc->sc_dev, "cannot write system-fan register\n"); 229 iic_release_bus(sc->sc_tag, 0); 230 return; 231 } 232 233 iic_release_bus(sc->sc_tag, 0); 234 235 aprint_debug_dev(sc->sc_dev, "changed fan speed to cpu=%d system=%d\n", 236 sc->sc_cfan_speed, sc->sc_sfan_speed); 237 } 238 239 static bool 240 is_cpu_sensor(const envsys_data_t *edata) 241 { 242 if (edata->units != ENVSYS_STEMP) 243 return false; 244 return strcmp(edata->desc, "external") == 0; 245 } 246 247 static bool 248 is_system_sensor(const envsys_data_t *edata) 249 { 250 if (edata->units != ENVSYS_STEMP) 251 return false; 252 return strcmp(edata->desc, "internal") == 0; 253 } 254 255 static void 256 tda_adjust(void *v) 257 { 258 struct tda_softc *sc = v; 259 u_int64_t ctemp, stemp; 260 u_int16_t cspeed, sspeed; 261 262 /* Default to running the fans at maximum speed. */ 263 sspeed = cspeed = TDA_FANSPEED_MAX; 264 265 /* fetch maximum current temperature */ 266 ctemp = sysmon_envsys_get_max_value(is_cpu_sensor, true); 267 stemp = sysmon_envsys_get_max_value(is_system_sensor, true); 268 269 /* the predicates for selecting sensors must have gone wrong */ 270 if (ctemp == 0 || stemp == 0) { 271 aprint_error_dev(sc->sc_dev, "skipping temp adjustment" 272 " - no sensor values\n"); 273 return; 274 } 275 276 aprint_debug_dev(sc->sc_dev, "current temperature: cpu %" PRIu64 277 " system %" PRIu64 "\n", 278 ctemp, stemp); 279 280 if (ctemp < CPU_TEMP_MIN) 281 cspeed = TDA_FANSPEED_MIN; 282 else if (ctemp < CPU_TEMP_MAX) 283 cspeed = TDA_FANSPEED_MIN + 284 (ctemp - CPU_TEMP_MIN) * 285 (TDA_FANSPEED_MAX - TDA_FANSPEED_MIN) / 286 (CPU_TEMP_MAX - CPU_TEMP_MIN); 287 288 if (stemp < SYS_TEMP_MIN) 289 sspeed = TDA_FANSPEED_MIN; 290 else if (stemp < SYS_TEMP_MAX) 291 sspeed = TDA_FANSPEED_MIN + 292 (stemp - SYS_TEMP_MIN) * 293 (TDA_FANSPEED_MAX - TDA_FANSPEED_MIN) / 294 (SYS_TEMP_MAX - SYS_TEMP_MIN); 295 296 if (sspeed == sc->sc_sfan_speed && cspeed == sc->sc_cfan_speed) 297 return; 298 299 sc->sc_sfan_speed = sspeed; 300 sc->sc_cfan_speed = cspeed; 301 tda_setspeed(sc); 302 } 303 304 void 305 tda_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 306 { 307 struct tda_softc *sc = sme->sme_cookie; 308 u_int16_t speed; 309 310 if (edata->sensor == SENSOR_FAN_CPU) 311 speed = sc->sc_cfan_speed; 312 else 313 speed = sc->sc_sfan_speed; 314 if (!speed) 315 edata->state = ENVSYS_SINVALID; 316 else { 317 edata->value_cur = speed; 318 edata->state = ENVSYS_SVALID; 319 } 320 } 321 322
Indexes created Fri Sep 26 20:09:58 GMT 2025