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