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  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include "config.h"
  20 #include <stdlib.h>
  21 #include "cpu.h"
  22 #include "kernel.h"
  23 #include "thread.h"
  24 #include "i2c.h"
  25 #include "debug.h"
  26 #include "rtc.h"
  27 #include "usb.h"
  28 #include "power.h"
  29 #include "system.h"
  30 #include "button.h"
  31 #include "timer.h"
  32 #include "backlight.h"
  33
  34 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  35 #include "lcd.h" /* for lcd_enable() and lcd_sleep() */
  36 #endif
  37 #ifdef HAVE_REMOTE_LCD
  38 #include "lcd-remote.h"
  39 #endif
  40 #ifndef SIMULATOR
  41 #include "backlight-target.h"
  42 #endif
  43
  44 #ifdef SIMULATOR
  45 static inline void __backlight_on(void)
  46 {
  47     sim_backlight(100);
  48 }
  49
  50 static inline void __backlight_off(void)
  51 {
  52     sim_backlight(0);
  53 }
  54
  55 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
  56 static inline void __backlight_set_brightness(int val)
  57 {
  58     (void)val;
  59 }
  60 #endif
  61
  62 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
  63 static inline void __buttonlight_set_brightness(int val)
  64 {
  65     (void)val;
  66 }
  67 #endif
  68
  69 #endif /* SIMULATOR */
  70
  71 #if defined(HAVE_BACKLIGHT) && !defined(BOOTLOADER)
  72
  73 const signed char backlight_timeout_value[19] =
  74 {
  75     -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 45, 60, 90
  76 };
  77
  78 #define BACKLIGHT_ON 1
  79 #define BACKLIGHT_OFF 2
  80 #define REMOTE_BACKLIGHT_ON 3
  81 #define REMOTE_BACKLIGHT_OFF 4
  82 #define BACKLIGHT_UNBOOST_CPU 5
  83 #ifdef HAVE_LCD_SLEEP
  84 #define LCD_SLEEP 6
  85 #endif
  86 #ifdef HAVE_BUTTON_LIGHT
  87 #define BUTTON_LIGHT_ON 7
  88 #define BUTTON_LIGHT_OFF 8
  89 #endif
  90
  91 static void backlight_thread(void);
  92 static long backlight_stack[DEFAULT_STACK_SIZE/sizeof(long)];
  93 #ifdef X5_BACKLIGHT_SHUTDOWN
  94 #define BACKLIGHT_QUIT 256
  95 #endif
  96 static const char backlight_thread_name[] = "backlight";
  97 static struct event_queue backlight_queue;
  98
  99 static int backlight_timer;
 100 static int backlight_timeout = 5*HZ;
 101 #if CONFIG_CHARGING
 102 static int backlight_timeout_plugged = 5*HZ;
 103 #endif
 104 #ifdef HAS_BUTTON_HOLD
 105 static int backlight_on_button_hold = 0;
 106 #endif
 107
 108 #ifdef HAVE_BUTTON_LIGHT
 109 static int button_backlight_timer;
 110 static int button_backlight_timeout = 5*HZ;
 111
 112 /* internal interface */
 113 static void _button_backlight_on(void)
 114 {
 115 #ifndef SIMULATOR
 116 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 117     __button_backlight_dim(false);
 118 #else
 119     __button_backlight_on();
 120 #endif
 121 #endif
 122 }
 123
 124 void _button_backlight_off(void)
 125 {
 126 #ifndef SIMULATOR
 127 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 128     if(button_backlight_timeout>0)
 129         __button_backlight_dim(true);
 130     else
 131 #endif
 132         __button_backlight_off();
 133 #endif
 134 }
 135
 136 /* Update state of buttonlight according to timeout setting */
 137 static void buttonlight_update_state(void)
 138 {
 139     button_backlight_timer = button_backlight_timeout;
 140
 141     /* Buttonlight == OFF in the setting? */
 142     if (button_backlight_timer < 0)
 143     {
 144         button_backlight_timer = 0; /* Disable the timeout */
 145         _button_backlight_off();
 146     }
 147     else
 148         _button_backlight_on();
 149 }
 150
 151 /* external interface */
 152 void button_backlight_on(void)
 153 {
 154     queue_remove_from_head(&backlight_queue, BUTTON_LIGHT_ON);
 155     queue_post(&backlight_queue, BUTTON_LIGHT_ON, 0);
 156 }
 157
 158 void button_backlight_off(void)
 159 {
 160     queue_post(&backlight_queue, BUTTON_LIGHT_OFF, 0);
 161 }
 162
 163 void button_backlight_set_timeout(int index)
 164 {
 165     if((unsigned)index >= sizeof(backlight_timeout_value))
 166         /* if given a weird value, use default */
 167         index = 6;
 168     button_backlight_timeout = HZ * backlight_timeout_value[index];
 169     buttonlight_update_state();
 170 }
 171
 172 #endif
 173
 174 #ifdef HAVE_REMOTE_LCD
 175 static int remote_backlight_timer;
 176 static int remote_backlight_timeout = 5*HZ;
 177 #if CONFIG_CHARGING
 178 static int remote_backlight_timeout_plugged = 5*HZ;
 179 #endif
 180 #ifdef HAS_REMOTE_BUTTON_HOLD
 181 static int remote_backlight_on_button_hold = 0;
 182 #endif
 183 #endif
 184
 185 #ifdef HAVE_LCD_SLEEP
 186 const signed char lcd_sleep_timeout_value[10] =
 187 {
 188     -1, 0, 5, 10, 15, 20, 30, 45, 60, 90
 189 };
 190 static int lcd_sleep_timer;
 191 static int lcd_sleep_timeout = 10*HZ;
 192 #endif
 193
 194 #if defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR)
 195 /* backlight fading */
 196 #define BL_PWM_INTERVAL 5000  /* Cycle interval in s */
 197 #define BL_PWM_COUNT    100
 198 static const char backlight_fade_value[8] = { 0, 1, 2, 4, 6, 8, 10, 20 };
 199 static int fade_in_count = 1;
 200 static int fade_out_count = 4;
 201
 202 static bool bl_timer_active = false;
 203 static int bl_dim_current = 0;
 204 static int bl_dim_target  = 0;
 205 static int bl_pwm_counter = 0;
 206 static volatile int bl_cycle_counter = 0;
 207 static enum {DIM_STATE_START, DIM_STATE_MAIN} bl_dim_state = DIM_STATE_START;
 208
 209 static void backlight_isr(void)
 210 {
 211     int timer_period;
 212     bool idle = false;
 213
 214     timer_period = TIMER_FREQ / 1000 * BL_PWM_INTERVAL / 1000;
 215     switch (bl_dim_state)
 216     {
 217       /* New cycle */
 218       case DIM_STATE_START:
 219         bl_pwm_counter = 0;
 220         bl_cycle_counter++;
 221
 222         if (bl_dim_current > 0 && bl_dim_current < BL_PWM_COUNT)
 223         {
 224             __backlight_on();
 225             bl_pwm_counter = bl_dim_current;
 226             timer_period = timer_period * bl_pwm_counter / BL_PWM_COUNT;
 227             bl_dim_state = DIM_STATE_MAIN;
 228         }
 229         else
 230         {
 231             if (bl_dim_current)
 232                 __backlight_on();
 233             else
 234                 __backlight_off();
 235             if (bl_dim_current == bl_dim_target)
 236                 idle = true;
 237         }
 238
 239         break ;
 240
 241       /* Dim main screen */
 242       case DIM_STATE_MAIN:
 243         __backlight_off();
 244         bl_dim_state = DIM_STATE_START;
 245         timer_period = timer_period * (BL_PWM_COUNT - bl_pwm_counter) / BL_PWM_COUNT;
 246         break ;
 247     }
 248
 249     if ((bl_dim_target > bl_dim_current) && (bl_cycle_counter >= fade_in_count))
 250     {
 251         bl_dim_current++;
 252         bl_cycle_counter = 0;
 253     }
 254
 255     if ((bl_dim_target < bl_dim_current) && (bl_cycle_counter >= fade_out_count))
 256     {
 257         bl_dim_current--;
 258         bl_cycle_counter = 0;
 259     }
 260
 261     if (idle)
 262     {
 263 #ifdef CPU_COLDFIRE
 264         queue_post(&backlight_queue, BACKLIGHT_UNBOOST_CPU, 0);
 265 #endif
 266         timer_unregister();
 267         bl_timer_active = false;
 268     }
 269     else
 270         timer_set_period(timer_period);
 271 }
 272
 273 static void backlight_switch(void)
 274 {
 275     if (bl_dim_target > (BL_PWM_COUNT/2))
 276     {
 277         __backlight_on();
 278         bl_dim_current = BL_PWM_COUNT;
 279     }
 280     else
 281     {
 282         __backlight_off();
 283         bl_dim_current = 0;
 284     }
 285 }
 286
 287 static void backlight_release_timer(void)
 288 {
 289 #ifdef CPU_COLDFIRE
 290     cpu_boost(false);
 291 #endif
 292     timer_unregister();
 293     bl_timer_active = false;
 294     backlight_switch();
 295 }
 296
 297 static void backlight_dim(int value)
 298 {
 299     /* protect from extraneous calls with the same target value */
 300     if (value == bl_dim_target)
 301         return;
 302
 303     bl_dim_target = value;
 304
 305     if (bl_timer_active)
 306         return ;
 307
 308     if (timer_register(0, backlight_release_timer, 2, 0, backlight_isr))
 309     {
 310 #ifdef CPU_COLDFIRE
 311         /* Prevent cpu frequency changes while dimming. */
 312         cpu_boost(true);
 313 #endif
 314         bl_timer_active = true;
 315     }
 316     else
 317         backlight_switch();
 318 }
 319
 320 void backlight_set_fade_in(int index)
 321 {
 322     fade_in_count = backlight_fade_value[index];
 323 }
 324
 325 void backlight_set_fade_out(int index)
 326 {
 327     fade_out_count = backlight_fade_value[index];
 328 }
 329 #endif /* defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR) */
 330
 331 static void _backlight_on(void)
 332 {
 333 #if defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR)
 334     if (fade_in_count > 0)
 335         backlight_dim(BL_PWM_COUNT);
 336     else
 337     {
 338         bl_dim_target = bl_dim_current = BL_PWM_COUNT;
 339         __backlight_on();
 340     }
 341 #elif defined(HAVE_BACKLIGHT_SET_FADING) && !defined(SIMULATOR)
 342     /* call the enable from here - it takes longer than the disable */
 343     lcd_enable(true);
 344     __backlight_dim(false);
 345 #else
 346     __backlight_on();
 347 #endif
 348 #ifdef HAVE_LCD_SLEEP
 349     lcd_sleep_timer = 0; /* LCD should be awake already */
 350 #endif
 351 }
 352
 353 static void _backlight_off(void)
 354 {
 355 #if defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR)
 356     if (fade_out_count > 0)
 357         backlight_dim(0);
 358     else
 359     {
 360         bl_dim_target = bl_dim_current = 0;
 361         __backlight_off();
 362     }
 363 #elif defined(HAVE_BACKLIGHT_SET_FADING) && !defined(SIMULATOR)
 364     __backlight_dim(true);
 365 #else
 366     __backlight_off();
 367 #endif
 368
 369 #ifdef HAVE_LCD_SLEEP
 370     /* Start LCD sleep countdown */
 371     if (lcd_sleep_timeout < 0)
 372     {
 373         lcd_sleep_timer = 0; /* Setting == Always */
 374         lcd_sleep();
 375     }
 376     else
 377         lcd_sleep_timer = lcd_sleep_timeout;
 378 #endif
 379 }
 380
 381 #ifdef HAVE_REMOTE_LCD
 382 #ifdef SIMULATOR
 383 static void __remote_backlight_on(void)
 384 {
 385     sim_remote_backlight(100);
 386 }
 387
 388 static void __remote_backlight_off(void)
 389 {
 390     sim_remote_backlight(0);
 391 }
 392 #endif /* SIMULATOR */
 393 #endif /* HAVE_REMOTE_LCD */
 394
 395 /* Update state of backlight according to timeout setting */
 396 static void backlight_update_state(void)
 397 {
 398 #if CONFIG_CHARGING
 399     if (charger_inserted()
 400 #ifdef HAVE_USB_POWER
 401             || usb_powered()
 402 #endif
 403             )
 404         backlight_timer = backlight_timeout_plugged;
 405     else
 406 #endif
 407         backlight_timer = backlight_timeout;
 408
 409     /* Backlight == OFF in the setting? */
 410     if (backlight_timer < 0)
 411     {
 412         backlight_timer = 0; /* Disable the timeout */
 413 #ifdef HAS_BUTTON_HOLD
 414         if (backlight_on_button_hold == 2 && button_hold())
 415             return; /* Keep on if "On" */
 416 #endif
 417         _backlight_off();
 418     }
 419     else
 420     {
 421 #ifdef HAS_BUTTON_HOLD
 422         if (backlight_on_button_hold == 1 && button_hold())
 423         {
 424             /* Keep off if "Off". */
 425             backlight_timer = 0; /* Disable the timeout */
 426             return;
 427         }
 428 #endif
 429         _backlight_on();
 430     }
 431 }
 432
 433 #ifdef HAVE_REMOTE_LCD
 434 /* Update state of remote backlight according to timeout setting */
 435 static void remote_backlight_update_state(void)
 436 {
 437 #if CONFIG_CHARGING
 438     if (charger_inserted()
 439 #ifdef HAVE_USB_POWER
 440             || usb_powered()
 441 #endif
 442             )
 443         remote_backlight_timer = remote_backlight_timeout_plugged;
 444     else
 445 #endif
 446         remote_backlight_timer = remote_backlight_timeout;
 447
 448     /* Backlight == OFF in the setting? */
 449     if (remote_backlight_timer < 0)
 450     {
 451         remote_backlight_timer = 0; /* Disable the timeout */
 452 #ifdef HAS_REMOTE_BUTTON_HOLD
 453         if (remote_backlight_on_button_hold == 2 && remote_button_hold())
 454             return; /* Keep on if "On" */
 455 #endif
 456         __remote_backlight_off();
 457     }
 458     else
 459     {
 460 #if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
 461         if (remote_type() == REMOTETYPE_H300_NONLCD)
 462         {
 463             backlight_update_state();
 464         }
 465         else
 466 #endif
 467         {
 468 #ifdef HAS_REMOTE_BUTTON_HOLD
 469             if (remote_backlight_on_button_hold == 1 && remote_button_hold())
 470             {
 471                 /* Keep off if "Off". */
 472                 remote_backlight_timer = 0; /* Disable the timeout */
 473                 return;
 474             }
 475 #endif
 476             __remote_backlight_on();
 477         }
 478     }
 479 }
 480 #endif /* HAVE_REMOTE_LCD */
 481
 482 void backlight_thread(void)
 483 {
 484     struct event ev;
 485
 486     while(1)
 487     {
 488         queue_wait(&backlight_queue, &ev);
 489         switch(ev.id)
 490         {
 491 #ifdef HAVE_REMOTE_LCD
 492             case REMOTE_BACKLIGHT_ON:
 493                 remote_backlight_update_state();
 494                 break;
 495
 496             case REMOTE_BACKLIGHT_OFF:
 497                 remote_backlight_timer = 0; /* Disable the timeout */
 498 #ifdef HAS_REMOTE_BUTTON_HOLD
 499                 if (remote_backlight_on_button_hold == 2 &&
 500                     remote_button_hold())
 501                     break; /* Keep on if "On" */
 502 #endif
 503                 __remote_backlight_off();
 504                 break;
 505 #endif /* HAVE_REMOTE_LCD */
 506
 507             case BACKLIGHT_ON:
 508                 backlight_update_state();
 509                 break;
 510
 511             case BACKLIGHT_OFF:
 512                 backlight_timer = 0; /* Disable the timeout */
 513 #ifdef HAS_BUTTON_HOLD
 514                 if (backlight_on_button_hold == 2 && button_hold())
 515                     break; /* Keep on if "On" */
 516 #endif
 517                 _backlight_off();
 518                 break;
 519
 520 #ifdef HAVE_LCD_SLEEP
 521             case LCD_SLEEP:
 522                 lcd_sleep();
 523                 break;
 524 #endif
 525 #ifdef HAVE_BUTTON_LIGHT
 526             case BUTTON_LIGHT_ON:
 527                 buttonlight_update_state();
 528                 break;
 529             case BUTTON_LIGHT_OFF:
 530                 button_backlight_timer = 0;
 531                 _button_backlight_off();
 532                 break;
 533 #endif
 534
 535 #ifdef X5_BACKLIGHT_SHUTDOWN
 536             case BACKLIGHT_QUIT:
 537                 remove_thread(NULL);
 538                 break;
 539 #endif
 540
 541 #if defined(HAVE_BACKLIGHT_PWM_FADING) && defined(CPU_COLDFIRE) \
 542     && !defined(SIMULATOR)
 543             case BACKLIGHT_UNBOOST_CPU:
 544                 cpu_boost(false);
 545                 break;
 546 #endif
 547
 548             case SYS_USB_CONNECTED:
 549                 /* Tell the USB thread that we are safe */
 550                 DEBUGF("backlight_thread got SYS_USB_CONNECTED\n");
 551                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
 552                 break;
 553
 554             case SYS_USB_DISCONNECTED:
 555                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
 556                 break;
 557         } /* end switch */
 558     } /* end while */
 559 }
 560
 561 static void backlight_tick(void)
 562 {
 563 #if CONFIG_CHARGING
 564     static bool charger_was_inserted = false;
 565     bool charger_is_inserted = charger_inserted()
 566 #ifdef HAVE_USB_POWER
 567         || usb_powered()
 568 #endif
 569         ;
 570
 571     if( charger_was_inserted != charger_is_inserted )
 572     {
 573         backlight_on();
 574 #ifdef HAVE_REMOTE_LCD
 575         remote_backlight_on();
 576 #endif
 577     }
 578     charger_was_inserted = charger_is_inserted;
 579 #endif /* CONFIG_CHARGING */
 580
 581     if(backlight_timer)
 582     {
 583         backlight_timer--;
 584         if(backlight_timer == 0)
 585         {
 586             backlight_off();
 587         }
 588     }
 589 #ifdef HAVE_LCD_SLEEP
 590     else if(lcd_sleep_timer)
 591     {
 592         lcd_sleep_timer--;
 593         if(lcd_sleep_timer == 0)
 594         {
 595             /* Queue on bl thread or freeze! */
 596             queue_post(&backlight_queue, LCD_SLEEP, 0);
 597         }
 598     }
 599 #endif /* HAVE_LCD_SLEEP */
 600
 601 #ifdef HAVE_REMOTE_LCD
 602     if(remote_backlight_timer)
 603     {
 604         remote_backlight_timer--;
 605         if(remote_backlight_timer == 0)
 606         {
 607             remote_backlight_off();
 608         }
 609     }
 610 #endif /* HAVE_REMOVE_LCD */
 611 #ifdef HAVE_BUTTON_LIGHT
 612     if (button_backlight_timer)
 613     {
 614         button_backlight_timer--;
 615         if (button_backlight_timer == 0)
 616         {
 617             button_backlight_off();
 618         }
 619     }
 620 #endif /* HAVE_BUTTON_LIGHT */
 621 }
 622
 623 void backlight_init(void)
 624 {
 625     queue_init(&backlight_queue, true);
 626     queue_set_irq_safe(&backlight_queue, true);
 627
 628 #ifndef SIMULATOR
 629     if (__backlight_init())
 630     {
 631 # ifdef HAVE_BACKLIGHT_PWM_FADING
 632         /* If backlight is already on, don't fade in. */
 633         bl_dim_current = BL_PWM_COUNT;
 634         bl_dim_target = BL_PWM_COUNT;
 635 # endif
 636     }
 637 #endif
 638     backlight_on();
 639 #ifdef HAVE_REMOTE_LCD
 640     remote_backlight_on();
 641 #endif
 642 #ifdef HAVE_BUTTON_LIGHT
 643     button_backlight_on();
 644 #endif
 645
 646     create_thread(backlight_thread, backlight_stack,
 647                   sizeof(backlight_stack), backlight_thread_name
 648                   IF_PRIO(, PRIORITY_SYSTEM)
 649                   IF_COP(, CPU, false));
 650     tick_add_task(backlight_tick);
 651 }
 652
 653 #ifdef X5_BACKLIGHT_SHUTDOWN
 654 void x5_backlight_shutdown(void)
 655 {
 656     /* Turn on the screen and don't let anyone else mess with it. Called
 657        from clean_shutdown in misc.c. */
 658     queue_empty(&backlight_queue);
 659     tick_remove_task(backlight_tick);
 660     /* Next time the thread runs, if at all, it will just remove itself. */
 661     queue_post(&backlight_queue, BACKLIGHT_QUIT, 0);
 662     __backlight_on();
 663 }
 664 #endif /* X5_BACKLIGHT_SHUTDOWN */
 665
 666 void backlight_on(void)
 667 {
 668     queue_remove_from_head(&backlight_queue, BACKLIGHT_ON);
 669     queue_post(&backlight_queue, BACKLIGHT_ON, 0);
 670 }
 671
 672 void backlight_off(void)
 673 {
 674     queue_post(&backlight_queue, BACKLIGHT_OFF, 0);
 675 }
 676
 677 /* returns true when the backlight is on OR when it's set to always off */
 678 bool is_backlight_on(void)
 679 {
 680     if (backlight_timer || backlight_get_current_timeout() <= 0)
 681         return true;
 682     else
 683         return false;
 684 }
 685
 686 /* return value in ticks; 0 means always on, <0 means always off */
 687 int backlight_get_current_timeout(void)
 688 {
 689 #if CONFIG_CHARGING
 690     if (charger_inserted()
 691 #ifdef HAVE_USB_POWER
 692             || usb_powered()
 693 #endif
 694         )
 695         return backlight_timeout_plugged;
 696     else
 697         return backlight_timeout;
 698 #else
 699     return backlight_timeout;
 700 #endif
 701 }
 702
 703 void backlight_set_timeout(int index)
 704 {
 705     if((unsigned)index >= sizeof(backlight_timeout_value))
 706         /* if given a weird value, use default */
 707         index = 6;
 708     backlight_timeout = HZ * backlight_timeout_value[index];
 709     backlight_update_state();
 710 }
 711
 712 #if CONFIG_CHARGING
 713 void backlight_set_timeout_plugged(int index)
 714 {
 715     if((unsigned)index >= sizeof(backlight_timeout_value))
 716         /* if given a weird value, use default */
 717         index = 6;
 718     backlight_timeout_plugged = HZ * backlight_timeout_value[index];
 719     backlight_update_state();
 720 }
 721 #endif /* CONFIG_CHARGING */
 722
 723 #ifdef HAS_BUTTON_HOLD
 724 /* Hold button change event handler. */
 725 void backlight_hold_changed(bool hold_button)
 726 {
 727     /* Hold switch overrides all backlight behavior except when
 728        set to "Normal" */
 729     /* Queue or freeze */
 730     if (hold_button && backlight_on_button_hold == 1)
 731         backlight_off(); /* setting == Off */
 732     else  /* setting == On, Normal, no hold button, or anything else */
 733         backlight_on();
 734 }
 735
 736 void backlight_set_on_button_hold(int index)
 737 {
 738     if ((unsigned)index >= 3)
 739         /* if given a weird value, use default */
 740         index = 0;
 741
 742     if (index == backlight_on_button_hold)
 743         return;
 744
 745     backlight_on_button_hold = index;
 746     backlight_hold_changed(button_hold());
 747 }
 748 #endif /* HAS_BUTTON_HOLD */
 749
 750 #ifdef HAVE_LCD_SLEEP
 751 void lcd_set_sleep_after_backlight_off(int index)
 752 {
 753     if ((unsigned)index >= sizeof(lcd_sleep_timeout_value))
 754         /* if given a weird value, use default */
 755         index = 3;
 756
 757     lcd_sleep_timeout = HZ * lcd_sleep_timeout_value[index];
 758
 759     if (backlight_timer > 0 || backlight_get_current_timeout() == 0)
 760         /* Timer will be set when bl turns off or bl set to on. */
 761         return;
 762
 763     /* Backlight is Off */
 764     if (lcd_sleep_timeout < 0)
 765         lcd_sleep_timer = 1; /* Always - sleep next tick */
 766     else
 767         lcd_sleep_timer = lcd_sleep_timeout; /* Never, other */
 768 }
 769 #endif /* HAVE_LCD_SLEEP */
 770
 771 #ifdef HAVE_REMOTE_LCD
 772 void remote_backlight_on(void)
 773 {
 774     queue_post(&backlight_queue, REMOTE_BACKLIGHT_ON, 0);
 775 }
 776
 777 void remote_backlight_off(void)
 778 {
 779     queue_post(&backlight_queue, REMOTE_BACKLIGHT_OFF, 0);
 780 }
 781
 782 void remote_backlight_set_timeout(int index)
 783 {
 784     if((unsigned)index >= sizeof(backlight_timeout_value))
 785         /* if given a weird value, use default */
 786         index=6;
 787     remote_backlight_timeout = HZ * backlight_timeout_value[index];
 788     remote_backlight_update_state();
 789 }
 790
 791 #if CONFIG_CHARGING
 792 void remote_backlight_set_timeout_plugged(int index)
 793 {
 794     if((unsigned)index >= sizeof(backlight_timeout_value))
 795         /* if given a weird value, use default */
 796         index=6;
 797     remote_backlight_timeout_plugged = HZ * backlight_timeout_value[index];
 798     remote_backlight_update_state();
 799 }
 800 #endif /* CONFIG_CHARGING */
 801
 802 #ifdef HAS_REMOTE_BUTTON_HOLD
 803 /* Remote hold button change event handler. */
 804 void remote_backlight_hold_changed(bool rc_hold_button)
 805 {
 806     /* Hold switch overrides all backlight behavior except when
 807        set to "Normal" */
 808     /* Queue or freeze */
 809     if (rc_hold_button && remote_backlight_on_button_hold == 1)
 810         remote_backlight_off(); /* setting == Off */
 811     else  /* setting == On, Normal, no hold button, or anything else */
 812         remote_backlight_on();
 813 }
 814
 815 void remote_backlight_set_on_button_hold(int index)
 816 {
 817     if ((unsigned)index >= 3)
 818         /* if given a weird value, use default */
 819         index = 0;
 820
 821     if (index == remote_backlight_on_button_hold)
 822         return;
 823
 824     remote_backlight_on_button_hold = index;
 825     remote_backlight_hold_changed(remote_button_hold());
 826 }
 827 #endif /* HAS_REMOTE_BUTTON_HOLD */
 828
 829 /* return value in ticks; 0 means always on, <0 means always off */
 830 int remote_backlight_get_current_timeout(void)
 831 {
 832 #if CONFIG_CHARGING
 833     if (charger_inserted()
 834 #ifdef HAVE_USB_POWER
 835             || usb_powered()
 836 #endif
 837         )
 838         return remote_backlight_timeout_plugged;
 839     else
 840         return remote_backlight_timeout;
 841 #else
 842     return remote_backlight_timeout;
 843 #endif
 844 }
 845
 846 /* returns true when the backlight is on OR when it's set to always off */
 847 bool is_remote_backlight_on(void)
 848 {
 849     if (remote_backlight_timer != 0 ||
 850                     remote_backlight_get_current_timeout() <= 0)
 851         return true;
 852     else
 853         return false;
 854 }
 855
 856 #endif /* HAVE_REMOTE_LCD */
 857
 858 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 859 void backlight_set_brightness(int val)
 860 {
 861     if (val < MIN_BRIGHTNESS_SETTING)
 862         val = MIN_BRIGHTNESS_SETTING;
 863     else if (val > MAX_BRIGHTNESS_SETTING)
 864         val = MAX_BRIGHTNESS_SETTING;
 865
 866     __backlight_set_brightness(val);
 867 }
 868 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
 869
 870 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 871 void buttonlight_set_brightness(int val)
 872 {
 873     if (val < MIN_BRIGHTNESS_SETTING)
 874         val = MIN_BRIGHTNESS_SETTING;
 875     else if (val > MAX_BRIGHTNESS_SETTING)
 876         val = MAX_BRIGHTNESS_SETTING;
 877
 878     __buttonlight_set_brightness(val);
 879 }
 880 #endif /* HAVE_BUTTONLIGHT_BRIGHTNESS */
 881
 882 #else /* !defined(HAVE_BACKLIGHT) || defined(BOOTLOADER)
 883     -- no backlight, empty dummy functions */
 884
 885 #if defined(BOOTLOADER) && defined(HAVE_BACKLIGHT)
 886 void backlight_init(void)
 887 {
 888     (void)__backlight_init();
 889     __backlight_on();
 890 }
 891 #endif
 892
 893 void backlight_on(void) {}
 894 void backlight_off(void) {}
 895 void button_backlight_on(void) {}
 896 void backlight_set_timeout(int index) {(void)index;}
 897 bool is_backlight_on(void) {return true;}
 898 #ifdef HAVE_REMOTE_LCD
 899 void remote_backlight_on(void) {}
 900 void remote_backlight_off(void) {}
 901 void remote_backlight_set_timeout(int index) {(void)index;}
 902 bool is_remote_backlight_on(void) {return true;}
 903 #endif /* HAVE_REMOTE_LCD */
 904 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
 905 void backlight_set_brightness(int val) { (void)val; }
 906 #endif
 907 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 908 void buttonlight_set_brightness(int val) { (void)val; }
 909 #endif
 910 #endif /* defined(HAVE_BACKLIGHT) && !defined(BOOTLOADER) */