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