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