firmware/backlight.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Linus Nielsen Feltzing
  11  * Additional work by Martin Ritter (2007) and Thomas Martitz (2008)
  12  *                  for backlight thread fading
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "config.h"
  24 #include <stdlib.h>
  25 #include "cpu.h"
  26 #include "kernel.h"
  27 #include "thread.h"
  28 #include "i2c.h"
  29 #include "debug.h"
  30 #include "rtc.h"
  31 #include "usb.h"
  32 #include "power.h"
  33 #include "system.h"
  34 #include "button.h"
  35 #include "timer.h"
  36 #include "backlight.h"
  37 #include "lcd.h"
  38 #include "screendump.h"
  39
  40 #ifdef HAVE_REMOTE_LCD
  41 #include "lcd-remote.h"
  42 #endif
  43 #ifndef SIMULATOR
  44 #include "backlight-target.h"
  45 #else
  46 #include "backlight-sim.h"
  47 #endif
  48
  49 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
  50     || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
  51 #include "backlight-sw-fading.h"
  52 #endif
  53
  54 #if defined(HAVE_BACKLIGHT) && defined(BACKLIGHT_FULL_INIT)
  55
  56 #define BACKLIGHT_FADE_IN_THREAD \
  57     (CONFIG_BACKLIGHT_FADING &  (BACKLIGHT_FADING_SW_SETTING \
  58                                 |BACKLIGHT_FADING_SW_HW_REG \
  59                                 |BACKLIGHT_FADING_PWM) )
  60
  61 #define BACKLIGHT_THREAD_TIMEOUT HZ
  62
  63 enum {
  64     BACKLIGHT_ON,
  65     BACKLIGHT_OFF,
  66     BACKLIGHT_TMO_CHANGED,
  67 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
  68     BACKLIGHT_BRIGHTNESS_CHANGED,
  69 #endif
  70 #ifdef HAVE_REMOTE_LCD
  71     REMOTE_BACKLIGHT_ON,
  72     REMOTE_BACKLIGHT_OFF,
  73     REMOTE_BACKLIGHT_TMO_CHANGED,
  74 #endif
  75 #if defined(_BACKLIGHT_FADE_BOOST) || defined(_BACKLIGHT_FADE_ENABLE)
  76     BACKLIGHT_FADE_FINISH,
  77 #endif
  78 #ifdef HAVE_LCD_SLEEP
  79     LCD_SLEEP,
  80 #endif
  81 #ifdef HAVE_BUTTON_LIGHT
  82     BUTTON_LIGHT_ON,
  83     BUTTON_LIGHT_OFF,
  84     BUTTON_LIGHT_TMO_CHANGED,
  85 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
  86     BUTTON_LIGHT_BRIGHTNESS_CHANGED,
  87 #endif
  88 #endif /* HAVE_BUTTON_LIGHT */
  89 #ifdef BACKLIGHT_DRIVER_CLOSE
  90     BACKLIGHT_QUIT,
  91 #endif
  92 };
  93
  94 static void backlight_thread(void);
  95 static long backlight_stack[DEFAULT_STACK_SIZE/sizeof(long)];
  96 static const char backlight_thread_name[] = "backlight";
  97 static struct event_queue backlight_queue;
  98 #ifdef BACKLIGHT_DRIVER_CLOSE
  99 static unsigned int backlight_thread_id = 0;
 100 #endif
 101
 102 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 103 int backlight_brightness = DEFAULT_BRIGHTNESS_SETTING;
 104 #endif
 105 static int backlight_timer SHAREDBSS_ATTR;
 106 static int backlight_timeout_normal = 5*HZ;
 107 #if CONFIG_CHARGING
 108 static int backlight_timeout_plugged = 5*HZ;
 109 #endif
 110 #ifdef HAS_BUTTON_HOLD
 111 static int backlight_on_button_hold = 0;
 112 #endif
 113 static void backlight_timeout_handler(void);
 114
 115 #ifdef HAVE_BUTTON_LIGHT
 116 static int buttonlight_timer;
 117 static int buttonlight_timeout = 5*HZ;
 118
 119 /* Update state of buttonlight according to timeout setting */
 120 static void buttonlight_update_state(void)
 121 {
 122     buttonlight_timer = buttonlight_timeout;
 123
 124     /* Buttonlight == OFF in the setting? */
 125     if (buttonlight_timer < 0)
 126     {
 127         buttonlight_timer = 0; /* Disable the timeout */
 128         _buttonlight_off();
 129     }
 130     else
 131         _buttonlight_on();
 132 }
 133
 134 /* external interface */
 135 void buttonlight_on(void)
 136 {
 137     queue_remove_from_head(&backlight_queue, BUTTON_LIGHT_ON);
 138     queue_post(&backlight_queue, BUTTON_LIGHT_ON, 0);
 139 }
 140
 141 void buttonlight_off(void)
 142 {
 143     queue_post(&backlight_queue, BUTTON_LIGHT_OFF, 0);
 144 }
 145
 146 void buttonlight_set_timeout(int value)
 147 {
 148     buttonlight_timeout = HZ * value;
 149     queue_post(&backlight_queue, BUTTON_LIGHT_TMO_CHANGED, 0);
 150 }
 151
 152 int buttonlight_get_current_timeout(void)
 153 {
 154     return buttonlight_timeout;
 155 }
 156
 157 #endif /* HAVE_BUTTON_LIGHT */
 158
 159 #ifdef HAVE_REMOTE_LCD
 160 static int remote_backlight_timer;
 161 static int remote_backlight_timeout_normal = 5*HZ;
 162 #if CONFIG_CHARGING
 163 static int remote_backlight_timeout_plugged = 5*HZ;
 164 #endif
 165 #ifdef HAS_REMOTE_BUTTON_HOLD
 166 static int remote_backlight_on_button_hold = 0;
 167 #endif
 168 #endif /* HAVE_REMOTE_LCD */
 169
 170 #ifdef HAVE_LCD_SLEEP
 171 #ifdef HAVE_LCD_SLEEP_SETTING
 172 const signed char lcd_sleep_timeout_value[10] =
 173 {
 174     -1, 0, 5, 10, 15, 20, 30, 45, 60, 90
 175 };
 176 static int lcd_sleep_timeout = 10*HZ;
 177 #else
 178 /* Target defines needed value */
 179 #define lcd_sleep_timeout LCD_SLEEP_TIMEOUT
 180 #endif
 181
 182 static int lcd_sleep_timer SHAREDDATA_ATTR = 0;
 183
 184 static void backlight_lcd_sleep_countdown(bool start)
 185 {
 186     if (!start)
 187     {
 188         /* Cancel the LCD sleep countdown */
 189         lcd_sleep_timer = 0;
 190         return;
 191     }
 192
 193     /* Start LCD sleep countdown */
 194     if (lcd_sleep_timeout < 0)
 195     {
 196         lcd_sleep_timer = 0; /* Setting == Always */
 197         /* Ensure lcd_sleep() is called from backlight_thread() */
 198 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_PWM)
 199         queue_post(&backlight_queue, LCD_SLEEP, 0);
 200 #else
 201         lcd_sleep();
 202 #endif
 203     }
 204     else
 205     {
 206         lcd_sleep_timer = lcd_sleep_timeout;
 207     }
 208 }
 209 #endif /* HAVE_LCD_SLEEP */
 210
 211 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
 212     || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
 213 static int backlight_fading_type = (FADING_UP|FADING_DOWN);
 214 static int backlight_fading_state = NOT_FADING;
 215 #endif
 216
 217
 218 /* backlight fading */
 219 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_PWM)
 220 #define BL_PWM_INTERVAL 5  /* Cycle interval in ms */
 221 #define BL_PWM_BITS     8
 222 #define BL_PWM_COUNT    (1<<BL_PWM_BITS)
 223
 224 /* s15.16 fixed point variables */
 225 static int32_t bl_fade_in_step  = ((BL_PWM_INTERVAL*BL_PWM_COUNT)<<16)/300;
 226 static int32_t bl_fade_out_step = ((BL_PWM_INTERVAL*BL_PWM_COUNT)<<16)/2000;
 227 static int32_t bl_dim_fraction  = 0;
 228
 229 static int bl_dim_target  = 0;
 230 static int bl_dim_current = 0;
 231 static enum {DIM_STATE_START, DIM_STATE_MAIN} bl_dim_state = DIM_STATE_START;
 232 static bool bl_timer_active = false;
 233
 234 static void backlight_isr(void)
 235 {
 236     int timer_period = (TIMER_FREQ*BL_PWM_INTERVAL/1000);
 237     bool idle = false;
 238
 239     switch (bl_dim_state)
 240     {
 241       /* New cycle */
 242       case DIM_STATE_START:
 243         bl_dim_current = bl_dim_fraction >> 16;
 244
 245         if (bl_dim_current > 0 && bl_dim_current < BL_PWM_COUNT)
 246         {
 247             _backlight_on_isr();
 248             timer_period = (timer_period * bl_dim_current) >> BL_PWM_BITS;
 249             bl_dim_state = DIM_STATE_MAIN;
 250         }
 251         else
 252         {
 253             if (bl_dim_current)
 254                 _backlight_on_isr();
 255             else
 256                 _backlight_off_isr();
 257             if (bl_dim_current == bl_dim_target)
 258                 idle = true;
 259         }
 260         if (bl_dim_current < bl_dim_target)
 261         {
 262             bl_dim_fraction = MIN(bl_dim_fraction + bl_fade_in_step,
 263                                   (BL_PWM_COUNT<<16));
 264         }
 265         else if (bl_dim_current > bl_dim_target)
 266         {
 267             bl_dim_fraction = MAX(bl_dim_fraction - bl_fade_out_step, 0);
 268         }
 269         break;
 270
 271       /* Dim main screen */
 272       case DIM_STATE_MAIN:
 273         _backlight_off_isr();
 274         timer_period = (timer_period * (BL_PWM_COUNT - bl_dim_current))
 275                      >> BL_PWM_BITS;
 276         bl_dim_state = DIM_STATE_START;
 277         break ;
 278     }
 279     if (idle)
 280     {
 281 #if defined(_BACKLIGHT_FADE_BOOST) || defined(_BACKLIGHT_FADE_ENABLE)
 282         queue_post(&backlight_queue, BACKLIGHT_FADE_FINISH, 0);
 283 #endif
 284         timer_unregister();
 285         bl_timer_active = false;
 286
 287 #ifdef HAVE_LCD_SLEEP
 288         if (bl_dim_current == 0)
 289             backlight_lcd_sleep_countdown(true);
 290 #endif
 291     }
 292     else
 293         timer_set_period(timer_period);
 294 }
 295
 296 static void backlight_switch(void)
 297 {
 298     if (bl_dim_target > (BL_PWM_COUNT/2))
 299     {
 300         _backlight_on_normal();
 301         bl_dim_fraction = (BL_PWM_COUNT<<16);
 302     }
 303     else
 304     {
 305         _backlight_off_normal();
 306         bl_dim_fraction = 0;
 307
 308 #ifdef HAVE_LCD_SLEEP
 309         backlight_lcd_sleep_countdown(true);
 310 #endif
 311     }
 312 }
 313
 314 static void backlight_release_timer(void)
 315 {
 316 #ifdef _BACKLIGHT_FADE_BOOST
 317     cpu_boost(false);
 318 #endif
 319     timer_unregister();
 320     bl_timer_active = false;
 321     backlight_switch();
 322 }
 323
 324 static void backlight_dim(int value)
 325 {
 326     /* protect from extraneous calls with the same target value */
 327     if (value == bl_dim_target)
 328         return;
 329
 330     bl_dim_target = value;
 331
 332     if (bl_timer_active)
 333         return ;
 334
 335     if (timer_register(0, backlight_release_timer, 2, backlight_isr
 336                        IF_COP(, CPU)))
 337     {
 338 #ifdef _BACKLIGHT_FADE_BOOST
 339         /* Prevent cpu frequency changes while dimming. */
 340         cpu_boost(true);
 341 #endif
 342         bl_timer_active = true;
 343     }
 344     else
 345         backlight_switch();
 346 }
 347
 348 static void backlight_setup_fade_up(void)
 349 {
 350     if (bl_fade_in_step > 0)
 351     {
 352 #ifdef _BACKLIGHT_FADE_ENABLE
 353         _backlight_hw_enable(true);
 354 #endif
 355         backlight_dim(BL_PWM_COUNT);
 356     }
 357     else
 358     {
 359         bl_dim_target = BL_PWM_COUNT;
 360         bl_dim_fraction = (BL_PWM_COUNT<<16);
 361         _backlight_on_normal();
 362     }
 363 }
 364
 365 static void backlight_setup_fade_down(void)
 366 {
 367     if (bl_fade_out_step > 0)
 368     {
 369         backlight_dim(0);
 370     }
 371     else
 372     {
 373         bl_dim_target = bl_dim_fraction = 0;
 374         _backlight_off_normal();
 375 #ifdef HAVE_LCD_SLEEP
 376         backlight_lcd_sleep_countdown(true);
 377 #endif
 378     }
 379 }
 380
 381 void backlight_set_fade_in(int value)
 382 {
 383     if (value > 0)
 384         bl_fade_in_step = ((BL_PWM_INTERVAL*BL_PWM_COUNT)<<16) / value;
 385     else
 386         bl_fade_in_step = 0;
 387 }
 388
 389 void backlight_set_fade_out(int value)
 390 {
 391     if (value > 0)
 392         bl_fade_out_step = ((BL_PWM_INTERVAL*BL_PWM_COUNT)<<16) / value;
 393     else
 394         bl_fade_out_step = 0;
 395 }
 396
 397 #elif  (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
 398     || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
 399
 400 void backlight_set_fade_out(bool value)
 401 {
 402     if(value) /* on */
 403         backlight_fading_type |= FADING_DOWN;
 404     else
 405         backlight_fading_type &= FADING_UP;
 406 }
 407
 408 void backlight_set_fade_in(bool value)
 409 {
 410     if(value) /* on */
 411         backlight_fading_type |= FADING_UP;
 412     else
 413         backlight_fading_type &= FADING_DOWN;
 414 }
 415
 416 static void backlight_setup_fade_up(void)
 417 {
 418     if (backlight_fading_type & FADING_UP)
 419     {
 420         if (backlight_fading_state == NOT_FADING)
 421         {
 422             /* make sure the backlight is at lowest level */
 423             _backlight_on();
 424         }
 425         backlight_fading_state = FADING_UP;
 426     }
 427     else
 428     {
 429         backlight_fading_state = NOT_FADING;
 430         _backlight_fade_update_state(backlight_brightness);
 431         _backlight_on();
 432         _backlight_set_brightness(backlight_brightness);
 433     }
 434 }
 435
 436 static void backlight_setup_fade_down(void)
 437 {
 438     if (backlight_fading_type & FADING_DOWN)
 439     {
 440         backlight_fading_state = FADING_DOWN;
 441     }
 442     else
 443     {
 444         backlight_fading_state = NOT_FADING;
 445         _backlight_fade_update_state(MIN_BRIGHTNESS_SETTING-1);
 446         _backlight_off();
 447 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
 448         /* write the lowest brightness level to the hardware so that
 449          * fading up is glitch free */
 450         _backlight_set_brightness(MIN_BRIGHTNESS_SETTING);
 451 #endif
 452 #ifdef HAVE_LCD_SLEEP
 453         backlight_lcd_sleep_countdown(true);
 454 #endif
 455     }
 456 }
 457 #endif /* CONFIG_BACKLIGHT_FADING */
 458
 459 static inline void do_backlight_off(void)
 460 {
 461     backlight_timer = 0;
 462 #if BACKLIGHT_FADE_IN_THREAD
 463     backlight_setup_fade_down();
 464 #else
 465     _backlight_off();
 466     /* targets that have fading need to start the countdown when done with
 467      * fading */
 468 #ifdef HAVE_LCD_SLEEP
 469     backlight_lcd_sleep_countdown(true);
 470 #endif
 471 #endif
 472 }
 473
 474 /* Update state of backlight according to timeout setting */
 475 static void backlight_update_state(void)
 476 {
 477
 478     int timeout = backlight_get_current_timeout();
 479
 480     /* Backlight == OFF in the setting? */
 481     if (UNLIKELY(timeout < 0))
 482     {
 483         do_backlight_off();
 484 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
 485     || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
 486         /* necessary step to issue fading down when the setting is selected */
 487         if (queue_empty(&backlight_queue))
 488             queue_post(&backlight_queue, SYS_TIMEOUT, 0);
 489 #endif
 490     }
 491     else
 492     {
 493         backlight_timer = timeout;
 494
 495 #ifdef HAVE_LCD_SLEEP
 496         backlight_lcd_sleep_countdown(false); /* wake up lcd */
 497 #endif
 498
 499 #if BACKLIGHT_FADE_IN_THREAD
 500         backlight_setup_fade_up();
 501 #else
 502         _backlight_on();
 503 #endif
 504     }
 505 }
 506
 507 #ifdef HAVE_REMOTE_LCD
 508 /* Update state of remote backlight according to timeout setting */
 509 static void remote_backlight_update_state(void)
 510 {
 511     int timeout = remote_backlight_get_current_timeout();
 512     /* Backlight == OFF in the setting? */
 513     if (timeout < 0)
 514     {
 515         remote_backlight_timer = 0; /* Disable the timeout */
 516         _remote_backlight_off();
 517     }
 518     else
 519     {
 520         remote_backlight_timer = timeout;
 521         _remote_backlight_on();
 522     }
 523 }
 524 #endif /* HAVE_REMOTE_LCD */
 525
 526 void backlight_thread(void)
 527 {
 528     struct queue_event ev;
 529     bool locked = false;
 530
 531     while(1)
 532     {
 533 #if  (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
 534     || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
 535         if (backlight_fading_state != NOT_FADING)
 536             queue_wait_w_tmo(&backlight_queue, &ev, FADE_DELAY);
 537         else
 538 #endif
 539             queue_wait_w_tmo(&backlight_queue, &ev, BACKLIGHT_THREAD_TIMEOUT);
 540         switch(ev.id)
 541         {   /* These events must always be processed */
 542 #ifdef _BACKLIGHT_FADE_BOOST
 543             case BACKLIGHT_FADE_FINISH:
 544                 cpu_boost(false);
 545                 break;
 546 #endif
 547 #ifdef _BACKLIGHT_FADE_ENABLE
 548             case BACKLIGHT_FADE_FINISH:
 549                 _backlight_hw_enable((bl_dim_current|bl_dim_target) != 0);
 550                 break;
 551 #endif
 552
 553 #ifndef SIMULATOR
 554             /* Here for now or else the aggressive init messes up scrolling */
 555 #ifdef HAVE_REMOTE_LCD
 556             case SYS_REMOTE_PLUGGED:
 557                 lcd_remote_on();
 558                 lcd_remote_update();
 559                 break;
 560
 561             case SYS_REMOTE_UNPLUGGED:
 562                 lcd_remote_off();
 563                 break;
 564 #elif defined HAVE_REMOTE_LCD_AS_MAIN
 565             case SYS_REMOTE_PLUGGED:
 566                 lcd_on();
 567                 lcd_update();
 568                 break;
 569
 570             case SYS_REMOTE_UNPLUGGED:
 571                 lcd_off();
 572                 break;
 573 #endif /* HAVE_REMOTE_LCD/ HAVE_REMOTE_LCD_AS_MAIN */
 574 #endif /* !SIMULATOR */
 575             case SYS_USB_CONNECTED:
 576                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
 577                 break;
 578
 579             case SYS_USB_DISCONNECTED:
 580                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 581                 break;
 582
 583 #ifdef BACKLIGHT_DRIVER_CLOSE
 584             /* Get out of here */
 585             case BACKLIGHT_QUIT:
 586                 return;
 587 #endif
 588         }
 589         if (locked)
 590             continue;
 591
 592         switch(ev.id)
 593         {   /* These events are only processed if backlight isn't locked */
 594 #ifdef HAVE_REMOTE_LCD
 595             case REMOTE_BACKLIGHT_TMO_CHANGED:
 596             case REMOTE_BACKLIGHT_ON:
 597                 remote_backlight_update_state();
 598                 break;
 599
 600             case REMOTE_BACKLIGHT_OFF:
 601                 remote_backlight_timer = 0; /* Disable the timeout */
 602                 _remote_backlight_off();
 603                 break;
 604 #endif /* HAVE_REMOTE_LCD */
 605
 606             case BACKLIGHT_TMO_CHANGED:
 607             case BACKLIGHT_ON:
 608                 backlight_update_state();
 609                 break;
 610
 611             case BACKLIGHT_OFF:
 612                 do_backlight_off();
 613                 break;
 614 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 615             case BACKLIGHT_BRIGHTNESS_CHANGED:
 616                 backlight_brightness = (int)ev.data;
 617                 _backlight_set_brightness((int)ev.data);
 618 #if  (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
 619     || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
 620                 /* receive backlight brightness */
 621                 _backlight_fade_update_state((int)ev.data);
 622 #endif
 623                 break;
 624 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
 625 #ifdef HAVE_LCD_SLEEP
 626             case LCD_SLEEP:
 627                 lcd_sleep();
 628                 break;
 629 #endif
 630 #ifdef HAVE_BUTTON_LIGHT
 631             case BUTTON_LIGHT_TMO_CHANGED:
 632             case BUTTON_LIGHT_ON:
 633                 buttonlight_update_state();
 634                 break;
 635
 636             case BUTTON_LIGHT_OFF:
 637                 buttonlight_timer = 0;
 638                 _buttonlight_off();
 639                 break;
 640 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 641             case BUTTON_LIGHT_BRIGHTNESS_CHANGED:
 642                 _buttonlight_set_brightness((int)ev.data);
 643                 break;
 644 #endif /* HAVE_BUTTONLIGHT_BRIGHTNESS */
 645 #endif /* HAVE_BUTTON_LIGHT */
 646
 647             case SYS_POWEROFF:  /* Lock backlight on poweroff so it doesn't */
 648                 locked = true;      /* go off before power is actually cut. */
 649                 /* fall through */
 650 #if CONFIG_CHARGING
 651             case SYS_CHARGER_CONNECTED:
 652             case SYS_CHARGER_DISCONNECTED:
 653 #endif
 654                 backlight_update_state();
 655 #ifdef HAVE_REMOTE_LCD
 656                 remote_backlight_update_state();
 657 #endif
 658                 break;
 659             case SYS_TIMEOUT:
 660 #if  (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
 661     || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
 662                 if (backlight_fading_state != NOT_FADING)
 663                 {
 664                     if ((_backlight_fade_step(backlight_fading_state)))
 665                     {   /* finished fading */
 666 #ifdef HAVE_LCD_SLEEP
 667                         if (backlight_fading_state == FADING_DOWN)
 668                         {   /* start sleep countdown */
 669                              backlight_lcd_sleep_countdown(true);
 670                         }
 671 #endif
 672                         backlight_fading_state = NOT_FADING;
 673                     }
 674                 }
 675                 else
 676 #endif /* CONFIG_BACKLIGHT_FADING */
 677                     backlight_timeout_handler();
 678                 break;
 679         }
 680     } /* end while */
 681 }
 682
 683 static void backlight_timeout_handler(void)
 684 {
 685     if(backlight_timer > 0)
 686     {
 687         backlight_timer -= BACKLIGHT_THREAD_TIMEOUT;
 688         if(backlight_timer <= 0)
 689         {
 690             do_backlight_off();
 691         }
 692     }
 693 #ifdef HAVE_LCD_SLEEP
 694     else if(lcd_sleep_timer > 0)
 695     {
 696         lcd_sleep_timer -= BACKLIGHT_THREAD_TIMEOUT;
 697         if(lcd_sleep_timer <= 0)
 698         {
 699             lcd_sleep();
 700         }
 701     }
 702 #endif /* HAVE_LCD_SLEEP */
 703 #ifdef HAVE_REMOTE_LCD
 704     if(remote_backlight_timer > 0)
 705     {
 706         remote_backlight_timer -= BACKLIGHT_THREAD_TIMEOUT;
 707         if(remote_backlight_timer <= 0)
 708         {
 709             _remote_backlight_off();
 710         }
 711     }
 712 #endif /* HAVE_REMOVE_LCD */
 713 #ifdef HAVE_BUTTON_LIGHT
 714     if (buttonlight_timer > 0)
 715     {
 716         buttonlight_timer -= BACKLIGHT_THREAD_TIMEOUT;
 717         if (buttonlight_timer <= 0)
 718         {
 719             _buttonlight_off();
 720         }
 721     }
 722 #endif /* HAVE_BUTTON_LIGHT */
 723 }
 724
 725 void backlight_init(void)
 726 {
 727     queue_init(&backlight_queue, true);
 728
 729     if (_backlight_init())
 730     {
 731 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_PWM)
 732         /* If backlight is already on, don't fade in. */
 733         bl_dim_target = BL_PWM_COUNT;
 734         bl_dim_fraction = (BL_PWM_COUNT<<16);
 735 #endif
 736     }
 737     /* Leave all lights as set by the bootloader here. The settings load will
 738      * call the appropriate backlight_set_*() functions, only changing light
 739      * status if necessary. */
 740 #ifdef BACKLIGHT_DRIVER_CLOSE
 741     backlight_thread_id =
 742 #endif
 743     create_thread(backlight_thread, backlight_stack,
 744                   sizeof(backlight_stack), 0, backlight_thread_name
 745                   IF_PRIO(, PRIORITY_USER_INTERFACE)
 746                   IF_COP(, CPU));
 747 }
 748
 749 #ifdef BACKLIGHT_DRIVER_CLOSE
 750 void backlight_close(void)
 751 {
 752     unsigned int thread = backlight_thread_id;
 753
 754     /* Wait for thread to exit */
 755     if (thread == 0)
 756         return;
 757
 758     backlight_thread_id = 0;
 759
 760     queue_post(&backlight_queue, BACKLIGHT_QUIT, 0);
 761     thread_wait(thread);
 762 }
 763 #endif /* BACKLIGHT_DRIVER_CLOSE */
 764
 765 void backlight_on(void)
 766 {
 767     queue_remove_from_head(&backlight_queue, BACKLIGHT_ON);
 768     queue_post(&backlight_queue, BACKLIGHT_ON, 0);
 769 }
 770
 771 void backlight_off(void)
 772 {
 773     queue_post(&backlight_queue, BACKLIGHT_OFF, 0);
 774 }
 775
 776 /* returns true when the backlight is on,
 777  * and optionally when it's set to always off. */
 778 bool is_backlight_on(bool ignore_always_off)
 779 {
 780     int timeout = backlight_get_current_timeout();
 781     return (backlight_timer > 0)   /* countdown */
 782         || (timeout == 0) /* always on */
 783         || ((timeout < 0) && !ignore_always_off);
 784 }
 785
 786 /* return value in ticks; 0 means always on, <0 means always off */
 787 int backlight_get_current_timeout(void)
 788 {
 789 #ifdef HAS_BUTTON_HOLD
 790     if ((backlight_on_button_hold != 0)
 791 #ifdef HAVE_REMOTE_LCD_AS_MAIN
 792         && remote_button_hold()
 793 #else
 794         && button_hold()
 795 #endif
 796         )
 797         return (backlight_on_button_hold == 2) ? 0 : -1;
 798         /* always on or always off */
 799     else
 800 #endif
 801 #if CONFIG_CHARGING
 802         if (power_input_present())
 803             return backlight_timeout_plugged;
 804         else
 805 #endif
 806             return backlight_timeout_normal;
 807 }
 808
 809 void backlight_set_timeout(int value)
 810 {
 811     backlight_timeout_normal = HZ * value;
 812     queue_post(&backlight_queue, BACKLIGHT_TMO_CHANGED, 0);
 813 }
 814
 815 #if CONFIG_CHARGING
 816 void backlight_set_timeout_plugged(int value)
 817 {
 818     backlight_timeout_plugged = HZ * value;
 819     queue_post(&backlight_queue, BACKLIGHT_TMO_CHANGED, 0);
 820 }
 821 #endif /* CONFIG_CHARGING */
 822
 823 #ifdef HAS_BUTTON_HOLD
 824 /* Hold button change event handler. */
 825 void backlight_hold_changed(bool hold_button)
 826 {
 827     if (!hold_button || (backlight_on_button_hold > 0))
 828         /* if unlocked or override in effect */
 829         backlight_on();
 830 }
 831
 832 void backlight_set_on_button_hold(int index)
 833 {
 834     if ((unsigned)index >= 3)
 835         /* if given a weird value, use default */
 836         index = 0;
 837
 838     backlight_on_button_hold = index;
 839     queue_post(&backlight_queue, BACKLIGHT_TMO_CHANGED, 0);
 840 }
 841 #endif /* HAS_BUTTON_HOLD */
 842
 843 #ifdef HAVE_LCD_SLEEP_SETTING
 844 void lcd_set_sleep_after_backlight_off(int index)
 845 {
 846     if ((unsigned)index >= sizeof(lcd_sleep_timeout_value))
 847         /* if given a weird value, use default */
 848         index = 3;
 849
 850     lcd_sleep_timeout = HZ * lcd_sleep_timeout_value[index];
 851
 852     if (is_backlight_on(true))
 853         /* Timer will be set when bl turns off or bl set to on. */
 854         return;
 855
 856     /* Backlight is Off */
 857     if (lcd_sleep_timeout < 0)
 858         lcd_sleep_timer = 1; /* Always - sleep next tick */
 859     else
 860         lcd_sleep_timer = lcd_sleep_timeout; /* Never, other */
 861 }
 862 #endif /* HAVE_LCD_SLEEP_SETTING */
 863
 864 #ifdef HAVE_REMOTE_LCD
 865 void remote_backlight_on(void)
 866 {
 867     queue_post(&backlight_queue, REMOTE_BACKLIGHT_ON, 0);
 868 }
 869
 870 void remote_backlight_off(void)
 871 {
 872     queue_post(&backlight_queue, REMOTE_BACKLIGHT_OFF, 0);
 873 }
 874
 875 void remote_backlight_set_timeout(int value)
 876 {
 877     remote_backlight_timeout_normal = HZ * value;
 878     queue_post(&backlight_queue, REMOTE_BACKLIGHT_TMO_CHANGED, 0);
 879 }
 880
 881 #if CONFIG_CHARGING
 882 void remote_backlight_set_timeout_plugged(int value)
 883 {
 884     remote_backlight_timeout_plugged = HZ * value;
 885     queue_post(&backlight_queue, REMOTE_BACKLIGHT_TMO_CHANGED, 0);
 886 }
 887 #endif /* CONFIG_CHARGING */
 888
 889 #ifdef HAS_REMOTE_BUTTON_HOLD
 890 /* Remote hold button change event handler. */
 891 void remote_backlight_hold_changed(bool rc_hold_button)
 892 {
 893     if (!rc_hold_button || (remote_backlight_on_button_hold > 0))
 894         /* if unlocked or override */
 895         remote_backlight_on();
 896 }
 897
 898 void remote_backlight_set_on_button_hold(int index)
 899 {
 900     if ((unsigned)index >= 3)
 901         /* if given a weird value, use default */
 902         index = 0;
 903
 904     remote_backlight_on_button_hold = index;
 905     queue_post(&backlight_queue, REMOTE_BACKLIGHT_TMO_CHANGED, 0);
 906 }
 907 #endif /* HAS_REMOTE_BUTTON_HOLD */
 908
 909 /* return value in ticks; 0 means always on, <0 means always off */
 910 int remote_backlight_get_current_timeout(void)
 911 {
 912 #ifdef HAS_REMOTE_BUTTON_HOLD
 913     if (remote_button_hold() && (remote_backlight_on_button_hold != 0))
 914         return (remote_backlight_on_button_hold == 2)
 915                                  ? 0 : -1;  /* always on or always off */
 916     else
 917 #endif
 918 #if CONFIG_CHARGING
 919         if (power_input_present())
 920             return remote_backlight_timeout_plugged;
 921         else
 922 #endif
 923             return remote_backlight_timeout_normal;
 924 }
 925
 926 /* returns true when the backlight is on, and
 927  * optionally  when it's set to always off */
 928 bool is_remote_backlight_on(bool ignore_always_off)
 929 {
 930     int timeout = remote_backlight_get_current_timeout();
 931     return (remote_backlight_timer > 0)   /* countdown */
 932         || (timeout == 0) /* always on */
 933         || ((timeout < 0) && !ignore_always_off);
 934 }
 935
 936 #endif /* HAVE_REMOTE_LCD */
 937
 938 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 939 void backlight_set_brightness(int val)
 940 {
 941     if (val < MIN_BRIGHTNESS_SETTING)
 942         val = MIN_BRIGHTNESS_SETTING;
 943     else if (val > MAX_BRIGHTNESS_SETTING)
 944         val = MAX_BRIGHTNESS_SETTING;
 945
 946     queue_post(&backlight_queue, BACKLIGHT_BRIGHTNESS_CHANGED, val);
 947 }
 948 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
 949
 950 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 951 void buttonlight_set_brightness(int val)
 952 {
 953     if (val < MIN_BRIGHTNESS_SETTING)
 954         val = MIN_BRIGHTNESS_SETTING;
 955     else if (val > MAX_BRIGHTNESS_SETTING)
 956         val = MAX_BRIGHTNESS_SETTING;
 957
 958      queue_post(&backlight_queue, BUTTON_LIGHT_BRIGHTNESS_CHANGED, val);
 959 }
 960 #endif /* HAVE_BUTTONLIGHT_BRIGHTNESS */
 961
 962 #else /* !defined(HAVE_BACKLIGHT) || !defined(BACKLIGHT_FULL_INIT)
 963     -- no backlight, empty dummy functions */
 964
 965 #if defined(HAVE_BACKLIGHT) && !defined(BACKLIGHT_FULL_INIT)
 966 void backlight_init(void)
 967 {
 968     (void)_backlight_init();
 969     _backlight_on();
 970 }
 971 #endif
 972
 973 void backlight_on(void) {}
 974 void backlight_off(void) {}
 975 void buttonlight_on(void) {}
 976 void backlight_set_timeout(int value) {(void)value;}
 977
 978 bool is_backlight_on(bool ignore_always_off)
 979 {
 980     (void)ignore_always_off;
 981     return true;
 982 }
 983 #ifdef HAVE_REMOTE_LCD
 984 void remote_backlight_on(void) {}
 985 void remote_backlight_off(void) {}
 986 void remote_backlight_set_timeout(int value) {(void)value;}
 987
 988 bool is_remote_backlight_on(bool ignore_always_off)
 989 {
 990     (void)ignore_always_off;
 991     return true;
 992 }
 993 #endif /* HAVE_REMOTE_LCD */
 994 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 995 void backlight_set_brightness(int val) { (void)val; }
 996 #endif
 997 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 998 void buttonlight_set_brightness(int val) { (void)val; }
 999 #endif
1000 #endif /* defined(HAVE_BACKLIGHT) && defined(BACKLIGHT_FULL_INIT) */