1*2d8f3966Smaxv /* $NetBSD: ibmhawk.c,v 1.9 2020/05/15 19:28:09 maxv Exp $ */
2ac0fa1d0Shannken
3ac0fa1d0Shannken /*-
4ac0fa1d0Shannken * Copyright (c) 2011 The NetBSD Foundation, Inc.
5ac0fa1d0Shannken * All rights reserved.
6ac0fa1d0Shannken *
7ac0fa1d0Shannken * This code is derived from software contributed to The NetBSD Foundation
8ac0fa1d0Shannken * by Juergen Hannken-Illjes.
9ac0fa1d0Shannken *
10ac0fa1d0Shannken * Redistribution and use in source and binary forms, with or without
11ac0fa1d0Shannken * modification, are permitted provided that the following conditions
12ac0fa1d0Shannken * are met:
13ac0fa1d0Shannken * 1. Redistributions of source code must retain the above copyright
14ac0fa1d0Shannken * notice, this list of conditions and the following disclaimer.
15ac0fa1d0Shannken * 2. Redistributions in binary form must reproduce the above copyright
16ac0fa1d0Shannken * notice, this list of conditions and the following disclaimer in the
17ac0fa1d0Shannken * documentation and/or other materials provided with the distribution.
18ac0fa1d0Shannken *
19ac0fa1d0Shannken * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20ac0fa1d0Shannken * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21ac0fa1d0Shannken * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22ac0fa1d0Shannken * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23ac0fa1d0Shannken * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24ac0fa1d0Shannken * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25ac0fa1d0Shannken * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26ac0fa1d0Shannken * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27ac0fa1d0Shannken * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28ac0fa1d0Shannken * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29ac0fa1d0Shannken * POSSIBILITY OF SUCH DAMAGE.
30ac0fa1d0Shannken */
31ac0fa1d0Shannken
32ac0fa1d0Shannken #include <sys/systm.h>
33ac0fa1d0Shannken #include <sys/param.h>
34ac0fa1d0Shannken #include <sys/kernel.h>
35ac0fa1d0Shannken #include <sys/device.h>
36ac0fa1d0Shannken #include <sys/bswap.h>
37ac0fa1d0Shannken
38ac0fa1d0Shannken #include <dev/sysmon/sysmonvar.h>
39ac0fa1d0Shannken #include <dev/i2c/i2cvar.h>
40ac0fa1d0Shannken #include <dev/i2c/ibmhawkreg.h>
41ac0fa1d0Shannken #include <dev/i2c/ibmhawkvar.h>
42ac0fa1d0Shannken
43ac0fa1d0Shannken #if !defined(IBMHAWK_DEBUG) /* Set to 2 for verbose debug. */
44ac0fa1d0Shannken #if defined(DEBUG)
45ac0fa1d0Shannken #define IBMHAWK_DEBUG 1
46ac0fa1d0Shannken #else
47ac0fa1d0Shannken #define IBMHAWK_DEBUG 0
48ac0fa1d0Shannken #endif
49ac0fa1d0Shannken #endif
50ac0fa1d0Shannken
51ac0fa1d0Shannken /*
52ac0fa1d0Shannken * Known sensors.
53ac0fa1d0Shannken */
54ac0fa1d0Shannken static struct ibmhawk_sensordesc {
55ac0fa1d0Shannken const char *desc;
56ac0fa1d0Shannken uint32_t units;
57ac0fa1d0Shannken int offset;
58ac0fa1d0Shannken } ibmhawk_sensors[] = {
59ac0fa1d0Shannken { "Ambient temperature", ENVSYS_STEMP, IBMHAWK_T_AMBIENT },
60ac0fa1d0Shannken { "CPU 1 temperature", ENVSYS_STEMP, IBMHAWK_T_CPU },
61ac0fa1d0Shannken { "CPU 2 temperature", ENVSYS_STEMP, IBMHAWK_T_CPU+1 },
62ac0fa1d0Shannken { "12 Voltage sensor", ENVSYS_SVOLTS_DC, IBMHAWK_V_VOLTAGE },
63ac0fa1d0Shannken { "5 Voltage sensor", ENVSYS_SVOLTS_DC, IBMHAWK_V_VOLTAGE+1 },
64ac0fa1d0Shannken { "3.3 Voltage sensor", ENVSYS_SVOLTS_DC, IBMHAWK_V_VOLTAGE+2 },
65ac0fa1d0Shannken { "2.5 Voltage sensor", ENVSYS_SVOLTS_DC, IBMHAWK_V_VOLTAGE+3 },
66ac0fa1d0Shannken { "1.5 Voltage sensor", ENVSYS_SVOLTS_DC, IBMHAWK_V_VOLTAGE+4 },
67ac0fa1d0Shannken { "1.25 Voltage sensor", ENVSYS_SVOLTS_DC, IBMHAWK_V_VOLTAGE+5 },
68ac0fa1d0Shannken { "VRM 1", ENVSYS_SVOLTS_DC, IBMHAWK_V_VOLTAGE+6 },
69ac0fa1d0Shannken { "Fan 1", ENVSYS_SFANRPM, IBMHAWK_F_FAN },
70ac0fa1d0Shannken { "Fan 2", ENVSYS_SFANRPM, IBMHAWK_F_FAN+1 },
71ac0fa1d0Shannken { "Fan 3", ENVSYS_SFANRPM, IBMHAWK_F_FAN+2 },
72ac0fa1d0Shannken { "Fan 4", ENVSYS_SFANRPM, IBMHAWK_F_FAN+3 },
73ac0fa1d0Shannken { "Fan 5", ENVSYS_SFANRPM, IBMHAWK_F_FAN+4 },
74ac0fa1d0Shannken { "Fan 6", ENVSYS_SFANRPM, IBMHAWK_F_FAN+5 },
75ac0fa1d0Shannken };
76ac0fa1d0Shannken static const int ibmhawk_num_sensors =
77ac0fa1d0Shannken (sizeof(ibmhawk_sensors)/sizeof(ibmhawk_sensors[0]));
78ac0fa1d0Shannken
79ac0fa1d0Shannken static int ibmhawk_match(device_t, cfdata_t, void *);
80ac0fa1d0Shannken static void ibmhawk_attach(device_t, device_t, void *);
81ac0fa1d0Shannken static int ibmhawk_detach(device_t, int);
82ac0fa1d0Shannken static uint8_t ibmhawk_cksum(uint8_t *);
83ac0fa1d0Shannken static int ibmhawk_request(struct ibmhawk_softc *,
84ac0fa1d0Shannken uint8_t, ibmhawk_response_t *);
85ac0fa1d0Shannken static uint32_t ibmhawk_normalize(int, uint32_t);
86ac0fa1d0Shannken static void ibmhawk_set(struct ibmhawk_softc *, int, int, bool, bool);
87ac0fa1d0Shannken static void ibmhawk_refreshall(struct ibmhawk_softc *, bool);
88ac0fa1d0Shannken static void ibmhawk_refresh(struct sysmon_envsys *, envsys_data_t *);
89ac0fa1d0Shannken static void ibmhawk_get_limits(struct sysmon_envsys *, envsys_data_t *,
90ac0fa1d0Shannken sysmon_envsys_lim_t *, uint32_t *);
91ac0fa1d0Shannken
92ac0fa1d0Shannken CFATTACH_DECL_NEW(ibmhawk, sizeof(struct ibmhawk_softc),
93ac0fa1d0Shannken ibmhawk_match, ibmhawk_attach, ibmhawk_detach, NULL);
94ac0fa1d0Shannken
95ac0fa1d0Shannken static int
ibmhawk_match(device_t parent,cfdata_t match,void * aux)96ac0fa1d0Shannken ibmhawk_match(device_t parent, cfdata_t match, void *aux)
97ac0fa1d0Shannken {
98ac0fa1d0Shannken struct i2c_attach_args *ia = aux;
99ac0fa1d0Shannken ibmhawk_response_t resp;
100ac0fa1d0Shannken static struct ibmhawk_softc sc;
101ac0fa1d0Shannken
10202f2bdfeSthorpej /* There is an expected address for this device: */
10302f2bdfeSthorpej if (ia->ia_addr != 0x37)
10402f2bdfeSthorpej return 0;
10502f2bdfeSthorpej
10602f2bdfeSthorpej /* XXX Probe is potentially destructive. */
10702f2bdfeSthorpej
108ac0fa1d0Shannken sc.sc_tag = ia->ia_tag;
109ac0fa1d0Shannken sc.sc_addr = ia->ia_addr;
110ac0fa1d0Shannken if (ibmhawk_request(&sc, IHR_EQUIP, &resp))
111ac0fa1d0Shannken return 0;
11222de7409Sthorpej
11322de7409Sthorpej return I2C_MATCH_ADDRESS_AND_PROBE;
114ac0fa1d0Shannken }
115ac0fa1d0Shannken
116ac0fa1d0Shannken static void
ibmhawk_attach(device_t parent,device_t self,void * aux)117ac0fa1d0Shannken ibmhawk_attach(device_t parent, device_t self, void *aux)
118ac0fa1d0Shannken {
119ac0fa1d0Shannken struct ibmhawk_softc *sc = device_private(self);
120ac0fa1d0Shannken struct i2c_attach_args *ia = aux;
121ac0fa1d0Shannken ibmhawk_response_t resp;
122ac0fa1d0Shannken int i;
123ac0fa1d0Shannken
124ac0fa1d0Shannken sc->sc_dev = self;
125ac0fa1d0Shannken sc->sc_tag = ia->ia_tag;
126ac0fa1d0Shannken sc->sc_addr = ia->ia_addr;
127ac0fa1d0Shannken
128ac0fa1d0Shannken if (!pmf_device_register(self, NULL, NULL))
129ac0fa1d0Shannken aprint_error_dev(self, "couldn't establish power handler\n");
130ac0fa1d0Shannken if (ibmhawk_request(sc, IHR_NAME, &resp)) {
1317717fecaSmsaitoh aprint_error_dev(self, "communication failed\n");
132ac0fa1d0Shannken return;
133ac0fa1d0Shannken }
134ac0fa1d0Shannken aprint_normal(": IBM Hawk \"%.16s\"\n", resp.ihr_name);
135ac0fa1d0Shannken if (ibmhawk_request(sc, IHR_EQUIP, &resp)) {
136ac0fa1d0Shannken aprint_error_dev(sc->sc_dev, "equip query failed\n");
137ac0fa1d0Shannken return;
138ac0fa1d0Shannken }
139a8a5c538Sriastradh sc->sc_numcpus = uimin(resp.ihr_numcpus, IBMHAWK_MAX_CPU);
140a8a5c538Sriastradh sc->sc_numfans = uimin(resp.ihr_numfans, IBMHAWK_MAX_FAN);
141ac0fa1d0Shannken #if IBMHAWK_DEBUG > 0
142ac0fa1d0Shannken aprint_normal_dev(sc->sc_dev, "monitoring %d/%d cpu(s) %d/%d fan(s)\n",
143ac0fa1d0Shannken sc->sc_numcpus, resp.ihr_numcpus, sc->sc_numfans, resp.ihr_numfans);
144ac0fa1d0Shannken #endif
145ac0fa1d0Shannken /* Request and set sensor thresholds. */
146ac0fa1d0Shannken if (ibmhawk_request(sc, IHR_TEMP_THR, &resp)) {
147ac0fa1d0Shannken aprint_error_dev(sc->sc_dev, "temp threshold query failed\n");
148ac0fa1d0Shannken return;
149ac0fa1d0Shannken }
150ac0fa1d0Shannken for (i = 0; i < sc->sc_numcpus; i++)
151ac0fa1d0Shannken sc->sc_sensordata[IBMHAWK_T_CPU+i].ihs_warnmax =
152ac0fa1d0Shannken resp.ihr_t_warn_thr;
153ac0fa1d0Shannken if (ibmhawk_request(sc, IHR_VOLT_THR, &resp)) {
154ac0fa1d0Shannken aprint_error_dev(sc->sc_dev, "volt threshold query failed\n");
155ac0fa1d0Shannken return;
156ac0fa1d0Shannken }
157ac0fa1d0Shannken for (i = 0; i < IBMHAWK_MAX_VOLTAGE; i++) {
158ac0fa1d0Shannken sc->sc_sensordata[IBMHAWK_V_VOLTAGE+i].ihs_warnmax =
159ac0fa1d0Shannken bswap16(resp.ihr_v_voltage_thr[i*2]);
160ac0fa1d0Shannken sc->sc_sensordata[IBMHAWK_V_VOLTAGE+i].ihs_warnmin =
161ac0fa1d0Shannken bswap16(resp.ihr_v_voltage_thr[i*2+1]);
162ac0fa1d0Shannken }
163ac0fa1d0Shannken if ((sc->sc_sme = sysmon_envsys_create()) == NULL) {
164ac0fa1d0Shannken aprint_error_dev(sc->sc_dev, "sysmon_envsys_create failed\n");
165ac0fa1d0Shannken return;
166ac0fa1d0Shannken }
167ac0fa1d0Shannken ibmhawk_refreshall(sc, true);
168ac0fa1d0Shannken sc->sc_sme->sme_name = device_xname(sc->sc_dev);
169ac0fa1d0Shannken sc->sc_sme->sme_cookie = sc;
170ac0fa1d0Shannken sc->sc_sme->sme_refresh = ibmhawk_refresh;
171ac0fa1d0Shannken sc->sc_sme->sme_get_limits = ibmhawk_get_limits;
172ac0fa1d0Shannken if (sysmon_envsys_register(sc->sc_sme)) {
173ac0fa1d0Shannken aprint_error_dev(sc->sc_dev, "sysmon_envsys_register failed\n");
174ac0fa1d0Shannken sysmon_envsys_destroy(sc->sc_sme);
175ac0fa1d0Shannken sc->sc_sme = NULL;
176ac0fa1d0Shannken return;
177ac0fa1d0Shannken }
178ac0fa1d0Shannken }
179ac0fa1d0Shannken
180ac0fa1d0Shannken static int
ibmhawk_detach(device_t self,int flags)181ac0fa1d0Shannken ibmhawk_detach(device_t self, int flags)
182ac0fa1d0Shannken {
183ac0fa1d0Shannken struct ibmhawk_softc *sc = device_private(self);
184ac0fa1d0Shannken
185ac0fa1d0Shannken if (sc->sc_sme)
186ac0fa1d0Shannken sysmon_envsys_destroy(sc->sc_sme);
187ac0fa1d0Shannken return 0;
188ac0fa1d0Shannken }
189ac0fa1d0Shannken
190ac0fa1d0Shannken
191ac0fa1d0Shannken /*
192ac0fa1d0Shannken * Compute the message checksum.
193ac0fa1d0Shannken */
194ac0fa1d0Shannken static uint8_t
ibmhawk_cksum(uint8_t * buf)195ac0fa1d0Shannken ibmhawk_cksum(uint8_t *buf)
196ac0fa1d0Shannken {
197ac0fa1d0Shannken int len = *buf++;
198ac0fa1d0Shannken int s = 0;
199ac0fa1d0Shannken
200ac0fa1d0Shannken while (--len > 0)
201ac0fa1d0Shannken s += *buf++;
202ac0fa1d0Shannken return -s;
203ac0fa1d0Shannken }
204ac0fa1d0Shannken
205ac0fa1d0Shannken /*
206ac0fa1d0Shannken * Request information from the management processor.
207ac0fa1d0Shannken * The response will be zeroed on error.
208ac0fa1d0Shannken * Request and response have the form <n> <data 0:n-2> <checksum>.
209ac0fa1d0Shannken */
210ac0fa1d0Shannken static int
ibmhawk_request(struct ibmhawk_softc * sc,uint8_t request,ibmhawk_response_t * response)211ac0fa1d0Shannken ibmhawk_request(struct ibmhawk_softc *sc, uint8_t request,
212ac0fa1d0Shannken ibmhawk_response_t *response)
213ac0fa1d0Shannken {
214c626b393Smaya int i, error, retries;
215ac0fa1d0Shannken uint8_t buf[sizeof(ibmhawk_response_t)+3], dummy;
216ac0fa1d0Shannken
217ac0fa1d0Shannken error = EIO; /* Fail until we have a valid response. */
218ac0fa1d0Shannken retries = 0;
219ac0fa1d0Shannken
220ac0fa1d0Shannken if (iic_acquire_bus(sc->sc_tag, 0))
221ac0fa1d0Shannken return error;
222ac0fa1d0Shannken
223ac0fa1d0Shannken again:
224ac0fa1d0Shannken memset(response, 0, sizeof(*response));
225ac0fa1d0Shannken
226ac0fa1d0Shannken /* Build and send the request. */
227ac0fa1d0Shannken buf[0] = 2;
228ac0fa1d0Shannken buf[1] = request;
229ac0fa1d0Shannken buf[2] = ibmhawk_cksum(buf);
230ac0fa1d0Shannken #if IBMHAWK_DEBUG > 1
231ac0fa1d0Shannken printf("[");
232ac0fa1d0Shannken for (i = 0; i < 3; i++)
233ac0fa1d0Shannken printf(" %02x", buf[i]);
234ac0fa1d0Shannken printf(" ]");
235ac0fa1d0Shannken #endif
236ac0fa1d0Shannken for (i = 0; i < 3; i++)
237ac0fa1d0Shannken if (iic_smbus_send_byte(sc->sc_tag, sc->sc_addr, buf[i], 0))
238ac0fa1d0Shannken goto bad;
239ac0fa1d0Shannken
240ac0fa1d0Shannken /* Receive and check the response. */
241ac0fa1d0Shannken #if IBMHAWK_DEBUG > 1
242ac0fa1d0Shannken printf(" => [");
243ac0fa1d0Shannken #endif
244ac0fa1d0Shannken if (iic_smbus_receive_byte(sc->sc_tag, sc->sc_addr, &buf[0], 0))
245ac0fa1d0Shannken goto bad;
246ac0fa1d0Shannken if (buf[0] == 0 || buf[0] == 255)
247ac0fa1d0Shannken goto bad;
248ac0fa1d0Shannken for (i = 1; i < buf[0]+1; i++)
249ac0fa1d0Shannken if (iic_smbus_receive_byte(sc->sc_tag, sc->sc_addr,
250ac0fa1d0Shannken (i < sizeof buf ? &buf[i] : &dummy), 0))
251ac0fa1d0Shannken goto bad;
252ac0fa1d0Shannken if (buf[0] >= sizeof(buf) || buf[1] != request ||
253ac0fa1d0Shannken ibmhawk_cksum(buf) != buf[buf[0]])
254ac0fa1d0Shannken goto bad;
255ac0fa1d0Shannken if (buf[0] > 2)
256ac0fa1d0Shannken memcpy(response, buf+2, buf[0]-2);
257ac0fa1d0Shannken error = 0;
258ac0fa1d0Shannken
259ac0fa1d0Shannken bad:
260ac0fa1d0Shannken #if IBMHAWK_DEBUG > 1
261a8a5c538Sriastradh for (i = 0; i < uimin(buf[0]+1, sizeof buf); i++)
262ac0fa1d0Shannken printf(" %02x", buf[i]);
263ac0fa1d0Shannken printf(" ] => %d\n", error);
264ac0fa1d0Shannken #endif
265ac0fa1d0Shannken if (error != 0 && retries++ < 3)
266ac0fa1d0Shannken goto again;
267ac0fa1d0Shannken
268ac0fa1d0Shannken iic_release_bus(sc->sc_tag, 0);
269ac0fa1d0Shannken return error;
270ac0fa1d0Shannken }
271ac0fa1d0Shannken
272ac0fa1d0Shannken static uint32_t
ibmhawk_normalize(int value,uint32_t units)273ac0fa1d0Shannken ibmhawk_normalize(int value, uint32_t units)
274ac0fa1d0Shannken {
275ac0fa1d0Shannken
276ac0fa1d0Shannken if (value == 0)
277ac0fa1d0Shannken return 0;
278ac0fa1d0Shannken
279ac0fa1d0Shannken switch (units) {
280ac0fa1d0Shannken case ENVSYS_STEMP:
281ac0fa1d0Shannken return 273150000+1000000*value;
282ac0fa1d0Shannken case ENVSYS_SVOLTS_DC:
283ac0fa1d0Shannken return 10000*value;
284ac0fa1d0Shannken default:
285ac0fa1d0Shannken return value;
286ac0fa1d0Shannken }
287ac0fa1d0Shannken }
288ac0fa1d0Shannken
289ac0fa1d0Shannken static void
ibmhawk_set(struct ibmhawk_softc * sc,int offset,int value,bool valid,bool create)290ac0fa1d0Shannken ibmhawk_set(struct ibmhawk_softc *sc,
291ac0fa1d0Shannken int offset, int value, bool valid, bool create)
292ac0fa1d0Shannken {
293ac0fa1d0Shannken int i;
294ac0fa1d0Shannken struct ibmhawk_sensordesc *sp;
295ac0fa1d0Shannken struct ibmhawk_sensordata *sd;
296ac0fa1d0Shannken envsys_data_t *dp;
297ac0fa1d0Shannken
298ac0fa1d0Shannken sd = &sc->sc_sensordata[offset];
299ac0fa1d0Shannken dp = &sd->ihs_edata;
300ac0fa1d0Shannken sp = NULL;
301ac0fa1d0Shannken if (create) {
302ac0fa1d0Shannken for (i = 0; i < ibmhawk_num_sensors; i++)
303ac0fa1d0Shannken if (ibmhawk_sensors[i].offset == offset) {
304ac0fa1d0Shannken sp = ibmhawk_sensors+i;
305ac0fa1d0Shannken break;
306ac0fa1d0Shannken }
307ac0fa1d0Shannken if (sp == NULL) {
308ac0fa1d0Shannken #if IBMHAWK_DEBUG > 0
309ac0fa1d0Shannken aprint_error_dev(sc->sc_dev,
310ac0fa1d0Shannken "offset %d: no sensor found\n", offset);
311ac0fa1d0Shannken #endif
312ac0fa1d0Shannken return;
313ac0fa1d0Shannken }
314ac0fa1d0Shannken strlcpy(dp->desc, sp->desc, sizeof(dp->desc));
315ac0fa1d0Shannken dp->units = sp->units;
316ac0fa1d0Shannken if (sd->ihs_warnmin != 0 || sd->ihs_warnmax != 0) {
317ac0fa1d0Shannken sd->ihs_warnmin =
318ac0fa1d0Shannken ibmhawk_normalize(sd->ihs_warnmin, dp->units);
319ac0fa1d0Shannken sd->ihs_warnmax =
320ac0fa1d0Shannken ibmhawk_normalize(sd->ihs_warnmax, dp->units);
321ac0fa1d0Shannken dp->flags |= ENVSYS_FMONLIMITS;
322ac0fa1d0Shannken }
323ac0fa1d0Shannken }
324ac0fa1d0Shannken
3255497d66fShannken if (valid) {
326ac0fa1d0Shannken dp->value_cur = ibmhawk_normalize(value, dp->units);
327ac0fa1d0Shannken dp->state = ENVSYS_SVALID;
3285497d66fShannken } else
3295497d66fShannken dp->state = ENVSYS_SINVALID;
3308c63bc3eShannken
3318c63bc3eShannken if (create) {
3328c63bc3eShannken if (sysmon_envsys_sensor_attach(sc->sc_sme, dp))
3338c63bc3eShannken aprint_error_dev(sc->sc_dev,
3348c63bc3eShannken "failed to attach \"%s\"\n", dp->desc);
3358c63bc3eShannken }
336ac0fa1d0Shannken }
337ac0fa1d0Shannken
338ac0fa1d0Shannken static void
ibmhawk_refreshall(struct ibmhawk_softc * sc,bool create)339ac0fa1d0Shannken ibmhawk_refreshall(struct ibmhawk_softc *sc, bool create)
340ac0fa1d0Shannken {
341ac0fa1d0Shannken int i;
342ac0fa1d0Shannken bool valid;
343ac0fa1d0Shannken ibmhawk_response_t resp;
344ac0fa1d0Shannken
345ac0fa1d0Shannken valid = (ibmhawk_request(sc, IHR_TEMP, &resp) == 0);
346ac0fa1d0Shannken ibmhawk_set(sc, IBMHAWK_T_AMBIENT, resp.ihr_t_ambient, valid, create);
347ac0fa1d0Shannken for (i = 0; i < sc->sc_numcpus; i++)
348ac0fa1d0Shannken ibmhawk_set(sc, IBMHAWK_T_CPU+i,
349ac0fa1d0Shannken resp.ihr_t_cpu[i], valid, create);
350ac0fa1d0Shannken
351ac0fa1d0Shannken valid = (ibmhawk_request(sc, IHR_FANRPM, &resp) == 0);
352ac0fa1d0Shannken for (i = 0; i < sc->sc_numfans; i++)
353ac0fa1d0Shannken ibmhawk_set(sc, IBMHAWK_F_FAN+i,
354ac0fa1d0Shannken bswap16(resp.ihr_fanrpm[i]), valid, create);
355ac0fa1d0Shannken
356ac0fa1d0Shannken valid = (ibmhawk_request(sc, IHR_VOLT, &resp) == 0);
357ac0fa1d0Shannken for (i = 0; i < IBMHAWK_MAX_VOLTAGE; i++)
358ac0fa1d0Shannken ibmhawk_set(sc, IBMHAWK_V_VOLTAGE+i,
359ac0fa1d0Shannken bswap16(resp.ihr_v_voltage[i]), valid, create);
360ac0fa1d0Shannken }
361ac0fa1d0Shannken
362ac0fa1d0Shannken static void
ibmhawk_refresh(struct sysmon_envsys * sme,envsys_data_t * edata)363ac0fa1d0Shannken ibmhawk_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
364ac0fa1d0Shannken {
365ac0fa1d0Shannken struct ibmhawk_softc *sc = sme->sme_cookie;
366ac0fa1d0Shannken
367ac0fa1d0Shannken /* No more than two refreshes per second. */
368*2d8f3966Smaxv if (getticks() - sc->sc_refresh < hz/2)
369ac0fa1d0Shannken return;
370ac0fa1d0Shannken #if IBMHAWK_DEBUG > 1
371ac0fa1d0Shannken aprint_normal_dev(sc->sc_dev, "refresh \"%s\" delta %d\n",
372*2d8f3966Smaxv edata->desc, getticks() - sc->sc_refresh);
373ac0fa1d0Shannken #endif
374*2d8f3966Smaxv sc->sc_refresh = getticks();
375ac0fa1d0Shannken ibmhawk_refreshall(sc, false);
376ac0fa1d0Shannken }
377ac0fa1d0Shannken
378ac0fa1d0Shannken static void
ibmhawk_get_limits(struct sysmon_envsys * sme,envsys_data_t * edata,sysmon_envsys_lim_t * limits,uint32_t * props)379ac0fa1d0Shannken ibmhawk_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
380ac0fa1d0Shannken sysmon_envsys_lim_t *limits, uint32_t *props)
381ac0fa1d0Shannken {
382ac0fa1d0Shannken struct ibmhawk_sensordata *sd = (struct ibmhawk_sensordata *)edata;
383ac0fa1d0Shannken
384ac0fa1d0Shannken if (sd->ihs_warnmin != 0) {
385ac0fa1d0Shannken limits->sel_warnmin = sd->ihs_warnmin;
386ac0fa1d0Shannken *props |= PROP_WARNMIN;
387ac0fa1d0Shannken }
388ac0fa1d0Shannken if (sd->ihs_warnmax != 0) {
389ac0fa1d0Shannken limits->sel_warnmax = sd->ihs_warnmax;
390ac0fa1d0Shannken *props |= PROP_WARNMAX;
391ac0fa1d0Shannken }
392ac0fa1d0Shannken }
393