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/delay.h>
   9 #include <linux/kmod.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 (call_usermodehelper("/sbin/shutdown", argv, envp, 0) < 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 }