]>
Commit | Line | Data |
---|---|---|
80ff974d ÉB |
1 | /* |
2 | * Windfarm PowerMac thermal control. iMac G5 iSight | |
3 | * | |
4 | * (c) Copyright 2007 Étienne Bersac <bersace@gmail.com> | |
5 | * | |
6 | * Bits & pieces from windfarm_pm81.c by (c) Copyright 2005 Benjamin | |
7 | * Herrenschmidt, IBM Corp. <benh@kernel.crashing.org> | |
8 | * | |
9 | * Released under the term of the GNU GPL v2. | |
10 | * | |
11 | * | |
12 | * | |
13 | * PowerMac12,1 | |
14 | * ============ | |
15 | * | |
16 | * | |
17 | * The algorithm used is the PID control algorithm, used the same way | |
18 | * the published Darwin code does, using the same values that are | |
19 | * present in the Darwin 8.10 snapshot property lists (note however | |
20 | * that none of the code has been re-used, it's a complete | |
21 | * re-implementation | |
22 | * | |
23 | * There is two models using PowerMac12,1. Model 2 is iMac G5 iSight | |
24 | * 17" while Model 3 is iMac G5 20". They do have both the same | |
25 | * controls with a tiny difference. The control-ids of hard-drive-fan | |
26 | * and cpu-fan is swapped. | |
27 | * | |
28 | * | |
29 | * Target Correction : | |
30 | * | |
31 | * controls have a target correction calculated as : | |
32 | * | |
33 | * new_min = ((((average_power * slope) >> 16) + offset) >> 16) + min_value | |
34 | * new_value = max(new_value, max(new_min, 0)) | |
35 | * | |
36 | * OD Fan control correction. | |
37 | * | |
38 | * # model_id: 2 | |
39 | * offset : -19563152 | |
40 | * slope : 1956315 | |
41 | * | |
42 | * # model_id: 3 | |
43 | * offset : -15650652 | |
44 | * slope : 1565065 | |
45 | * | |
46 | * HD Fan control correction. | |
47 | * | |
48 | * # model_id: 2 | |
49 | * offset : -15650652 | |
50 | * slope : 1565065 | |
51 | * | |
52 | * # model_id: 3 | |
53 | * offset : -19563152 | |
54 | * slope : 1956315 | |
55 | * | |
56 | * CPU Fan control correction. | |
57 | * | |
58 | * # model_id: 2 | |
59 | * offset : -25431900 | |
60 | * slope : 2543190 | |
61 | * | |
62 | * # model_id: 3 | |
63 | * offset : -15650652 | |
64 | * slope : 1565065 | |
65 | * | |
66 | * | |
67 | * Target rubber-banding : | |
68 | * | |
69 | * Some controls have a target correction which depends on another | |
70 | * control value. The correction is computed in the following way : | |
71 | * | |
72 | * new_min = ref_value * slope + offset | |
73 | * | |
74 | * ref_value is the value of the reference control. If new_min is | |
75 | * greater than 0, then we correct the target value using : | |
76 | * | |
77 | * new_target = max (new_target, new_min >> 16) | |
78 | * | |
79 | * | |
80 | * # model_id : 2 | |
81 | * control : cpu-fan | |
82 | * ref : optical-drive-fan | |
83 | * offset : -15650652 | |
84 | * slope : 1565065 | |
85 | * | |
86 | * # model_id : 3 | |
87 | * control : optical-drive-fan | |
88 | * ref : hard-drive-fan | |
89 | * offset : -32768000 | |
90 | * slope : 65536 | |
91 | * | |
92 | * | |
93 | * In order to have the moste efficient correction with those | |
94 | * dependencies, we must trigger HD loop before OD loop before CPU | |
95 | * loop. | |
96 | * | |
97 | * | |
98 | * The various control loops found in Darwin config file are: | |
99 | * | |
100 | * HD Fan control loop. | |
101 | * | |
102 | * # model_id: 2 | |
103 | * control : hard-drive-fan | |
104 | * sensor : hard-drive-temp | |
105 | * PID params : G_d = 0x00000000 | |
106 | * G_p = 0x002D70A3 | |
107 | * G_r = 0x00019999 | |
108 | * History = 2 entries | |
109 | * Input target = 0x370000 | |
110 | * Interval = 5s | |
111 | * | |
112 | * # model_id: 3 | |
113 | * control : hard-drive-fan | |
114 | * sensor : hard-drive-temp | |
115 | * PID params : G_d = 0x00000000 | |
116 | * G_p = 0x002170A3 | |
117 | * G_r = 0x00019999 | |
118 | * History = 2 entries | |
119 | * Input target = 0x370000 | |
120 | * Interval = 5s | |
121 | * | |
122 | * OD Fan control loop. | |
123 | * | |
124 | * # model_id: 2 | |
125 | * control : optical-drive-fan | |
126 | * sensor : optical-drive-temp | |
127 | * PID params : G_d = 0x00000000 | |
128 | * G_p = 0x001FAE14 | |
129 | * G_r = 0x00019999 | |
130 | * History = 2 entries | |
131 | * Input target = 0x320000 | |
132 | * Interval = 5s | |
133 | * | |
134 | * # model_id: 3 | |
135 | * control : optical-drive-fan | |
136 | * sensor : optical-drive-temp | |
137 | * PID params : G_d = 0x00000000 | |
138 | * G_p = 0x001FAE14 | |
139 | * G_r = 0x00019999 | |
140 | * History = 2 entries | |
141 | * Input target = 0x320000 | |
142 | * Interval = 5s | |
143 | * | |
144 | * GPU Fan control loop. | |
145 | * | |
146 | * # model_id: 2 | |
147 | * control : hard-drive-fan | |
148 | * sensor : gpu-temp | |
149 | * PID params : G_d = 0x00000000 | |
150 | * G_p = 0x002A6666 | |
151 | * G_r = 0x00019999 | |
152 | * History = 2 entries | |
153 | * Input target = 0x5A0000 | |
154 | * Interval = 5s | |
155 | * | |
156 | * # model_id: 3 | |
157 | * control : cpu-fan | |
158 | * sensor : gpu-temp | |
159 | * PID params : G_d = 0x00000000 | |
160 | * G_p = 0x0010CCCC | |
161 | * G_r = 0x00019999 | |
162 | * History = 2 entries | |
163 | * Input target = 0x500000 | |
164 | * Interval = 5s | |
165 | * | |
166 | * KODIAK (aka northbridge) Fan control loop. | |
167 | * | |
168 | * # model_id: 2 | |
169 | * control : optical-drive-fan | |
170 | * sensor : north-bridge-temp | |
171 | * PID params : G_d = 0x00000000 | |
172 | * G_p = 0x003BD70A | |
173 | * G_r = 0x00019999 | |
174 | * History = 2 entries | |
175 | * Input target = 0x550000 | |
176 | * Interval = 5s | |
177 | * | |
178 | * # model_id: 3 | |
179 | * control : hard-drive-fan | |
180 | * sensor : north-bridge-temp | |
181 | * PID params : G_d = 0x00000000 | |
182 | * G_p = 0x0030F5C2 | |
183 | * G_r = 0x00019999 | |
184 | * History = 2 entries | |
185 | * Input target = 0x550000 | |
186 | * Interval = 5s | |
187 | * | |
188 | * CPU Fan control loop. | |
189 | * | |
190 | * control : cpu-fan | |
191 | * sensors : cpu-temp, cpu-power | |
192 | * PID params : from SDB partition | |
193 | * | |
194 | * | |
195 | * CPU Slew control loop. | |
196 | * | |
197 | * control : cpufreq-clamp | |
198 | * sensor : cpu-temp | |
199 | * | |
200 | */ | |
201 | ||
202 | #undef DEBUG | |
203 | ||
204 | #include <linux/types.h> | |
205 | #include <linux/errno.h> | |
206 | #include <linux/kernel.h> | |
207 | #include <linux/delay.h> | |
208 | #include <linux/slab.h> | |
209 | #include <linux/init.h> | |
210 | #include <linux/spinlock.h> | |
211 | #include <linux/wait.h> | |
212 | #include <linux/kmod.h> | |
213 | #include <linux/device.h> | |
214 | #include <linux/platform_device.h> | |
215 | #include <asm/prom.h> | |
216 | #include <asm/machdep.h> | |
217 | #include <asm/io.h> | |
80ff974d ÉB |
218 | #include <asm/sections.h> |
219 | #include <asm/smu.h> | |
220 | ||
221 | #include "windfarm.h" | |
222 | #include "windfarm_pid.h" | |
223 | ||
224 | #define VERSION "0.3" | |
225 | ||
226 | static int pm121_mach_model; /* machine model id */ | |
227 | ||
228 | /* Controls & sensors */ | |
229 | static struct wf_sensor *sensor_cpu_power; | |
230 | static struct wf_sensor *sensor_cpu_temp; | |
231 | static struct wf_sensor *sensor_cpu_voltage; | |
232 | static struct wf_sensor *sensor_cpu_current; | |
233 | static struct wf_sensor *sensor_gpu_temp; | |
234 | static struct wf_sensor *sensor_north_bridge_temp; | |
235 | static struct wf_sensor *sensor_hard_drive_temp; | |
236 | static struct wf_sensor *sensor_optical_drive_temp; | |
237 | static struct wf_sensor *sensor_incoming_air_temp; /* unused ! */ | |
238 | ||
239 | enum { | |
240 | FAN_CPU, | |
241 | FAN_HD, | |
242 | FAN_OD, | |
243 | CPUFREQ, | |
244 | N_CONTROLS | |
245 | }; | |
246 | static struct wf_control *controls[N_CONTROLS] = {}; | |
247 | ||
248 | /* Set to kick the control loop into life */ | |
4f256d56 GS |
249 | static int pm121_all_controls_ok, pm121_all_sensors_ok; |
250 | static bool pm121_started; | |
80ff974d ÉB |
251 | |
252 | enum { | |
253 | FAILURE_FAN = 1 << 0, | |
254 | FAILURE_SENSOR = 1 << 1, | |
255 | FAILURE_OVERTEMP = 1 << 2 | |
256 | }; | |
257 | ||
258 | /* All sys loops. Note the HD before the OD loop in order to have it | |
259 | run before. */ | |
260 | enum { | |
261 | LOOP_GPU, /* control = hd or cpu, but luckily, | |
262 | it doesn't matter */ | |
263 | LOOP_HD, /* control = hd */ | |
264 | LOOP_KODIAK, /* control = hd or od */ | |
265 | LOOP_OD, /* control = od */ | |
266 | N_LOOPS | |
267 | }; | |
268 | ||
269 | static const char *loop_names[N_LOOPS] = { | |
270 | "GPU", | |
271 | "HD", | |
272 | "KODIAK", | |
273 | "OD", | |
274 | }; | |
275 | ||
276 | #define PM121_NUM_CONFIGS 2 | |
277 | ||
278 | static unsigned int pm121_failure_state; | |
279 | static int pm121_readjust, pm121_skipping; | |
4bb29711 | 280 | static bool pm121_overtemp; |
80ff974d ÉB |
281 | static s32 average_power; |
282 | ||
283 | struct pm121_correction { | |
284 | int offset; | |
285 | int slope; | |
286 | }; | |
287 | ||
288 | static struct pm121_correction corrections[N_CONTROLS][PM121_NUM_CONFIGS] = { | |
289 | /* FAN_OD */ | |
290 | { | |
291 | /* MODEL 2 */ | |
292 | { .offset = -19563152, | |
293 | .slope = 1956315 | |
294 | }, | |
295 | /* MODEL 3 */ | |
296 | { .offset = -15650652, | |
297 | .slope = 1565065 | |
298 | }, | |
299 | }, | |
300 | /* FAN_HD */ | |
301 | { | |
302 | /* MODEL 2 */ | |
303 | { .offset = -15650652, | |
304 | .slope = 1565065 | |
305 | }, | |
306 | /* MODEL 3 */ | |
307 | { .offset = -19563152, | |
308 | .slope = 1956315 | |
309 | }, | |
310 | }, | |
311 | /* FAN_CPU */ | |
312 | { | |
313 | /* MODEL 2 */ | |
314 | { .offset = -25431900, | |
315 | .slope = 2543190 | |
316 | }, | |
317 | /* MODEL 3 */ | |
318 | { .offset = -15650652, | |
319 | .slope = 1565065 | |
320 | }, | |
321 | }, | |
322 | /* CPUFREQ has no correction (and is not implemented at all) */ | |
323 | }; | |
324 | ||
325 | struct pm121_connection { | |
326 | unsigned int control_id; | |
327 | unsigned int ref_id; | |
328 | struct pm121_correction correction; | |
329 | }; | |
330 | ||
331 | static struct pm121_connection pm121_connections[] = { | |
332 | /* MODEL 2 */ | |
333 | { .control_id = FAN_CPU, | |
334 | .ref_id = FAN_OD, | |
335 | { .offset = -32768000, | |
336 | .slope = 65536 | |
337 | } | |
338 | }, | |
339 | /* MODEL 3 */ | |
340 | { .control_id = FAN_OD, | |
341 | .ref_id = FAN_HD, | |
342 | { .offset = -32768000, | |
343 | .slope = 65536 | |
344 | } | |
345 | }, | |
346 | }; | |
347 | ||
348 | /* pointer to the current model connection */ | |
349 | static struct pm121_connection *pm121_connection; | |
350 | ||
351 | /* | |
352 | * ****** System Fans Control Loop ****** | |
353 | * | |
354 | */ | |
355 | ||
356 | /* Since each loop handles only one control and we want to avoid | |
357 | * writing virtual control, we store the control correction with the | |
358 | * loop params. Some data are not set, there are common to all loop | |
359 | * and thus, hardcoded. | |
360 | */ | |
361 | struct pm121_sys_param { | |
362 | /* purely informative since we use mach_model-2 as index */ | |
363 | int model_id; | |
364 | struct wf_sensor **sensor; /* use sensor_id instead ? */ | |
365 | s32 gp, itarget; | |
366 | unsigned int control_id; | |
367 | }; | |
368 | ||
369 | static struct pm121_sys_param | |
370 | pm121_sys_all_params[N_LOOPS][PM121_NUM_CONFIGS] = { | |
371 | /* GPU Fan control loop */ | |
372 | { | |
373 | { .model_id = 2, | |
374 | .sensor = &sensor_gpu_temp, | |
375 | .gp = 0x002A6666, | |
376 | .itarget = 0x5A0000, | |
377 | .control_id = FAN_HD, | |
378 | }, | |
379 | { .model_id = 3, | |
380 | .sensor = &sensor_gpu_temp, | |
381 | .gp = 0x0010CCCC, | |
382 | .itarget = 0x500000, | |
383 | .control_id = FAN_CPU, | |
384 | }, | |
385 | }, | |
386 | /* HD Fan control loop */ | |
387 | { | |
388 | { .model_id = 2, | |
389 | .sensor = &sensor_hard_drive_temp, | |
390 | .gp = 0x002D70A3, | |
391 | .itarget = 0x370000, | |
392 | .control_id = FAN_HD, | |
393 | }, | |
394 | { .model_id = 3, | |
395 | .sensor = &sensor_hard_drive_temp, | |
396 | .gp = 0x002170A3, | |
397 | .itarget = 0x370000, | |
398 | .control_id = FAN_HD, | |
399 | }, | |
400 | }, | |
401 | /* KODIAK Fan control loop */ | |
402 | { | |
403 | { .model_id = 2, | |
404 | .sensor = &sensor_north_bridge_temp, | |
405 | .gp = 0x003BD70A, | |
406 | .itarget = 0x550000, | |
407 | .control_id = FAN_OD, | |
408 | }, | |
409 | { .model_id = 3, | |
410 | .sensor = &sensor_north_bridge_temp, | |
411 | .gp = 0x0030F5C2, | |
412 | .itarget = 0x550000, | |
413 | .control_id = FAN_HD, | |
414 | }, | |
415 | }, | |
416 | /* OD Fan control loop */ | |
417 | { | |
418 | { .model_id = 2, | |
419 | .sensor = &sensor_optical_drive_temp, | |
420 | .gp = 0x001FAE14, | |
421 | .itarget = 0x320000, | |
422 | .control_id = FAN_OD, | |
423 | }, | |
424 | { .model_id = 3, | |
425 | .sensor = &sensor_optical_drive_temp, | |
426 | .gp = 0x001FAE14, | |
427 | .itarget = 0x320000, | |
428 | .control_id = FAN_OD, | |
429 | }, | |
430 | }, | |
431 | }; | |
432 | ||
433 | /* the hardcoded values */ | |
434 | #define PM121_SYS_GD 0x00000000 | |
435 | #define PM121_SYS_GR 0x00019999 | |
436 | #define PM121_SYS_HISTORY_SIZE 2 | |
437 | #define PM121_SYS_INTERVAL 5 | |
438 | ||
439 | /* State data used by the system fans control loop | |
440 | */ | |
441 | struct pm121_sys_state { | |
442 | int ticks; | |
443 | s32 setpoint; | |
444 | struct wf_pid_state pid; | |
445 | }; | |
446 | ||
447 | struct pm121_sys_state *pm121_sys_state[N_LOOPS] = {}; | |
448 | ||
449 | /* | |
450 | * ****** CPU Fans Control Loop ****** | |
451 | * | |
452 | */ | |
453 | ||
454 | #define PM121_CPU_INTERVAL 1 | |
455 | ||
456 | /* State data used by the cpu fans control loop | |
457 | */ | |
458 | struct pm121_cpu_state { | |
459 | int ticks; | |
460 | s32 setpoint; | |
461 | struct wf_cpu_pid_state pid; | |
462 | }; | |
463 | ||
464 | static struct pm121_cpu_state *pm121_cpu_state; | |
465 | ||
466 | ||
467 | ||
468 | /* | |
469 | * ***** Implementation ***** | |
470 | * | |
471 | */ | |
472 | ||
473 | /* correction the value using the output-low-bound correction algo */ | |
474 | static s32 pm121_correct(s32 new_setpoint, | |
475 | unsigned int control_id, | |
476 | s32 min) | |
477 | { | |
478 | s32 new_min; | |
479 | struct pm121_correction *correction; | |
480 | correction = &corrections[control_id][pm121_mach_model - 2]; | |
481 | ||
482 | new_min = (average_power * correction->slope) >> 16; | |
483 | new_min += correction->offset; | |
484 | new_min = (new_min >> 16) + min; | |
485 | ||
732eacc0 | 486 | return max3(new_setpoint, new_min, 0); |
80ff974d ÉB |
487 | } |
488 | ||
489 | static s32 pm121_connect(unsigned int control_id, s32 setpoint) | |
490 | { | |
491 | s32 new_min, value, new_setpoint; | |
492 | ||
493 | if (pm121_connection->control_id == control_id) { | |
494 | controls[control_id]->ops->get_value(controls[control_id], | |
495 | &value); | |
496 | new_min = value * pm121_connection->correction.slope; | |
497 | new_min += pm121_connection->correction.offset; | |
498 | if (new_min > 0) { | |
499 | new_setpoint = max(setpoint, (new_min >> 16)); | |
500 | if (new_setpoint != setpoint) { | |
501 | pr_debug("pm121: %s depending on %s, " | |
502 | "corrected from %d to %d RPM\n", | |
503 | controls[control_id]->name, | |
504 | controls[pm121_connection->ref_id]->name, | |
505 | (int) setpoint, (int) new_setpoint); | |
506 | } | |
507 | } else | |
508 | new_setpoint = setpoint; | |
509 | } | |
510 | /* no connection */ | |
511 | else | |
512 | new_setpoint = setpoint; | |
513 | ||
514 | return new_setpoint; | |
515 | } | |
516 | ||
517 | /* FAN LOOPS */ | |
518 | static void pm121_create_sys_fans(int loop_id) | |
519 | { | |
520 | struct pm121_sys_param *param = NULL; | |
521 | struct wf_pid_param pid_param; | |
522 | struct wf_control *control = NULL; | |
523 | int i; | |
524 | ||
525 | /* First, locate the params for this model */ | |
526 | for (i = 0; i < PM121_NUM_CONFIGS; i++) { | |
527 | if (pm121_sys_all_params[loop_id][i].model_id == pm121_mach_model) { | |
528 | param = &(pm121_sys_all_params[loop_id][i]); | |
529 | break; | |
530 | } | |
531 | } | |
532 | ||
533 | /* No params found, put fans to max */ | |
534 | if (param == NULL) { | |
535 | printk(KERN_WARNING "pm121: %s fan config not found " | |
536 | " for this machine model\n", | |
537 | loop_names[loop_id]); | |
538 | goto fail; | |
539 | } | |
540 | ||
541 | control = controls[param->control_id]; | |
542 | ||
543 | /* Alloc & initialize state */ | |
544 | pm121_sys_state[loop_id] = kmalloc(sizeof(struct pm121_sys_state), | |
545 | GFP_KERNEL); | |
546 | if (pm121_sys_state[loop_id] == NULL) { | |
547 | printk(KERN_WARNING "pm121: Memory allocation error\n"); | |
548 | goto fail; | |
549 | } | |
550 | pm121_sys_state[loop_id]->ticks = 1; | |
551 | ||
552 | /* Fill PID params */ | |
553 | pid_param.gd = PM121_SYS_GD; | |
554 | pid_param.gp = param->gp; | |
555 | pid_param.gr = PM121_SYS_GR; | |
556 | pid_param.interval = PM121_SYS_INTERVAL; | |
557 | pid_param.history_len = PM121_SYS_HISTORY_SIZE; | |
558 | pid_param.itarget = param->itarget; | |
bd0c30e3 RS |
559 | if(control) |
560 | { | |
561 | pid_param.min = control->ops->get_min(control); | |
562 | pid_param.max = control->ops->get_max(control); | |
563 | } else { | |
564 | /* | |
565 | * This is probably not the right!? | |
566 | * Perhaps goto fail if control == NULL above? | |
567 | */ | |
568 | pid_param.min = 0; | |
569 | pid_param.max = 0; | |
570 | } | |
80ff974d ÉB |
571 | |
572 | wf_pid_init(&pm121_sys_state[loop_id]->pid, &pid_param); | |
573 | ||
574 | pr_debug("pm121: %s Fan control loop initialized.\n" | |
575 | " itarged=%d.%03d, min=%d RPM, max=%d RPM\n", | |
576 | loop_names[loop_id], FIX32TOPRINT(pid_param.itarget), | |
577 | pid_param.min, pid_param.max); | |
578 | return; | |
579 | ||
580 | fail: | |
581 | /* note that this is not optimal since another loop may still | |
582 | control the same control */ | |
583 | printk(KERN_WARNING "pm121: failed to set up %s loop " | |
584 | "setting \"%s\" to max speed.\n", | |
bd0c30e3 | 585 | loop_names[loop_id], control ? control->name : "uninitialized value"); |
80ff974d ÉB |
586 | |
587 | if (control) | |
588 | wf_control_set_max(control); | |
589 | } | |
590 | ||
591 | static void pm121_sys_fans_tick(int loop_id) | |
592 | { | |
593 | struct pm121_sys_param *param; | |
594 | struct pm121_sys_state *st; | |
595 | struct wf_sensor *sensor; | |
596 | struct wf_control *control; | |
597 | s32 temp, new_setpoint; | |
598 | int rc; | |
599 | ||
600 | param = &(pm121_sys_all_params[loop_id][pm121_mach_model-2]); | |
601 | st = pm121_sys_state[loop_id]; | |
602 | sensor = *(param->sensor); | |
603 | control = controls[param->control_id]; | |
604 | ||
605 | if (--st->ticks != 0) { | |
606 | if (pm121_readjust) | |
607 | goto readjust; | |
608 | return; | |
609 | } | |
610 | st->ticks = PM121_SYS_INTERVAL; | |
611 | ||
612 | rc = sensor->ops->get_value(sensor, &temp); | |
613 | if (rc) { | |
614 | printk(KERN_WARNING "windfarm: %s sensor error %d\n", | |
615 | sensor->name, rc); | |
616 | pm121_failure_state |= FAILURE_SENSOR; | |
617 | return; | |
618 | } | |
619 | ||
620 | pr_debug("pm121: %s Fan tick ! %s: %d.%03d\n", | |
621 | loop_names[loop_id], sensor->name, | |
622 | FIX32TOPRINT(temp)); | |
623 | ||
624 | new_setpoint = wf_pid_run(&st->pid, temp); | |
625 | ||
626 | /* correction */ | |
627 | new_setpoint = pm121_correct(new_setpoint, | |
628 | param->control_id, | |
629 | st->pid.param.min); | |
630 | /* linked corretion */ | |
631 | new_setpoint = pm121_connect(param->control_id, new_setpoint); | |
632 | ||
633 | if (new_setpoint == st->setpoint) | |
634 | return; | |
635 | st->setpoint = new_setpoint; | |
636 | pr_debug("pm121: %s corrected setpoint: %d RPM\n", | |
637 | control->name, (int)new_setpoint); | |
638 | readjust: | |
639 | if (control && pm121_failure_state == 0) { | |
640 | rc = control->ops->set_value(control, st->setpoint); | |
641 | if (rc) { | |
642 | printk(KERN_WARNING "windfarm: %s fan error %d\n", | |
643 | control->name, rc); | |
644 | pm121_failure_state |= FAILURE_FAN; | |
645 | } | |
646 | } | |
647 | } | |
648 | ||
649 | ||
650 | /* CPU LOOP */ | |
651 | static void pm121_create_cpu_fans(void) | |
652 | { | |
653 | struct wf_cpu_pid_param pid_param; | |
654 | const struct smu_sdbp_header *hdr; | |
655 | struct smu_sdbp_cpupiddata *piddata; | |
656 | struct smu_sdbp_fvt *fvt; | |
657 | struct wf_control *fan_cpu; | |
658 | s32 tmax, tdelta, maxpow, powadj; | |
659 | ||
660 | fan_cpu = controls[FAN_CPU]; | |
661 | ||
662 | /* First, locate the PID params in SMU SBD */ | |
663 | hdr = smu_get_sdb_partition(SMU_SDB_CPUPIDDATA_ID, NULL); | |
664 | if (hdr == 0) { | |
665 | printk(KERN_WARNING "pm121: CPU PID fan config not found.\n"); | |
666 | goto fail; | |
667 | } | |
668 | piddata = (struct smu_sdbp_cpupiddata *)&hdr[1]; | |
669 | ||
670 | /* Get the FVT params for operating point 0 (the only supported one | |
671 | * for now) in order to get tmax | |
672 | */ | |
673 | hdr = smu_get_sdb_partition(SMU_SDB_FVT_ID, NULL); | |
674 | if (hdr) { | |
675 | fvt = (struct smu_sdbp_fvt *)&hdr[1]; | |
676 | tmax = ((s32)fvt->maxtemp) << 16; | |
677 | } else | |
678 | tmax = 0x5e0000; /* 94 degree default */ | |
679 | ||
680 | /* Alloc & initialize state */ | |
681 | pm121_cpu_state = kmalloc(sizeof(struct pm121_cpu_state), | |
682 | GFP_KERNEL); | |
683 | if (pm121_cpu_state == NULL) | |
684 | goto fail; | |
685 | pm121_cpu_state->ticks = 1; | |
686 | ||
687 | /* Fill PID params */ | |
688 | pid_param.interval = PM121_CPU_INTERVAL; | |
689 | pid_param.history_len = piddata->history_len; | |
690 | if (pid_param.history_len > WF_CPU_PID_MAX_HISTORY) { | |
691 | printk(KERN_WARNING "pm121: History size overflow on " | |
692 | "CPU control loop (%d)\n", piddata->history_len); | |
693 | pid_param.history_len = WF_CPU_PID_MAX_HISTORY; | |
694 | } | |
695 | pid_param.gd = piddata->gd; | |
696 | pid_param.gp = piddata->gp; | |
697 | pid_param.gr = piddata->gr / pid_param.history_len; | |
698 | ||
699 | tdelta = ((s32)piddata->target_temp_delta) << 16; | |
700 | maxpow = ((s32)piddata->max_power) << 16; | |
701 | powadj = ((s32)piddata->power_adj) << 16; | |
702 | ||
703 | pid_param.tmax = tmax; | |
704 | pid_param.ttarget = tmax - tdelta; | |
705 | pid_param.pmaxadj = maxpow - powadj; | |
706 | ||
707 | pid_param.min = fan_cpu->ops->get_min(fan_cpu); | |
708 | pid_param.max = fan_cpu->ops->get_max(fan_cpu); | |
709 | ||
710 | wf_cpu_pid_init(&pm121_cpu_state->pid, &pid_param); | |
711 | ||
712 | pr_debug("pm121: CPU Fan control initialized.\n"); | |
942cc40a | 713 | pr_debug(" ttarget=%d.%03d, tmax=%d.%03d, min=%d RPM, max=%d RPM,\n", |
80ff974d ÉB |
714 | FIX32TOPRINT(pid_param.ttarget), FIX32TOPRINT(pid_param.tmax), |
715 | pid_param.min, pid_param.max); | |
716 | ||
717 | return; | |
718 | ||
719 | fail: | |
720 | printk(KERN_WARNING "pm121: CPU fan config not found, max fan speed\n"); | |
721 | ||
722 | if (controls[CPUFREQ]) | |
723 | wf_control_set_max(controls[CPUFREQ]); | |
724 | if (fan_cpu) | |
725 | wf_control_set_max(fan_cpu); | |
726 | } | |
727 | ||
728 | ||
729 | static void pm121_cpu_fans_tick(struct pm121_cpu_state *st) | |
730 | { | |
731 | s32 new_setpoint, temp, power; | |
732 | struct wf_control *fan_cpu = NULL; | |
733 | int rc; | |
734 | ||
735 | if (--st->ticks != 0) { | |
736 | if (pm121_readjust) | |
737 | goto readjust; | |
738 | return; | |
739 | } | |
740 | st->ticks = PM121_CPU_INTERVAL; | |
741 | ||
742 | fan_cpu = controls[FAN_CPU]; | |
743 | ||
744 | rc = sensor_cpu_temp->ops->get_value(sensor_cpu_temp, &temp); | |
745 | if (rc) { | |
746 | printk(KERN_WARNING "pm121: CPU temp sensor error %d\n", | |
747 | rc); | |
748 | pm121_failure_state |= FAILURE_SENSOR; | |
749 | return; | |
750 | } | |
751 | ||
752 | rc = sensor_cpu_power->ops->get_value(sensor_cpu_power, &power); | |
753 | if (rc) { | |
754 | printk(KERN_WARNING "pm121: CPU power sensor error %d\n", | |
755 | rc); | |
756 | pm121_failure_state |= FAILURE_SENSOR; | |
757 | return; | |
758 | } | |
759 | ||
760 | pr_debug("pm121: CPU Fans tick ! CPU temp: %d.%03d°C, power: %d.%03d\n", | |
761 | FIX32TOPRINT(temp), FIX32TOPRINT(power)); | |
762 | ||
763 | if (temp > st->pid.param.tmax) | |
764 | pm121_failure_state |= FAILURE_OVERTEMP; | |
765 | ||
766 | new_setpoint = wf_cpu_pid_run(&st->pid, power, temp); | |
767 | ||
768 | /* correction */ | |
769 | new_setpoint = pm121_correct(new_setpoint, | |
770 | FAN_CPU, | |
771 | st->pid.param.min); | |
772 | ||
773 | /* connected correction */ | |
774 | new_setpoint = pm121_connect(FAN_CPU, new_setpoint); | |
775 | ||
776 | if (st->setpoint == new_setpoint) | |
777 | return; | |
778 | st->setpoint = new_setpoint; | |
779 | pr_debug("pm121: CPU corrected setpoint: %d RPM\n", (int)new_setpoint); | |
780 | ||
781 | readjust: | |
782 | if (fan_cpu && pm121_failure_state == 0) { | |
783 | rc = fan_cpu->ops->set_value(fan_cpu, st->setpoint); | |
784 | if (rc) { | |
785 | printk(KERN_WARNING "pm121: %s fan error %d\n", | |
786 | fan_cpu->name, rc); | |
787 | pm121_failure_state |= FAILURE_FAN; | |
788 | } | |
789 | } | |
790 | } | |
791 | ||
792 | /* | |
793 | * ****** Common ****** | |
794 | * | |
795 | */ | |
796 | ||
797 | static void pm121_tick(void) | |
798 | { | |
799 | unsigned int last_failure = pm121_failure_state; | |
800 | unsigned int new_failure; | |
801 | s32 total_power; | |
802 | int i; | |
803 | ||
804 | if (!pm121_started) { | |
805 | pr_debug("pm121: creating control loops !\n"); | |
806 | for (i = 0; i < N_LOOPS; i++) | |
807 | pm121_create_sys_fans(i); | |
808 | ||
809 | pm121_create_cpu_fans(); | |
4f256d56 | 810 | pm121_started = true; |
80ff974d ÉB |
811 | } |
812 | ||
813 | /* skipping ticks */ | |
814 | if (pm121_skipping && --pm121_skipping) | |
815 | return; | |
816 | ||
817 | /* compute average power */ | |
818 | total_power = 0; | |
819 | for (i = 0; i < pm121_cpu_state->pid.param.history_len; i++) | |
820 | total_power += pm121_cpu_state->pid.powers[i]; | |
821 | ||
822 | average_power = total_power / pm121_cpu_state->pid.param.history_len; | |
823 | ||
824 | ||
825 | pm121_failure_state = 0; | |
826 | for (i = 0 ; i < N_LOOPS; i++) { | |
827 | if (pm121_sys_state[i]) | |
828 | pm121_sys_fans_tick(i); | |
829 | } | |
830 | ||
831 | if (pm121_cpu_state) | |
832 | pm121_cpu_fans_tick(pm121_cpu_state); | |
833 | ||
834 | pm121_readjust = 0; | |
835 | new_failure = pm121_failure_state & ~last_failure; | |
836 | ||
837 | /* If entering failure mode, clamp cpufreq and ramp all | |
838 | * fans to full speed. | |
839 | */ | |
840 | if (pm121_failure_state && !last_failure) { | |
841 | for (i = 0; i < N_CONTROLS; i++) { | |
842 | if (controls[i]) | |
843 | wf_control_set_max(controls[i]); | |
844 | } | |
845 | } | |
846 | ||
847 | /* If leaving failure mode, unclamp cpufreq and readjust | |
848 | * all fans on next iteration | |
849 | */ | |
850 | if (!pm121_failure_state && last_failure) { | |
851 | if (controls[CPUFREQ]) | |
852 | wf_control_set_min(controls[CPUFREQ]); | |
853 | pm121_readjust = 1; | |
854 | } | |
855 | ||
856 | /* Overtemp condition detected, notify and start skipping a couple | |
857 | * ticks to let the temperature go down | |
858 | */ | |
859 | if (new_failure & FAILURE_OVERTEMP) { | |
860 | wf_set_overtemp(); | |
861 | pm121_skipping = 2; | |
4bb29711 | 862 | pm121_overtemp = true; |
80ff974d ÉB |
863 | } |
864 | ||
865 | /* We only clear the overtemp condition if overtemp is cleared | |
866 | * _and_ no other failure is present. Since a sensor error will | |
867 | * clear the overtemp condition (can't measure temperature) at | |
868 | * the control loop levels, but we don't want to keep it clear | |
869 | * here in this case | |
870 | */ | |
4bb29711 | 871 | if (!pm121_failure_state && pm121_overtemp) { |
80ff974d | 872 | wf_clear_overtemp(); |
4bb29711 AK |
873 | pm121_overtemp = false; |
874 | } | |
80ff974d ÉB |
875 | } |
876 | ||
877 | ||
878 | static struct wf_control* pm121_register_control(struct wf_control *ct, | |
879 | const char *match, | |
880 | unsigned int id) | |
881 | { | |
882 | if (controls[id] == NULL && !strcmp(ct->name, match)) { | |
883 | if (wf_get_control(ct) == 0) | |
884 | controls[id] = ct; | |
885 | } | |
886 | return controls[id]; | |
887 | } | |
888 | ||
889 | static void pm121_new_control(struct wf_control *ct) | |
890 | { | |
891 | int all = 1; | |
892 | ||
893 | if (pm121_all_controls_ok) | |
894 | return; | |
895 | ||
896 | all = pm121_register_control(ct, "optical-drive-fan", FAN_OD) && all; | |
897 | all = pm121_register_control(ct, "hard-drive-fan", FAN_HD) && all; | |
898 | all = pm121_register_control(ct, "cpu-fan", FAN_CPU) && all; | |
899 | all = pm121_register_control(ct, "cpufreq-clamp", CPUFREQ) && all; | |
900 | ||
901 | if (all) | |
902 | pm121_all_controls_ok = 1; | |
903 | } | |
904 | ||
905 | ||
906 | ||
907 | ||
908 | static struct wf_sensor* pm121_register_sensor(struct wf_sensor *sensor, | |
909 | const char *match, | |
910 | struct wf_sensor **var) | |
911 | { | |
912 | if (*var == NULL && !strcmp(sensor->name, match)) { | |
913 | if (wf_get_sensor(sensor) == 0) | |
914 | *var = sensor; | |
915 | } | |
916 | return *var; | |
917 | } | |
918 | ||
919 | static void pm121_new_sensor(struct wf_sensor *sr) | |
920 | { | |
921 | int all = 1; | |
922 | ||
923 | if (pm121_all_sensors_ok) | |
924 | return; | |
925 | ||
926 | all = pm121_register_sensor(sr, "cpu-temp", | |
927 | &sensor_cpu_temp) && all; | |
928 | all = pm121_register_sensor(sr, "cpu-current", | |
929 | &sensor_cpu_current) && all; | |
930 | all = pm121_register_sensor(sr, "cpu-voltage", | |
931 | &sensor_cpu_voltage) && all; | |
932 | all = pm121_register_sensor(sr, "cpu-power", | |
933 | &sensor_cpu_power) && all; | |
934 | all = pm121_register_sensor(sr, "hard-drive-temp", | |
935 | &sensor_hard_drive_temp) && all; | |
936 | all = pm121_register_sensor(sr, "optical-drive-temp", | |
937 | &sensor_optical_drive_temp) && all; | |
938 | all = pm121_register_sensor(sr, "incoming-air-temp", | |
939 | &sensor_incoming_air_temp) && all; | |
940 | all = pm121_register_sensor(sr, "north-bridge-temp", | |
941 | &sensor_north_bridge_temp) && all; | |
942 | all = pm121_register_sensor(sr, "gpu-temp", | |
943 | &sensor_gpu_temp) && all; | |
944 | ||
945 | if (all) | |
946 | pm121_all_sensors_ok = 1; | |
947 | } | |
948 | ||
949 | ||
950 | ||
951 | static int pm121_notify(struct notifier_block *self, | |
952 | unsigned long event, void *data) | |
953 | { | |
954 | switch (event) { | |
955 | case WF_EVENT_NEW_CONTROL: | |
956 | pr_debug("pm121: new control %s detected\n", | |
957 | ((struct wf_control *)data)->name); | |
958 | pm121_new_control(data); | |
959 | break; | |
960 | case WF_EVENT_NEW_SENSOR: | |
961 | pr_debug("pm121: new sensor %s detected\n", | |
962 | ((struct wf_sensor *)data)->name); | |
963 | pm121_new_sensor(data); | |
964 | break; | |
965 | case WF_EVENT_TICK: | |
966 | if (pm121_all_controls_ok && pm121_all_sensors_ok) | |
967 | pm121_tick(); | |
968 | break; | |
969 | } | |
970 | ||
971 | return 0; | |
972 | } | |
973 | ||
974 | static struct notifier_block pm121_events = { | |
975 | .notifier_call = pm121_notify, | |
976 | }; | |
977 | ||
978 | static int pm121_init_pm(void) | |
979 | { | |
980 | const struct smu_sdbp_header *hdr; | |
981 | ||
982 | hdr = smu_get_sdb_partition(SMU_SDB_SENSORTREE_ID, NULL); | |
983 | if (hdr != 0) { | |
984 | struct smu_sdbp_sensortree *st = | |
985 | (struct smu_sdbp_sensortree *)&hdr[1]; | |
986 | pm121_mach_model = st->model_id; | |
987 | } | |
988 | ||
989 | pm121_connection = &pm121_connections[pm121_mach_model - 2]; | |
990 | ||
991 | printk(KERN_INFO "pm121: Initializing for iMac G5 iSight model ID %d\n", | |
992 | pm121_mach_model); | |
993 | ||
994 | return 0; | |
995 | } | |
996 | ||
997 | ||
998 | static int pm121_probe(struct platform_device *ddev) | |
999 | { | |
1000 | wf_register_client(&pm121_events); | |
1001 | ||
1002 | return 0; | |
1003 | } | |
1004 | ||
1da42fb6 | 1005 | static int pm121_remove(struct platform_device *ddev) |
80ff974d ÉB |
1006 | { |
1007 | wf_unregister_client(&pm121_events); | |
1008 | return 0; | |
1009 | } | |
1010 | ||
1011 | static struct platform_driver pm121_driver = { | |
1012 | .probe = pm121_probe, | |
1da42fb6 | 1013 | .remove = pm121_remove, |
80ff974d ÉB |
1014 | .driver = { |
1015 | .name = "windfarm", | |
1016 | .bus = &platform_bus_type, | |
1017 | }, | |
1018 | }; | |
1019 | ||
1020 | ||
1021 | static int __init pm121_init(void) | |
1022 | { | |
1023 | int rc = -ENODEV; | |
1024 | ||
71a157e8 | 1025 | if (of_machine_is_compatible("PowerMac12,1")) |
80ff974d ÉB |
1026 | rc = pm121_init_pm(); |
1027 | ||
1028 | if (rc == 0) { | |
1029 | request_module("windfarm_smu_controls"); | |
1030 | request_module("windfarm_smu_sensors"); | |
1031 | request_module("windfarm_smu_sat"); | |
1032 | request_module("windfarm_lm75_sensor"); | |
1033 | request_module("windfarm_max6690_sensor"); | |
1034 | request_module("windfarm_cpufreq_clamp"); | |
1035 | platform_driver_register(&pm121_driver); | |
1036 | } | |
1037 | ||
1038 | return rc; | |
1039 | } | |
1040 | ||
1041 | static void __exit pm121_exit(void) | |
1042 | { | |
1043 | ||
1044 | platform_driver_unregister(&pm121_driver); | |
1045 | } | |
1046 | ||
1047 | ||
1048 | module_init(pm121_init); | |
1049 | module_exit(pm121_exit); | |
1050 | ||
1051 | MODULE_AUTHOR("Étienne Bersac <bersace@gmail.com>"); | |
1052 | MODULE_DESCRIPTION("Thermal control logic for iMac G5 (iSight)"); | |
1053 | MODULE_LICENSE("GPL"); | |
1054 |