[PATCH] more kernel_execve() fallout (sbus)
[sfrench/cifs-2.6.git] / drivers / sbus / char / bbc_envctrl.c
1 /* $Id: bbc_envctrl.c,v 1.4 2001/04/06 16:48:08 davem Exp $
2  * bbc_envctrl.c: UltraSPARC-III environment control driver.
3  *
4  * Copyright (C) 2001 David S. Miller (davem@redhat.com)
5  */
6
7 #include <linux/kthread.h>
8 #include <linux/syscalls.h>
9 #include <linux/delay.h>
10 #include <asm/oplib.h>
11 #include <asm/ebus.h>
12
13 #include "bbc_i2c.h"
14 #include "max1617.h"
15
16 #undef ENVCTRL_TRACE
17
18 /* WARNING: Making changes to this driver is very dangerous.
19  *          If you misprogram the sensor chips they can
20  *          cut the power on you instantly.
21  */
22
23 /* Two temperature sensors exist in the SunBLADE-1000 enclosure.
24  * Both are implemented using max1617 i2c devices.  Each max1617
25  * monitors 2 temperatures, one for one of the cpu dies and the other
26  * for the ambient temperature.
27  *
28  * The max1617 is capable of being programmed with power-off
29  * temperature values, one low limit and one high limit.  These
30  * can be controlled independently for the cpu or ambient temperature.
31  * If a limit is violated, the power is simply shut off.  The frequency
32  * with which the max1617 does temperature sampling can be controlled
33  * as well.
34  *
35  * Three fans exist inside the machine, all three are controlled with
36  * an i2c digital to analog converter.  There is a fan directed at the
37  * two processor slots, another for the rest of the enclosure, and the
38  * third is for the power supply.  The first two fans may be speed
39  * controlled by changing the voltage fed to them.  The third fan may
40  * only be completely off or on.  The third fan is meant to only be
41  * disabled/enabled when entering/exiting the lowest power-saving
42  * mode of the machine.
43  *
44  * An environmental control kernel thread periodically monitors all
45  * temperature sensors.  Based upon the samples it will adjust the
46  * fan speeds to try and keep the system within a certain temperature
47  * range (the goal being to make the fans as quiet as possible without
48  * allowing the system to get too hot).
49  *
50  * If the temperature begins to rise/fall outside of the acceptable
51  * operating range, a periodic warning will be sent to the kernel log.
52  * The fans will be put on full blast to attempt to deal with this
53  * situation.  After exceeding the acceptable operating range by a
54  * certain threshold, the kernel thread will shut down the system.
55  * Here, the thread is attempting to shut the machine down cleanly
56  * before the hardware based power-off event is triggered.
57  */
58
59 /* These settings are in Celsius.  We use these defaults only
60  * if we cannot interrogate the cpu-fru SEEPROM.
61  */
62 struct temp_limits {
63         s8 high_pwroff, high_shutdown, high_warn;
64         s8 low_warn, low_shutdown, low_pwroff;
65 };
66
67 static struct temp_limits cpu_temp_limits[2] = {
68         { 100, 85, 80, 5, -5, -10 },
69         { 100, 85, 80, 5, -5, -10 },
70 };
71
72 static struct temp_limits amb_temp_limits[2] = {
73         { 65, 55, 40, 5, -5, -10 },
74         { 65, 55, 40, 5, -5, -10 },
75 };
76
77 enum fan_action { FAN_SLOWER, FAN_SAME, FAN_FASTER, FAN_FULLBLAST, FAN_STATE_MAX };
78
79 struct bbc_cpu_temperature {
80         struct bbc_cpu_temperature      *next;
81
82         struct bbc_i2c_client           *client;
83         int                             index;
84
85         /* Current readings, and history. */
86         s8                              curr_cpu_temp;
87         s8                              curr_amb_temp;
88         s8                              prev_cpu_temp;
89         s8                              prev_amb_temp;
90         s8                              avg_cpu_temp;
91         s8                              avg_amb_temp;
92
93         int                             sample_tick;
94
95         enum fan_action                 fan_todo[2];
96 #define FAN_AMBIENT     0
97 #define FAN_CPU         1
98 };
99
100 struct bbc_cpu_temperature *all_bbc_temps;
101
102 struct bbc_fan_control {
103         struct bbc_fan_control  *next;
104
105         struct bbc_i2c_client   *client;
106         int                     index;
107
108         int                     psupply_fan_on;
109         int                     cpu_fan_speed;
110         int                     system_fan_speed;
111 };
112
113 struct bbc_fan_control *all_bbc_fans;
114
115 #define CPU_FAN_REG     0xf0
116 #define SYS_FAN_REG     0xf2
117 #define PSUPPLY_FAN_REG 0xf4
118
119 #define FAN_SPEED_MIN   0x0c
120 #define FAN_SPEED_MAX   0x3f
121
122 #define PSUPPLY_FAN_ON  0x1f
123 #define PSUPPLY_FAN_OFF 0x00
124
125 static void set_fan_speeds(struct bbc_fan_control *fp)
126 {
127         /* Put temperatures into range so we don't mis-program
128          * the hardware.
129          */
130         if (fp->cpu_fan_speed < FAN_SPEED_MIN)
131                 fp->cpu_fan_speed = FAN_SPEED_MIN;
132         if (fp->cpu_fan_speed > FAN_SPEED_MAX)
133                 fp->cpu_fan_speed = FAN_SPEED_MAX;
134         if (fp->system_fan_speed < FAN_SPEED_MIN)
135                 fp->system_fan_speed = FAN_SPEED_MIN;
136         if (fp->system_fan_speed > FAN_SPEED_MAX)
137                 fp->system_fan_speed = FAN_SPEED_MAX;
138 #ifdef ENVCTRL_TRACE
139         printk("fan%d: Changed fan speed to cpu(%02x) sys(%02x)\n",
140                fp->index,
141                fp->cpu_fan_speed, fp->system_fan_speed);
142 #endif
143
144         bbc_i2c_writeb(fp->client, fp->cpu_fan_speed, CPU_FAN_REG);
145         bbc_i2c_writeb(fp->client, fp->system_fan_speed, SYS_FAN_REG);
146         bbc_i2c_writeb(fp->client,
147                        (fp->psupply_fan_on ?
148                         PSUPPLY_FAN_ON : PSUPPLY_FAN_OFF),
149                        PSUPPLY_FAN_REG);
150 }
151
152 static void get_current_temps(struct bbc_cpu_temperature *tp)
153 {
154         tp->prev_amb_temp = tp->curr_amb_temp;
155         bbc_i2c_readb(tp->client,
156                       (unsigned char *) &tp->curr_amb_temp,
157                       MAX1617_AMB_TEMP);
158         tp->prev_cpu_temp = tp->curr_cpu_temp;
159         bbc_i2c_readb(tp->client,
160                       (unsigned char *) &tp->curr_cpu_temp,
161                       MAX1617_CPU_TEMP);
162 #ifdef ENVCTRL_TRACE
163         printk("temp%d: cpu(%d C) amb(%d C)\n",
164                tp->index,
165                (int) tp->curr_cpu_temp, (int) tp->curr_amb_temp);
166 #endif
167 }
168
169
170 static void do_envctrl_shutdown(struct bbc_cpu_temperature *tp)
171 {
172         static int shutting_down = 0;
173         static char *envp[] = { "HOME=/", "TERM=linux", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
174         char *argv[] = { "/sbin/shutdown", "-h", "now", NULL };
175         char *type = "???";
176         s8 val = -1;
177
178         if (shutting_down != 0)
179                 return;
180
181         if (tp->curr_amb_temp >= amb_temp_limits[tp->index].high_shutdown ||
182             tp->curr_amb_temp < amb_temp_limits[tp->index].low_shutdown) {
183                 type = "ambient";
184                 val = tp->curr_amb_temp;
185         } else if (tp->curr_cpu_temp >= cpu_temp_limits[tp->index].high_shutdown ||
186                    tp->curr_cpu_temp < cpu_temp_limits[tp->index].low_shutdown) {
187                 type = "CPU";
188                 val = tp->curr_cpu_temp;
189         }
190
191         printk(KERN_CRIT "temp%d: Outside of safe %s "
192                "operating temperature, %d C.\n",
193                tp->index, type, val);
194
195         printk(KERN_CRIT "kenvctrld: Shutting down the system now.\n");
196
197         shutting_down = 1;
198         if (kernel_execve("/sbin/shutdown", argv, envp) < 0)
199                 printk(KERN_CRIT "envctrl: shutdown execution failed\n");
200 }
201
202 #define WARN_INTERVAL   (30 * HZ)
203
204 static void analyze_ambient_temp(struct bbc_cpu_temperature *tp, unsigned long *last_warn, int tick)
205 {
206         int ret = 0;
207
208         if (time_after(jiffies, (*last_warn + WARN_INTERVAL))) {
209                 if (tp->curr_amb_temp >=
210                     amb_temp_limits[tp->index].high_warn) {
211                         printk(KERN_WARNING "temp%d: "
212                                "Above safe ambient operating temperature, %d C.\n",
213                                tp->index, (int) tp->curr_amb_temp);
214                         ret = 1;
215                 } else if (tp->curr_amb_temp <
216                            amb_temp_limits[tp->index].low_warn) {
217                         printk(KERN_WARNING "temp%d: "
218                                "Below safe ambient operating temperature, %d C.\n",
219                                tp->index, (int) tp->curr_amb_temp);
220                         ret = 1;
221                 }
222                 if (ret)
223                         *last_warn = jiffies;
224         } else if (tp->curr_amb_temp >= amb_temp_limits[tp->index].high_warn ||
225                    tp->curr_amb_temp < amb_temp_limits[tp->index].low_warn)
226                 ret = 1;
227
228         /* Now check the shutdown limits. */
229         if (tp->curr_amb_temp >= amb_temp_limits[tp->index].high_shutdown ||
230             tp->curr_amb_temp < amb_temp_limits[tp->index].low_shutdown) {
231                 do_envctrl_shutdown(tp);
232                 ret = 1;
233         }
234
235         if (ret) {
236                 tp->fan_todo[FAN_AMBIENT] = FAN_FULLBLAST;
237         } else if ((tick & (8 - 1)) == 0) {
238                 s8 amb_goal_hi = amb_temp_limits[tp->index].high_warn - 10;
239                 s8 amb_goal_lo;
240
241                 amb_goal_lo = amb_goal_hi - 3;
242
243                 /* We do not try to avoid 'too cold' events.  Basically we
244                  * only try to deal with over-heating and fan noise reduction.
245                  */
246                 if (tp->avg_amb_temp < amb_goal_hi) {
247                         if (tp->avg_amb_temp >= amb_goal_lo)
248                                 tp->fan_todo[FAN_AMBIENT] = FAN_SAME;
249                         else
250                                 tp->fan_todo[FAN_AMBIENT] = FAN_SLOWER;
251                 } else {
252                         tp->fan_todo[FAN_AMBIENT] = FAN_FASTER;
253                 }
254         } else {
255                 tp->fan_todo[FAN_AMBIENT] = FAN_SAME;
256         }
257 }
258
259 static void analyze_cpu_temp(struct bbc_cpu_temperature *tp, unsigned long *last_warn, int tick)
260 {
261         int ret = 0;
262
263         if (time_after(jiffies, (*last_warn + WARN_INTERVAL))) {
264                 if (tp->curr_cpu_temp >=
265                     cpu_temp_limits[tp->index].high_warn) {
266                         printk(KERN_WARNING "temp%d: "
267                                "Above safe CPU operating temperature, %d C.\n",
268                                tp->index, (int) tp->curr_cpu_temp);
269                         ret = 1;
270                 } else if (tp->curr_cpu_temp <
271                            cpu_temp_limits[tp->index].low_warn) {
272                         printk(KERN_WARNING "temp%d: "
273                                "Below safe CPU operating temperature, %d C.\n",
274                                tp->index, (int) tp->curr_cpu_temp);
275                         ret = 1;
276                 }
277                 if (ret)
278                         *last_warn = jiffies;
279         } else if (tp->curr_cpu_temp >= cpu_temp_limits[tp->index].high_warn ||
280                    tp->curr_cpu_temp < cpu_temp_limits[tp->index].low_warn)
281                 ret = 1;
282
283         /* Now check the shutdown limits. */
284         if (tp->curr_cpu_temp >= cpu_temp_limits[tp->index].high_shutdown ||
285             tp->curr_cpu_temp < cpu_temp_limits[tp->index].low_shutdown) {
286                 do_envctrl_shutdown(tp);
287                 ret = 1;
288         }
289
290         if (ret) {
291                 tp->fan_todo[FAN_CPU] = FAN_FULLBLAST;
292         } else if ((tick & (8 - 1)) == 0) {
293                 s8 cpu_goal_hi = cpu_temp_limits[tp->index].high_warn - 10;
294                 s8 cpu_goal_lo;
295
296                 cpu_goal_lo = cpu_goal_hi - 3;
297
298                 /* We do not try to avoid 'too cold' events.  Basically we
299                  * only try to deal with over-heating and fan noise reduction.
300                  */
301                 if (tp->avg_cpu_temp < cpu_goal_hi) {
302                         if (tp->avg_cpu_temp >= cpu_goal_lo)
303                                 tp->fan_todo[FAN_CPU] = FAN_SAME;
304                         else
305                                 tp->fan_todo[FAN_CPU] = FAN_SLOWER;
306                 } else {
307                         tp->fan_todo[FAN_CPU] = FAN_FASTER;
308                 }
309         } else {
310                 tp->fan_todo[FAN_CPU] = FAN_SAME;
311         }
312 }
313
314 static void analyze_temps(struct bbc_cpu_temperature *tp, unsigned long *last_warn)
315 {
316         tp->avg_amb_temp = (s8)((int)((int)tp->avg_amb_temp + (int)tp->curr_amb_temp) / 2);
317         tp->avg_cpu_temp = (s8)((int)((int)tp->avg_cpu_temp + (int)tp->curr_cpu_temp) / 2);
318
319         analyze_ambient_temp(tp, last_warn, tp->sample_tick);
320         analyze_cpu_temp(tp, last_warn, tp->sample_tick);
321
322         tp->sample_tick++;
323 }
324
325 static enum fan_action prioritize_fan_action(int which_fan)
326 {
327         struct bbc_cpu_temperature *tp;
328         enum fan_action decision = FAN_STATE_MAX;
329
330         /* Basically, prioritize what the temperature sensors
331          * recommend we do, and perform that action on all the
332          * fans.
333          */
334         for (tp = all_bbc_temps; tp; tp = tp->next) {
335                 if (tp->fan_todo[which_fan] == FAN_FULLBLAST) {
336                         decision = FAN_FULLBLAST;
337                         break;
338                 }
339                 if (tp->fan_todo[which_fan] == FAN_SAME &&
340                     decision != FAN_FASTER)
341                         decision = FAN_SAME;
342                 else if (tp->fan_todo[which_fan] == FAN_FASTER)
343                         decision = FAN_FASTER;
344                 else if (decision != FAN_FASTER &&
345                          decision != FAN_SAME &&
346                          tp->fan_todo[which_fan] == FAN_SLOWER)
347                         decision = FAN_SLOWER;
348         }
349         if (decision == FAN_STATE_MAX)
350                 decision = FAN_SAME;
351
352         return decision;
353 }
354
355 static int maybe_new_ambient_fan_speed(struct bbc_fan_control *fp)
356 {
357         enum fan_action decision = prioritize_fan_action(FAN_AMBIENT);
358         int ret;
359
360         if (decision == FAN_SAME)
361                 return 0;
362
363         ret = 1;
364         if (decision == FAN_FULLBLAST) {
365                 if (fp->system_fan_speed >= FAN_SPEED_MAX)
366                         ret = 0;
367                 else
368                         fp->system_fan_speed = FAN_SPEED_MAX;
369         } else {
370                 if (decision == FAN_FASTER) {
371                         if (fp->system_fan_speed >= FAN_SPEED_MAX)
372                                 ret = 0;
373                         else
374                                 fp->system_fan_speed += 2;
375                 } else {
376                         int orig_speed = fp->system_fan_speed;
377
378                         if (orig_speed <= FAN_SPEED_MIN ||
379                             orig_speed <= (fp->cpu_fan_speed - 3))
380                                 ret = 0;
381                         else
382                                 fp->system_fan_speed -= 1;
383                 }
384         }
385
386         return ret;
387 }
388
389 static int maybe_new_cpu_fan_speed(struct bbc_fan_control *fp)
390 {
391         enum fan_action decision = prioritize_fan_action(FAN_CPU);
392         int ret;
393
394         if (decision == FAN_SAME)
395                 return 0;
396
397         ret = 1;
398         if (decision == FAN_FULLBLAST) {
399                 if (fp->cpu_fan_speed >= FAN_SPEED_MAX)
400                         ret = 0;
401                 else
402                         fp->cpu_fan_speed = FAN_SPEED_MAX;
403         } else {
404                 if (decision == FAN_FASTER) {
405                         if (fp->cpu_fan_speed >= FAN_SPEED_MAX)
406                                 ret = 0;
407                         else {
408                                 fp->cpu_fan_speed += 2;
409                                 if (fp->system_fan_speed <
410                                     (fp->cpu_fan_speed - 3))
411                                         fp->system_fan_speed =
412                                                 fp->cpu_fan_speed - 3;
413                         }
414                 } else {
415                         if (fp->cpu_fan_speed <= FAN_SPEED_MIN)
416                                 ret = 0;
417                         else
418                                 fp->cpu_fan_speed -= 1;
419                 }
420         }
421
422         return ret;
423 }
424
425 static void maybe_new_fan_speeds(struct bbc_fan_control *fp)
426 {
427         int new;
428
429         new  = maybe_new_ambient_fan_speed(fp);
430         new |= maybe_new_cpu_fan_speed(fp);
431
432         if (new)
433                 set_fan_speeds(fp);
434 }
435
436 static void fans_full_blast(void)
437 {
438         struct bbc_fan_control *fp;
439
440         /* Since we will not be monitoring things anymore, put
441          * the fans on full blast.
442          */
443         for (fp = all_bbc_fans; fp; fp = fp->next) {
444                 fp->cpu_fan_speed = FAN_SPEED_MAX;
445                 fp->system_fan_speed = FAN_SPEED_MAX;
446                 fp->psupply_fan_on = 1;
447                 set_fan_speeds(fp);
448         }
449 }
450
451 #define POLL_INTERVAL   (5 * 1000)
452 static unsigned long last_warning_jiffies;
453 static struct task_struct *kenvctrld_task;
454
455 static int kenvctrld(void *__unused)
456 {
457         printk(KERN_INFO "bbc_envctrl: kenvctrld starting...\n");
458         last_warning_jiffies = jiffies - WARN_INTERVAL;
459         for (;;) {
460                 struct bbc_cpu_temperature *tp;
461                 struct bbc_fan_control *fp;
462
463                 msleep_interruptible(POLL_INTERVAL);
464                 if (kthread_should_stop())
465                         break;
466
467                 for (tp = all_bbc_temps; tp; tp = tp->next) {
468                         get_current_temps(tp);
469                         analyze_temps(tp, &last_warning_jiffies);
470                 }
471                 for (fp = all_bbc_fans; fp; fp = fp->next)
472                         maybe_new_fan_speeds(fp);
473         }
474         printk(KERN_INFO "bbc_envctrl: kenvctrld exiting...\n");
475
476         fans_full_blast();
477
478         return 0;
479 }
480
481 static void attach_one_temp(struct linux_ebus_child *echild, int temp_idx)
482 {
483         struct bbc_cpu_temperature *tp = kmalloc(sizeof(*tp), GFP_KERNEL);
484
485         if (!tp)
486                 return;
487         memset(tp, 0, sizeof(*tp));
488         tp->client = bbc_i2c_attach(echild);
489         if (!tp->client) {
490                 kfree(tp);
491                 return;
492         }
493
494         tp->index = temp_idx;
495         {
496                 struct bbc_cpu_temperature **tpp = &all_bbc_temps;
497                 while (*tpp)
498                         tpp = &((*tpp)->next);
499                 tp->next = NULL;
500                 *tpp = tp;
501         }
502
503         /* Tell it to convert once every 5 seconds, clear all cfg
504          * bits.
505          */
506         bbc_i2c_writeb(tp->client, 0x00, MAX1617_WR_CFG_BYTE);
507         bbc_i2c_writeb(tp->client, 0x02, MAX1617_WR_CVRATE_BYTE);
508
509         /* Program the hard temperature limits into the chip. */
510         bbc_i2c_writeb(tp->client, amb_temp_limits[tp->index].high_pwroff,
511                        MAX1617_WR_AMB_HIGHLIM);
512         bbc_i2c_writeb(tp->client, amb_temp_limits[tp->index].low_pwroff,
513                        MAX1617_WR_AMB_LOWLIM);
514         bbc_i2c_writeb(tp->client, cpu_temp_limits[tp->index].high_pwroff,
515                        MAX1617_WR_CPU_HIGHLIM);
516         bbc_i2c_writeb(tp->client, cpu_temp_limits[tp->index].low_pwroff,
517                        MAX1617_WR_CPU_LOWLIM);
518
519         get_current_temps(tp);
520         tp->prev_cpu_temp = tp->avg_cpu_temp = tp->curr_cpu_temp;
521         tp->prev_amb_temp = tp->avg_amb_temp = tp->curr_amb_temp;
522
523         tp->fan_todo[FAN_AMBIENT] = FAN_SAME;
524         tp->fan_todo[FAN_CPU] = FAN_SAME;
525 }
526
527 static void attach_one_fan(struct linux_ebus_child *echild, int fan_idx)
528 {
529         struct bbc_fan_control *fp = kmalloc(sizeof(*fp), GFP_KERNEL);
530
531         if (!fp)
532                 return;
533         memset(fp, 0, sizeof(*fp));
534         fp->client = bbc_i2c_attach(echild);
535         if (!fp->client) {
536                 kfree(fp);
537                 return;
538         }
539
540         fp->index = fan_idx;
541
542         {
543                 struct bbc_fan_control **fpp = &all_bbc_fans;
544                 while (*fpp)
545                         fpp = &((*fpp)->next);
546                 fp->next = NULL;
547                 *fpp = fp;
548         }
549
550         /* The i2c device controlling the fans is write-only.
551          * So the only way to keep track of the current power
552          * level fed to the fans is via software.  Choose half
553          * power for cpu/system and 'on' fo the powersupply fan
554          * and set it now.
555          */
556         fp->psupply_fan_on = 1;
557         fp->cpu_fan_speed = (FAN_SPEED_MAX - FAN_SPEED_MIN) / 2;
558         fp->cpu_fan_speed += FAN_SPEED_MIN;
559         fp->system_fan_speed = (FAN_SPEED_MAX - FAN_SPEED_MIN) / 2;
560         fp->system_fan_speed += FAN_SPEED_MIN;
561
562         set_fan_speeds(fp);
563 }
564
565 int bbc_envctrl_init(void)
566 {
567         struct linux_ebus_child *echild;
568         int temp_index = 0;
569         int fan_index = 0;
570         int devidx = 0;
571
572         while ((echild = bbc_i2c_getdev(devidx++)) != NULL) {
573                 if (!strcmp(echild->prom_node->name, "temperature"))
574                         attach_one_temp(echild, temp_index++);
575                 if (!strcmp(echild->prom_node->name, "fan-control"))
576                         attach_one_fan(echild, fan_index++);
577         }
578         if (temp_index != 0 && fan_index != 0) {
579                 kenvctrld_task = kthread_run(kenvctrld, NULL, "kenvctrld");
580                 if (IS_ERR(kenvctrld_task))
581                         return PTR_ERR(kenvctrld_task);
582         }
583
584         return 0;
585 }
586
587 static void destroy_one_temp(struct bbc_cpu_temperature *tp)
588 {
589         bbc_i2c_detach(tp->client);
590         kfree(tp);
591 }
592
593 static void destroy_one_fan(struct bbc_fan_control *fp)
594 {
595         bbc_i2c_detach(fp->client);
596         kfree(fp);
597 }
598
599 void bbc_envctrl_cleanup(void)
600 {
601         struct bbc_cpu_temperature *tp;
602         struct bbc_fan_control *fp;
603
604         kthread_stop(kenvctrld_task);
605
606         tp = all_bbc_temps;
607         while (tp != NULL) {
608                 struct bbc_cpu_temperature *next = tp->next;
609                 destroy_one_temp(tp);
610                 tp = next;
611         }
612         all_bbc_temps = NULL;
613
614         fp = all_bbc_fans;
615         while (fp != NULL) {
616                 struct bbc_fan_control *next = fp->next;
617                 destroy_one_fan(fp);
618                 fp = next;
619         }
620         all_bbc_fans = NULL;
621 }