This source file includes following definitions.
- wf_fcu_release
- wf_fcu_fan_release
- wf_fcu_read_reg
- wf_fcu_write_reg
- wf_fcu_fan_set_rpm
- wf_fcu_fan_get_rpm
- wf_fcu_fan_set_pwm
- wf_fcu_fan_get_pwm
- wf_fcu_fan_min
- wf_fcu_fan_max
- wf_fcu_get_pump_minmax
- wf_fcu_get_rpmfan_minmax
- wf_fcu_add_fan
- wf_fcu_lookup_fans
- wf_fcu_default_fans
- wf_fcu_init_chip
- wf_fcu_probe
- wf_fcu_remove
1
2
3
4
5
6
7 #undef DEBUG
8
9 #include <linux/types.h>
10 #include <linux/errno.h>
11 #include <linux/kernel.h>
12 #include <linux/delay.h>
13 #include <linux/slab.h>
14 #include <linux/init.h>
15 #include <linux/wait.h>
16 #include <linux/i2c.h>
17 #include <asm/prom.h>
18 #include <asm/machdep.h>
19 #include <asm/io.h>
20 #include <asm/sections.h>
21
22 #include "windfarm.h"
23 #include "windfarm_mpu.h"
24
25 #define VERSION "1.0"
26
27 #ifdef DEBUG
28 #define DBG(args...) printk(args)
29 #else
30 #define DBG(args...) do { } while(0)
31 #endif
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 #define RPM_PID_USE_ACTUAL_SPEED 0
47
48
49 #define CPU_PUMP_OUTPUT_MAX 3200
50 #define CPU_PUMP_OUTPUT_MIN 1250
51
52 #define FCU_FAN_RPM 0
53 #define FCU_FAN_PWM 1
54
55 struct wf_fcu_priv {
56 struct kref ref;
57 struct i2c_client *i2c;
58 struct mutex lock;
59 struct list_head fan_list;
60 int rpm_shift;
61 };
62
63 struct wf_fcu_fan {
64 struct list_head link;
65 int id;
66 s32 min, max, target;
67 struct wf_fcu_priv *fcu_priv;
68 struct wf_control ctrl;
69 };
70
71 static void wf_fcu_release(struct kref *ref)
72 {
73 struct wf_fcu_priv *pv = container_of(ref, struct wf_fcu_priv, ref);
74
75 kfree(pv);
76 }
77
78 static void wf_fcu_fan_release(struct wf_control *ct)
79 {
80 struct wf_fcu_fan *fan = ct->priv;
81
82 kref_put(&fan->fcu_priv->ref, wf_fcu_release);
83 kfree(fan);
84 }
85
86 static int wf_fcu_read_reg(struct wf_fcu_priv *pv, int reg,
87 unsigned char *buf, int nb)
88 {
89 int tries, nr, nw;
90
91 mutex_lock(&pv->lock);
92
93 buf[0] = reg;
94 tries = 0;
95 for (;;) {
96 nw = i2c_master_send(pv->i2c, buf, 1);
97 if (nw > 0 || (nw < 0 && nw != -EIO) || tries >= 100)
98 break;
99 msleep(10);
100 ++tries;
101 }
102 if (nw <= 0) {
103 pr_err("Failure writing address to FCU: %d", nw);
104 nr = nw;
105 goto bail;
106 }
107 tries = 0;
108 for (;;) {
109 nr = i2c_master_recv(pv->i2c, buf, nb);
110 if (nr > 0 || (nr < 0 && nr != -ENODEV) || tries >= 100)
111 break;
112 msleep(10);
113 ++tries;
114 }
115 if (nr <= 0)
116 pr_err("wf_fcu: Failure reading data from FCU: %d", nw);
117 bail:
118 mutex_unlock(&pv->lock);
119 return nr;
120 }
121
122 static int wf_fcu_write_reg(struct wf_fcu_priv *pv, int reg,
123 const unsigned char *ptr, int nb)
124 {
125 int tries, nw;
126 unsigned char buf[16];
127
128 buf[0] = reg;
129 memcpy(buf+1, ptr, nb);
130 ++nb;
131 tries = 0;
132 for (;;) {
133 nw = i2c_master_send(pv->i2c, buf, nb);
134 if (nw > 0 || (nw < 0 && nw != -EIO) || tries >= 100)
135 break;
136 msleep(10);
137 ++tries;
138 }
139 if (nw < 0)
140 pr_err("wf_fcu: Failure writing to FCU: %d", nw);
141 return nw;
142 }
143
144 static int wf_fcu_fan_set_rpm(struct wf_control *ct, s32 value)
145 {
146 struct wf_fcu_fan *fan = ct->priv;
147 struct wf_fcu_priv *pv = fan->fcu_priv;
148 int rc, shift = pv->rpm_shift;
149 unsigned char buf[2];
150
151 if (value < fan->min)
152 value = fan->min;
153 if (value > fan->max)
154 value = fan->max;
155
156 fan->target = value;
157
158 buf[0] = value >> (8 - shift);
159 buf[1] = value << shift;
160 rc = wf_fcu_write_reg(pv, 0x10 + (fan->id * 2), buf, 2);
161 if (rc < 0)
162 return -EIO;
163 return 0;
164 }
165
166 static int wf_fcu_fan_get_rpm(struct wf_control *ct, s32 *value)
167 {
168 struct wf_fcu_fan *fan = ct->priv;
169 struct wf_fcu_priv *pv = fan->fcu_priv;
170 int rc, reg_base, shift = pv->rpm_shift;
171 unsigned char failure;
172 unsigned char active;
173 unsigned char buf[2];
174
175 rc = wf_fcu_read_reg(pv, 0xb, &failure, 1);
176 if (rc != 1)
177 return -EIO;
178 if ((failure & (1 << fan->id)) != 0)
179 return -EFAULT;
180 rc = wf_fcu_read_reg(pv, 0xd, &active, 1);
181 if (rc != 1)
182 return -EIO;
183 if ((active & (1 << fan->id)) == 0)
184 return -ENXIO;
185
186
187 #if RPM_PID_USE_ACTUAL_SPEED
188 reg_base = 0x11;
189 #else
190 reg_base = 0x10;
191 #endif
192 rc = wf_fcu_read_reg(pv, reg_base + (fan->id * 2), buf, 2);
193 if (rc != 2)
194 return -EIO;
195
196 *value = (buf[0] << (8 - shift)) | buf[1] >> shift;
197
198 return 0;
199 }
200
201 static int wf_fcu_fan_set_pwm(struct wf_control *ct, s32 value)
202 {
203 struct wf_fcu_fan *fan = ct->priv;
204 struct wf_fcu_priv *pv = fan->fcu_priv;
205 unsigned char buf[2];
206 int rc;
207
208 if (value < fan->min)
209 value = fan->min;
210 if (value > fan->max)
211 value = fan->max;
212
213 fan->target = value;
214
215 value = (value * 2559) / 1000;
216 buf[0] = value;
217 rc = wf_fcu_write_reg(pv, 0x30 + (fan->id * 2), buf, 1);
218 if (rc < 0)
219 return -EIO;
220 return 0;
221 }
222
223 static int wf_fcu_fan_get_pwm(struct wf_control *ct, s32 *value)
224 {
225 struct wf_fcu_fan *fan = ct->priv;
226 struct wf_fcu_priv *pv = fan->fcu_priv;
227 unsigned char failure;
228 unsigned char active;
229 unsigned char buf[2];
230 int rc;
231
232 rc = wf_fcu_read_reg(pv, 0x2b, &failure, 1);
233 if (rc != 1)
234 return -EIO;
235 if ((failure & (1 << fan->id)) != 0)
236 return -EFAULT;
237 rc = wf_fcu_read_reg(pv, 0x2d, &active, 1);
238 if (rc != 1)
239 return -EIO;
240 if ((active & (1 << fan->id)) == 0)
241 return -ENXIO;
242
243 rc = wf_fcu_read_reg(pv, 0x30 + (fan->id * 2), buf, 1);
244 if (rc != 1)
245 return -EIO;
246
247 *value = (((s32)buf[0]) * 1000) / 2559;
248
249 return 0;
250 }
251
252 static s32 wf_fcu_fan_min(struct wf_control *ct)
253 {
254 struct wf_fcu_fan *fan = ct->priv;
255
256 return fan->min;
257 }
258
259 static s32 wf_fcu_fan_max(struct wf_control *ct)
260 {
261 struct wf_fcu_fan *fan = ct->priv;
262
263 return fan->max;
264 }
265
266 static const struct wf_control_ops wf_fcu_fan_rpm_ops = {
267 .set_value = wf_fcu_fan_set_rpm,
268 .get_value = wf_fcu_fan_get_rpm,
269 .get_min = wf_fcu_fan_min,
270 .get_max = wf_fcu_fan_max,
271 .release = wf_fcu_fan_release,
272 .owner = THIS_MODULE,
273 };
274
275 static const struct wf_control_ops wf_fcu_fan_pwm_ops = {
276 .set_value = wf_fcu_fan_set_pwm,
277 .get_value = wf_fcu_fan_get_pwm,
278 .get_min = wf_fcu_fan_min,
279 .get_max = wf_fcu_fan_max,
280 .release = wf_fcu_fan_release,
281 .owner = THIS_MODULE,
282 };
283
284 static void wf_fcu_get_pump_minmax(struct wf_fcu_fan *fan)
285 {
286 const struct mpu_data *mpu = wf_get_mpu(0);
287 u16 pump_min = 0, pump_max = 0xffff;
288 u16 tmp[4];
289
290
291 if (mpu) {
292 memcpy(&tmp, mpu->processor_part_num, 8);
293 if (tmp[0] != 0xffff && tmp[1] != 0xffff) {
294 pump_min = max(pump_min, tmp[0]);
295 pump_max = min(pump_max, tmp[1]);
296 }
297 if (tmp[2] != 0xffff && tmp[3] != 0xffff) {
298 pump_min = max(pump_min, tmp[2]);
299 pump_max = min(pump_max, tmp[3]);
300 }
301 }
302
303
304
305
306
307 if (pump_min == pump_max || pump_min == 0 || pump_max == 0xffff) {
308 pump_min = CPU_PUMP_OUTPUT_MIN;
309 pump_max = CPU_PUMP_OUTPUT_MAX;
310 }
311
312 fan->min = pump_min;
313 fan->max = pump_max;
314
315 DBG("wf_fcu: pump min/max for %s set to: [%d..%d] RPM\n",
316 fan->ctrl.name, pump_min, pump_max);
317 }
318
319 static void wf_fcu_get_rpmfan_minmax(struct wf_fcu_fan *fan)
320 {
321 struct wf_fcu_priv *pv = fan->fcu_priv;
322 const struct mpu_data *mpu0 = wf_get_mpu(0);
323 const struct mpu_data *mpu1 = wf_get_mpu(1);
324
325
326 fan->min = 2400 >> pv->rpm_shift;
327 fan->max = 56000 >> pv->rpm_shift;
328
329
330 if (mpu0 && !strcmp(fan->ctrl.name, "cpu-front-fan-0")) {
331 fan->min = max(fan->min, (s32)mpu0->rminn_intake_fan);
332 fan->max = min(fan->max, (s32)mpu0->rmaxn_intake_fan);
333 goto bail;
334 }
335 if (mpu1 && !strcmp(fan->ctrl.name, "cpu-front-fan-1")) {
336 fan->min = max(fan->min, (s32)mpu1->rminn_intake_fan);
337 fan->max = min(fan->max, (s32)mpu1->rmaxn_intake_fan);
338 goto bail;
339 }
340 if (mpu0 && !strcmp(fan->ctrl.name, "cpu-rear-fan-0")) {
341 fan->min = max(fan->min, (s32)mpu0->rminn_exhaust_fan);
342 fan->max = min(fan->max, (s32)mpu0->rmaxn_exhaust_fan);
343 goto bail;
344 }
345 if (mpu1 && !strcmp(fan->ctrl.name, "cpu-rear-fan-1")) {
346 fan->min = max(fan->min, (s32)mpu1->rminn_exhaust_fan);
347 fan->max = min(fan->max, (s32)mpu1->rmaxn_exhaust_fan);
348 goto bail;
349 }
350
351 if (!strncmp(fan->ctrl.name, "cpu-fan", 7)) {
352 fan->min = max(fan->min, (s32)mpu0->rminn_intake_fan);
353 fan->max = min(fan->max, (s32)mpu0->rmaxn_intake_fan);
354 goto bail;
355 }
356 bail:
357 DBG("wf_fcu: fan min/max for %s set to: [%d..%d] RPM\n",
358 fan->ctrl.name, fan->min, fan->max);
359 }
360
361 static void wf_fcu_add_fan(struct wf_fcu_priv *pv, const char *name,
362 int type, int id)
363 {
364 struct wf_fcu_fan *fan;
365
366 fan = kzalloc(sizeof(*fan), GFP_KERNEL);
367 if (!fan)
368 return;
369 fan->fcu_priv = pv;
370 fan->id = id;
371 fan->ctrl.name = name;
372 fan->ctrl.priv = fan;
373
374
375
376
377 if (type == FCU_FAN_RPM) {
378 if (!strncmp(name, "cpu-pump", strlen("cpu-pump")))
379 wf_fcu_get_pump_minmax(fan);
380 else
381 wf_fcu_get_rpmfan_minmax(fan);
382 fan->ctrl.type = WF_CONTROL_RPM_FAN;
383 fan->ctrl.ops = &wf_fcu_fan_rpm_ops;
384 } else {
385 fan->min = 10;
386 fan->max = 100;
387 fan->ctrl.type = WF_CONTROL_PWM_FAN;
388 fan->ctrl.ops = &wf_fcu_fan_pwm_ops;
389 }
390
391 if (wf_register_control(&fan->ctrl)) {
392 pr_err("wf_fcu: Failed to register fan %s\n", name);
393 kfree(fan);
394 return;
395 }
396 list_add(&fan->link, &pv->fan_list);
397 kref_get(&pv->ref);
398 }
399
400 static void wf_fcu_lookup_fans(struct wf_fcu_priv *pv)
401 {
402
403
404
405 static const struct {
406 const char *dt_name;
407 const char *ct_name;
408 } loc_trans[] = {
409 { "BACKSIDE", "backside-fan", },
410 { "SYS CTRLR FAN", "backside-fan", },
411 { "DRIVE BAY", "drive-bay-fan", },
412 { "SLOT", "slots-fan", },
413 { "PCI FAN", "slots-fan", },
414 { "CPU A INTAKE", "cpu-front-fan-0", },
415 { "CPU A EXHAUST", "cpu-rear-fan-0", },
416 { "CPU B INTAKE", "cpu-front-fan-1", },
417 { "CPU B EXHAUST", "cpu-rear-fan-1", },
418 { "CPU A PUMP", "cpu-pump-0", },
419 { "CPU B PUMP", "cpu-pump-1", },
420 { "CPU A 1", "cpu-fan-a-0", },
421 { "CPU A 2", "cpu-fan-b-0", },
422 { "CPU A 3", "cpu-fan-c-0", },
423 { "CPU B 1", "cpu-fan-a-1", },
424 { "CPU B 2", "cpu-fan-b-1", },
425 { "CPU B 3", "cpu-fan-c-1", },
426 };
427 struct device_node *np, *fcu = pv->i2c->dev.of_node;
428 int i;
429
430 DBG("Looking up FCU controls in device-tree...\n");
431
432 for_each_child_of_node(fcu, np) {
433 int id, type = -1;
434 const char *loc;
435 const char *name;
436 const u32 *reg;
437
438 DBG(" control: %pOFn, type: %s\n", np, of_node_get_device_type(np));
439
440
441 if (of_node_is_type(np, "fan-rpm-control") ||
442 of_node_is_type(np, "fan-rpm"))
443 type = FCU_FAN_RPM;
444 if (of_node_is_type(np, "fan-pwm-control") ||
445 of_node_is_type(np, "fan-pwm"))
446 type = FCU_FAN_PWM;
447
448 if (type == -1)
449 continue;
450
451
452 loc = of_get_property(np, "location", NULL);
453 reg = of_get_property(np, "reg", NULL);
454 if (loc == NULL || reg == NULL)
455 continue;
456 DBG(" matching location: %s, reg: 0x%08x\n", loc, *reg);
457
458 for (i = 0; i < ARRAY_SIZE(loc_trans); i++) {
459 if (strncmp(loc, loc_trans[i].dt_name,
460 strlen(loc_trans[i].dt_name)))
461 continue;
462 name = loc_trans[i].ct_name;
463
464 DBG(" location match, name: %s\n", name);
465
466 if (type == FCU_FAN_RPM)
467 id = ((*reg) - 0x10) / 2;
468 else
469 id = ((*reg) - 0x30) / 2;
470 if (id > 7) {
471 pr_warning("wf_fcu: Can't parse "
472 "fan ID in device-tree for %pOF\n",
473 np);
474 break;
475 }
476 wf_fcu_add_fan(pv, name, type, id);
477 break;
478 }
479 }
480 }
481
482 static void wf_fcu_default_fans(struct wf_fcu_priv *pv)
483 {
484
485 if (!of_machine_is_compatible("PowerMac7,2"))
486 return;
487
488 wf_fcu_add_fan(pv, "backside-fan", FCU_FAN_PWM, 1);
489 wf_fcu_add_fan(pv, "drive-bay-fan", FCU_FAN_RPM, 2);
490 wf_fcu_add_fan(pv, "slots-fan", FCU_FAN_PWM, 2);
491 wf_fcu_add_fan(pv, "cpu-front-fan-0", FCU_FAN_RPM, 3);
492 wf_fcu_add_fan(pv, "cpu-rear-fan-0", FCU_FAN_RPM, 4);
493 wf_fcu_add_fan(pv, "cpu-front-fan-1", FCU_FAN_RPM, 5);
494 wf_fcu_add_fan(pv, "cpu-rear-fan-1", FCU_FAN_RPM, 6);
495 }
496
497 static int wf_fcu_init_chip(struct wf_fcu_priv *pv)
498 {
499 unsigned char buf = 0xff;
500 int rc;
501
502 rc = wf_fcu_write_reg(pv, 0xe, &buf, 1);
503 if (rc < 0)
504 return -EIO;
505 rc = wf_fcu_write_reg(pv, 0x2e, &buf, 1);
506 if (rc < 0)
507 return -EIO;
508 rc = wf_fcu_read_reg(pv, 0, &buf, 1);
509 if (rc < 0)
510 return -EIO;
511 pv->rpm_shift = (buf == 1) ? 2 : 3;
512
513 pr_debug("wf_fcu: FCU Initialized, RPM fan shift is %d\n",
514 pv->rpm_shift);
515
516 return 0;
517 }
518
519 static int wf_fcu_probe(struct i2c_client *client,
520 const struct i2c_device_id *id)
521 {
522 struct wf_fcu_priv *pv;
523
524 pv = kzalloc(sizeof(*pv), GFP_KERNEL);
525 if (!pv)
526 return -ENOMEM;
527
528 kref_init(&pv->ref);
529 mutex_init(&pv->lock);
530 INIT_LIST_HEAD(&pv->fan_list);
531 pv->i2c = client;
532
533
534
535
536
537 if (wf_fcu_init_chip(pv)) {
538 pr_err("wf_fcu: Initialization failed !\n");
539 kfree(pv);
540 return -ENXIO;
541 }
542
543
544 wf_fcu_lookup_fans(pv);
545
546
547
548
549
550 if (list_empty(&pv->fan_list))
551 wf_fcu_default_fans(pv);
552
553
554 if (list_empty(&pv->fan_list)) {
555 pr_err("wf_fcu: Failed to find fans for your machine\n");
556 kfree(pv);
557 return -ENODEV;
558 }
559
560 dev_set_drvdata(&client->dev, pv);
561
562 return 0;
563 }
564
565 static int wf_fcu_remove(struct i2c_client *client)
566 {
567 struct wf_fcu_priv *pv = dev_get_drvdata(&client->dev);
568 struct wf_fcu_fan *fan;
569
570 while (!list_empty(&pv->fan_list)) {
571 fan = list_first_entry(&pv->fan_list, struct wf_fcu_fan, link);
572 list_del(&fan->link);
573 wf_unregister_control(&fan->ctrl);
574 }
575 kref_put(&pv->ref, wf_fcu_release);
576 return 0;
577 }
578
579 static const struct i2c_device_id wf_fcu_id[] = {
580 { "MAC,fcu", 0 },
581 { }
582 };
583 MODULE_DEVICE_TABLE(i2c, wf_fcu_id);
584
585 static const struct of_device_id wf_fcu_of_id[] = {
586 { .compatible = "fcu", },
587 { }
588 };
589 MODULE_DEVICE_TABLE(of, wf_fcu_of_id);
590
591 static struct i2c_driver wf_fcu_driver = {
592 .driver = {
593 .name = "wf_fcu",
594 .of_match_table = wf_fcu_of_id,
595 },
596 .probe = wf_fcu_probe,
597 .remove = wf_fcu_remove,
598 .id_table = wf_fcu_id,
599 };
600
601 module_i2c_driver(wf_fcu_driver);
602
603 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
604 MODULE_DESCRIPTION("FCU control objects for PowerMacs thermal control");
605 MODULE_LICENSE("GPL");
606