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