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