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@openbsd.org>
6 * Copyright (c) 2008 Mark Kettenis <kettenis@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
tda_match(device_t parent,cfdata_t match,void * aux)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
tda_attach(device_t parent,device_t self,void * aux)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
tda_detach(device_t self,int flags)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
tda_timeout(void * v)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
tda_setspeed(struct tda_softc * sc)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
is_cpu_sensor(const envsys_data_t * edata)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
is_system_sensor(const envsys_data_t * edata)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
tda_adjust(void * v)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
tda_refresh(struct sysmon_envsys * sme,envsys_data_t * edata)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