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