1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2010 Andreas Tobler
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/param.h>
30 #include <sys/bus.h>
31 #include <sys/systm.h>
32 #include <sys/module.h>
33 #include <sys/callout.h>
34 #include <sys/conf.h>
35 #include <sys/cpu.h>
36 #include <sys/ctype.h>
37 #include <sys/kernel.h>
38 #include <sys/reboot.h>
39 #include <sys/rman.h>
40 #include <sys/sysctl.h>
41 #include <sys/limits.h>
42
43 #include <machine/bus.h>
44 #include <machine/md_var.h>
45
46 #include <dev/iicbus/iicbus.h>
47 #include <dev/iicbus/iiconf.h>
48
49 #include <dev/ofw/openfirm.h>
50 #include <dev/ofw/ofw_bus.h>
51 #include <powerpc/powermac/powermac_thermal.h>
52
53 /* FCU registers
54 * /u3@0,f8000000/i2c@f8001000/fan@15e
55 */
56 #define FCU_RPM_FAIL 0x0b /* fans states in bits 0<1-6>7 */
57 #define FCU_RPM_AVAILABLE 0x0c
58 #define FCU_RPM_ACTIVE 0x0d
59 #define FCU_RPM_READ(x) 0x11 + (x) * 2
60 #define FCU_RPM_SET(x) 0x10 + (x) * 2
61
62 #define FCU_PWM_FAIL 0x2b
63 #define FCU_PWM_AVAILABLE 0x2c
64 #define FCU_PWM_ACTIVE 0x2d
65 #define FCU_PWM_RPM(x) 0x31 + (x) * 2 /* Get RPM. */
66 #define FCU_PWM_SGET(x) 0x30 + (x) * 2 /* Set or get PWM. */
67
68 struct fcu_fan {
69 struct pmac_fan fan;
70 device_t dev;
71
72 int id;
73 enum {
74 FCU_FAN_RPM,
75 FCU_FAN_PWM
76 } type;
77 int setpoint;
78 int rpm;
79 };
80
81 struct fcu_softc {
82 device_t sc_dev;
83 struct intr_config_hook enum_hook;
84 uint32_t sc_addr;
85 struct fcu_fan *sc_fans;
86 int sc_nfans;
87 };
88
89 /* We can read the PWM and the RPM from a PWM controlled fan.
90 * Offer both values via sysctl.
91 */
92 enum {
93 FCU_PWM_SYSCTL_PWM = 1 << 8,
94 FCU_PWM_SYSCTL_RPM = 2 << 8
95 };
96
97 static int fcu_rpm_shift;
98
99 /* Regular bus attachment functions */
100 static int fcu_probe(device_t);
101 static int fcu_attach(device_t);
102
103 /* Utility functions */
104 static void fcu_attach_fans(device_t dev);
105 static int fcu_fill_fan_prop(device_t dev);
106 static int fcu_fan_set_rpm(struct fcu_fan *fan, int rpm);
107 static int fcu_fan_get_rpm(struct fcu_fan *fan);
108 static int fcu_fan_set_pwm(struct fcu_fan *fan, int pwm);
109 static int fcu_fan_get_pwm(device_t dev, struct fcu_fan *fan, int *pwm,
110 int *rpm);
111 static int fcu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS);
112 static void fcu_start(void *xdev);
113 static int fcu_write(device_t dev, uint32_t addr, uint8_t reg, uint8_t *buf,
114 int len);
115 static int fcu_read_1(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data);
116
117 static device_method_t fcu_methods[] = {
118 /* Device interface */
119 DEVMETHOD(device_probe, fcu_probe),
120 DEVMETHOD(device_attach, fcu_attach),
121 { 0, 0 },
122 };
123
124 static driver_t fcu_driver = {
125 "fcu",
126 fcu_methods,
127 sizeof(struct fcu_softc)
128 };
129
130 DRIVER_MODULE(fcu, iicbus, fcu_driver, 0, 0);
131 static MALLOC_DEFINE(M_FCU, "fcu", "FCU Sensor Information");
132
133 static int
fcu_write(device_t dev,uint32_t addr,uint8_t reg,uint8_t * buff,int len)134 fcu_write(device_t dev, uint32_t addr, uint8_t reg, uint8_t *buff,
135 int len)
136 {
137 unsigned char buf[4];
138 int try = 0;
139
140 struct iic_msg msg[] = {
141 { addr, IIC_M_WR, 0, buf }
142 };
143
144 msg[0].len = len + 1;
145 buf[0] = reg;
146 memcpy(buf + 1, buff, len);
147
148 for (;;)
149 {
150 if (iicbus_transfer(dev, msg, 1) == 0)
151 return (0);
152
153 if (++try > 5) {
154 device_printf(dev, "iicbus write failed\n");
155 return (-1);
156 }
157 pause("fcu_write", hz);
158 }
159 }
160
161 static int
fcu_read_1(device_t dev,uint32_t addr,uint8_t reg,uint8_t * data)162 fcu_read_1(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data)
163 {
164 uint8_t buf[4];
165 int err, try = 0;
166
167 struct iic_msg msg[2] = {
168 { addr, IIC_M_WR | IIC_M_NOSTOP, 1, ® },
169 { addr, IIC_M_RD, 1, buf },
170 };
171
172 for (;;)
173 {
174 err = iicbus_transfer(dev, msg, 2);
175 if (err != 0)
176 goto retry;
177
178 *data = *((uint8_t*)buf);
179 return (0);
180 retry:
181 if (++try > 5) {
182 device_printf(dev, "iicbus read failed\n");
183 return (-1);
184 }
185 pause("fcu_read_1", hz);
186 }
187 }
188
189 static int
fcu_probe(device_t dev)190 fcu_probe(device_t dev)
191 {
192 const char *name, *compatible;
193 struct fcu_softc *sc;
194
195 name = ofw_bus_get_name(dev);
196 compatible = ofw_bus_get_compat(dev);
197
198 if (!name)
199 return (ENXIO);
200
201 if (strcmp(name, "fan") != 0 || strcmp(compatible, "fcu") != 0)
202 return (ENXIO);
203
204 sc = device_get_softc(dev);
205 sc->sc_dev = dev;
206 sc->sc_addr = iicbus_get_addr(dev);
207
208 device_set_desc(dev, "Apple Fan Control Unit");
209
210 return (0);
211 }
212
213 static int
fcu_attach(device_t dev)214 fcu_attach(device_t dev)
215 {
216 struct fcu_softc *sc;
217
218 sc = device_get_softc(dev);
219
220 sc->enum_hook.ich_func = fcu_start;
221 sc->enum_hook.ich_arg = dev;
222
223 /* We have to wait until interrupts are enabled. I2C read and write
224 * only works if the interrupts are available.
225 * The unin/i2c is controlled by the htpic on unin. But this is not
226 * the master. The openpic on mac-io is controlling the htpic.
227 * This one gets attached after the mac-io probing and then the
228 * interrupts will be available.
229 */
230
231 if (config_intrhook_establish(&sc->enum_hook) != 0)
232 return (ENOMEM);
233
234 return (0);
235 }
236
237 static void
fcu_start(void * xdev)238 fcu_start(void *xdev)
239 {
240 unsigned char buf[1] = { 0xff };
241 struct fcu_softc *sc;
242
243 device_t dev = (device_t)xdev;
244
245 sc = device_get_softc(dev);
246
247 /* Start the fcu device. */
248 fcu_write(sc->sc_dev, sc->sc_addr, 0xe, buf, 1);
249 fcu_write(sc->sc_dev, sc->sc_addr, 0x2e, buf, 1);
250 fcu_read_1(sc->sc_dev, sc->sc_addr, 0, buf);
251 fcu_rpm_shift = (buf[0] == 1) ? 2 : 3;
252
253 device_printf(dev, "FCU initialized, RPM shift: %d\n",
254 fcu_rpm_shift);
255
256 /* Detect and attach child devices. */
257
258 fcu_attach_fans(dev);
259
260 config_intrhook_disestablish(&sc->enum_hook);
261
262 }
263
264 static int
fcu_fan_set_rpm(struct fcu_fan * fan,int rpm)265 fcu_fan_set_rpm(struct fcu_fan *fan, int rpm)
266 {
267 uint8_t reg;
268 struct fcu_softc *sc;
269 unsigned char buf[2];
270
271 sc = device_get_softc(fan->dev);
272
273 /* Clamp to allowed range */
274 rpm = max(fan->fan.min_rpm, rpm);
275 rpm = min(fan->fan.max_rpm, rpm);
276
277 if (fan->type == FCU_FAN_RPM) {
278 reg = FCU_RPM_SET(fan->id);
279 fan->setpoint = rpm;
280 } else {
281 device_printf(fan->dev, "Unknown fan type: %d\n", fan->type);
282 return (ENXIO);
283 }
284
285 buf[0] = rpm >> (8 - fcu_rpm_shift);
286 buf[1] = rpm << fcu_rpm_shift;
287
288 if (fcu_write(sc->sc_dev, sc->sc_addr, reg, buf, 2) < 0)
289 return (EIO);
290
291 return (0);
292 }
293
294 static int
fcu_fan_get_rpm(struct fcu_fan * fan)295 fcu_fan_get_rpm(struct fcu_fan *fan)
296 {
297 uint8_t reg;
298 struct fcu_softc *sc;
299 uint8_t buff[2] = { 0, 0 };
300 uint8_t active = 0, avail = 0, fail = 0;
301 int rpm;
302
303 sc = device_get_softc(fan->dev);
304
305 if (fan->type == FCU_FAN_RPM) {
306 /* Check if the fan is available. */
307 reg = FCU_RPM_AVAILABLE;
308 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &avail) < 0)
309 return (-1);
310 if ((avail & (1 << fan->id)) == 0) {
311 device_printf(fan->dev,
312 "RPM Fan not available ID: %d\n", fan->id);
313 return (-1);
314 }
315 /* Check if we have a failed fan. */
316 reg = FCU_RPM_FAIL;
317 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &fail) < 0)
318 return (-1);
319 if ((fail & (1 << fan->id)) != 0) {
320 device_printf(fan->dev,
321 "RPM Fan failed ID: %d\n", fan->id);
322 return (-1);
323 }
324 /* Check if fan is active. */
325 reg = FCU_RPM_ACTIVE;
326 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &active) < 0)
327 return (-1);
328 if ((active & (1 << fan->id)) == 0) {
329 device_printf(fan->dev, "RPM Fan not active ID: %d\n",
330 fan->id);
331 return (-1);
332 }
333 reg = FCU_RPM_READ(fan->id);
334
335 } else {
336 device_printf(fan->dev, "Unknown fan type: %d\n", fan->type);
337 return (-1);
338 }
339
340 /* It seems that we can read the fans rpm. */
341 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buff) < 0)
342 return (-1);
343
344 rpm = (buff[0] << (8 - fcu_rpm_shift)) | buff[1] >> fcu_rpm_shift;
345
346 return (rpm);
347 }
348
349 static int
fcu_fan_set_pwm(struct fcu_fan * fan,int pwm)350 fcu_fan_set_pwm(struct fcu_fan *fan, int pwm)
351 {
352 uint8_t reg;
353 struct fcu_softc *sc;
354 uint8_t buf[2];
355
356 sc = device_get_softc(fan->dev);
357
358 /* Clamp to allowed range */
359 pwm = max(fan->fan.min_rpm, pwm);
360 pwm = min(fan->fan.max_rpm, pwm);
361
362 if (fan->type == FCU_FAN_PWM) {
363 reg = FCU_PWM_SGET(fan->id);
364 if (pwm > 100)
365 pwm = 100;
366 if (pwm < 30)
367 pwm = 30;
368 fan->setpoint = pwm;
369 } else {
370 device_printf(fan->dev, "Unknown fan type: %d\n", fan->type);
371 return (EIO);
372 }
373
374 buf[0] = (pwm * 2550) / 1000;
375
376 if (fcu_write(sc->sc_dev, sc->sc_addr, reg, buf, 1) < 0)
377 return (EIO);
378 return (0);
379 }
380
381 static int
fcu_fan_get_pwm(device_t dev,struct fcu_fan * fan,int * pwm,int * rpm)382 fcu_fan_get_pwm(device_t dev, struct fcu_fan *fan, int *pwm, int *rpm)
383 {
384 uint8_t reg;
385 struct fcu_softc *sc;
386 uint8_t buf[2];
387 uint8_t active = 0, avail = 0, fail = 0;
388
389 sc = device_get_softc(dev);
390
391 if (fan->type == FCU_FAN_PWM) {
392 /* Check if the fan is available. */
393 reg = FCU_PWM_AVAILABLE;
394 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &avail) < 0)
395 return (-1);
396 if ((avail & (1 << fan->id)) == 0) {
397 device_printf(dev, "PWM Fan not available ID: %d\n",
398 fan->id);
399 return (-1);
400 }
401 /* Check if we have a failed fan. */
402 reg = FCU_PWM_FAIL;
403 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &fail) < 0)
404 return (-1);
405 if ((fail & (1 << fan->id)) != 0) {
406 device_printf(dev, "PWM Fan failed ID: %d\n", fan->id);
407 return (-1);
408 }
409 /* Check if fan is active. */
410 reg = FCU_PWM_ACTIVE;
411 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, &active) < 0)
412 return (-1);
413 if ((active & (1 << fan->id)) == 0) {
414 device_printf(dev, "PWM Fan not active ID: %d\n",
415 fan->id);
416 return (-1);
417 }
418 reg = FCU_PWM_SGET(fan->id);
419 } else {
420 device_printf(dev, "Unknown fan type: %d\n", fan->type);
421 return (EIO);
422 }
423
424 /* It seems that we can read the fans pwm. */
425 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buf) < 0)
426 return (-1);
427
428 *pwm = (buf[0] * 1000) / 2550;
429
430 /* Now read the rpm. */
431 reg = FCU_PWM_RPM(fan->id);
432 if (fcu_read_1(sc->sc_dev, sc->sc_addr, reg, buf) < 0)
433 return (-1);
434
435 *rpm = (buf[0] << (8 - fcu_rpm_shift)) | buf[1] >> fcu_rpm_shift;
436
437 return (0);
438 }
439
440 /*
441 * This function returns the number of fans. If we call it the second time
442 * and we have allocated memory for sc->sc_fans, we fill in the properties.
443 */
444 static int
fcu_fill_fan_prop(device_t dev)445 fcu_fill_fan_prop(device_t dev)
446 {
447 phandle_t child;
448 struct fcu_softc *sc;
449 u_int id[12];
450 char location[144];
451 char type[96];
452 int i = 0, j, len = 0, prop_len, prev_len = 0;
453
454 sc = device_get_softc(dev);
455
456 child = ofw_bus_get_node(dev);
457
458 /* Fill the fan location property. */
459 prop_len = OF_getprop(child, "hwctrl-location", location,
460 sizeof(location));
461 while (len < prop_len) {
462 if (sc->sc_fans != NULL) {
463 strcpy(sc->sc_fans[i].fan.name, location + len);
464 }
465 prev_len = strlen(location + len) + 1;
466 len += prev_len;
467 i++;
468 }
469 if (sc->sc_fans == NULL)
470 return (i);
471
472 /* Fill the fan type property. */
473 len = 0;
474 i = 0;
475 prev_len = 0;
476 prop_len = OF_getprop(child, "hwctrl-type", type, sizeof(type));
477 while (len < prop_len) {
478 if (strcmp(type + len, "fan-rpm") == 0)
479 sc->sc_fans[i].type = FCU_FAN_RPM;
480 else
481 sc->sc_fans[i].type = FCU_FAN_PWM;
482 prev_len = strlen(type + len) + 1;
483 len += prev_len;
484 i++;
485 }
486
487 /* Fill the fan ID property. */
488 prop_len = OF_getprop(child, "hwctrl-id", id, sizeof(id));
489 for (j = 0; j < i; j++)
490 sc->sc_fans[j].id = ((id[j] >> 8) & 0x0f) % 8;
491
492 /* Fill the fan zone property. */
493 prop_len = OF_getprop(child, "hwctrl-zone", id, sizeof(id));
494 for (j = 0; j < i; j++)
495 sc->sc_fans[j].fan.zone = id[j];
496
497 /* Finish setting up fan properties */
498 for (j = 0; j < i; j++) {
499 sc->sc_fans[j].dev = sc->sc_dev;
500 if (sc->sc_fans[j].type == FCU_FAN_RPM) {
501 sc->sc_fans[j].fan.min_rpm = 4800 >> fcu_rpm_shift;
502 sc->sc_fans[j].fan.max_rpm = 56000 >> fcu_rpm_shift;
503 sc->sc_fans[j].setpoint =
504 fcu_fan_get_rpm(&sc->sc_fans[j]);
505 sc->sc_fans[j].fan.read =
506 (int (*)(struct pmac_fan *))(fcu_fan_get_rpm);
507 sc->sc_fans[j].fan.set =
508 (int (*)(struct pmac_fan *, int))(fcu_fan_set_rpm);
509 } else {
510 sc->sc_fans[j].fan.min_rpm = 30; /* Percent */
511 sc->sc_fans[j].fan.max_rpm = 100;
512 sc->sc_fans[j].fan.read = NULL;
513 sc->sc_fans[j].fan.set =
514 (int (*)(struct pmac_fan *, int))(fcu_fan_set_pwm);
515 }
516 sc->sc_fans[j].fan.default_rpm = sc->sc_fans[j].fan.max_rpm;
517 }
518
519 return (i);
520 }
521
522 static int
fcu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS)523 fcu_fanrpm_sysctl(SYSCTL_HANDLER_ARGS)
524 {
525 device_t fcu;
526 struct fcu_softc *sc;
527 struct fcu_fan *fan;
528 int rpm = 0, pwm = 0, error = 0;
529
530 fcu = arg1;
531 sc = device_get_softc(fcu);
532 fan = &sc->sc_fans[arg2 & 0x00ff];
533 if (fan->type == FCU_FAN_RPM) {
534 rpm = fcu_fan_get_rpm(fan);
535 if (rpm < 0)
536 return (EIO);
537 error = sysctl_handle_int(oidp, &rpm, 0, req);
538 } else {
539 error = fcu_fan_get_pwm(fcu, fan, &pwm, &rpm);
540 if (error < 0)
541 return (EIO);
542
543 switch (arg2 & 0xff00) {
544 case FCU_PWM_SYSCTL_PWM:
545 error = sysctl_handle_int(oidp, &pwm, 0, req);
546 break;
547 case FCU_PWM_SYSCTL_RPM:
548 error = sysctl_handle_int(oidp, &rpm, 0, req);
549 break;
550 default:
551 /* This should never happen */
552 return (EINVAL);
553 }
554 }
555
556 /* We can only read the RPM from a PWM controlled fan, so return. */
557 if ((arg2 & 0xff00) == FCU_PWM_SYSCTL_RPM)
558 return (0);
559
560 if (error || !req->newptr)
561 return (error);
562
563 if (fan->type == FCU_FAN_RPM)
564 return (fcu_fan_set_rpm(fan, rpm));
565 else
566 return (fcu_fan_set_pwm(fan, pwm));
567 }
568
569 static void
fcu_attach_fans(device_t dev)570 fcu_attach_fans(device_t dev)
571 {
572 struct fcu_softc *sc;
573 struct sysctl_oid *oid, *fanroot_oid;
574 struct sysctl_ctx_list *ctx;
575 char sysctl_name[32];
576 int i, j;
577
578 sc = device_get_softc(dev);
579
580 sc->sc_nfans = 0;
581
582 /* Count the actual number of fans. */
583 sc->sc_nfans = fcu_fill_fan_prop(dev);
584
585 device_printf(dev, "%d fans detected!\n", sc->sc_nfans);
586
587 if (sc->sc_nfans == 0) {
588 device_printf(dev, "WARNING: No fans detected!\n");
589 return;
590 }
591
592 sc->sc_fans = malloc(sc->sc_nfans * sizeof(struct fcu_fan), M_FCU,
593 M_WAITOK | M_ZERO);
594
595 ctx = device_get_sysctl_ctx(dev);
596 fanroot_oid = SYSCTL_ADD_NODE(ctx,
597 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "fans",
598 CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "FCU Fan Information");
599
600 /* Now we can fill the properties into the allocated struct. */
601 sc->sc_nfans = fcu_fill_fan_prop(dev);
602
603 /* Register fans with pmac_thermal */
604 for (i = 0; i < sc->sc_nfans; i++)
605 pmac_thermal_fan_register(&sc->sc_fans[i].fan);
606
607 /* Add sysctls for the fans. */
608 for (i = 0; i < sc->sc_nfans; i++) {
609 for (j = 0; j < strlen(sc->sc_fans[i].fan.name); j++) {
610 sysctl_name[j] = tolower(sc->sc_fans[i].fan.name[j]);
611 if (isspace(sysctl_name[j]))
612 sysctl_name[j] = '_';
613 }
614 sysctl_name[j] = 0;
615
616 if (sc->sc_fans[i].type == FCU_FAN_RPM) {
617 oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid),
618 OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE,
619 0, "Fan Information");
620 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
621 "minrpm", CTLFLAG_RD,
622 &(sc->sc_fans[i].fan.min_rpm), 0,
623 "Minimum allowed RPM");
624 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
625 "maxrpm", CTLFLAG_RD,
626 &(sc->sc_fans[i].fan.max_rpm), 0,
627 "Maximum allowed RPM");
628 /* I use i to pass the fan id. */
629 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
630 "rpm", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
631 dev, i, fcu_fanrpm_sysctl, "I", "Fan RPM");
632 } else {
633 fcu_fan_get_pwm(dev, &sc->sc_fans[i],
634 &sc->sc_fans[i].setpoint,
635 &sc->sc_fans[i].rpm);
636
637 oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(fanroot_oid),
638 OID_AUTO, sysctl_name, CTLFLAG_RD | CTLFLAG_MPSAFE,
639 0, "Fan Information");
640 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
641 "minpwm", CTLFLAG_RD,
642 &(sc->sc_fans[i].fan.min_rpm), 0,
643 "Minimum allowed PWM in %");
644 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
645 "maxpwm", CTLFLAG_RD,
646 &(sc->sc_fans[i].fan.max_rpm), 0,
647 "Maximum allowed PWM in %");
648 /* I use i to pass the fan id or'ed with the type
649 * of info I want to display/modify.
650 */
651 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
652 "pwm", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT,
653 dev, FCU_PWM_SYSCTL_PWM | i, fcu_fanrpm_sysctl, "I",
654 "Fan PWM in %");
655 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
656 "rpm", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
657 dev, FCU_PWM_SYSCTL_RPM | i, fcu_fanrpm_sysctl, "I",
658 "Fan RPM");
659 }
660 }
661
662 /* Dump fan location, type & RPM. */
663 if (bootverbose) {
664 device_printf(dev, "Fans\n");
665 for (i = 0; i < sc->sc_nfans; i++) {
666 device_printf(dev, "Location: %s type: %d ID: %d "
667 "RPM: %d\n", sc->sc_fans[i].fan.name,
668 sc->sc_fans[i].type, sc->sc_fans[i].id,
669 (sc->sc_fans[i].type == FCU_FAN_RPM) ?
670 sc->sc_fans[i].setpoint :
671 sc->sc_fans[i].rpm );
672 }
673 }
674 }
675