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