1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Linus Nielsen Feltzing
11 * Additional work by Martin Ritter (2007) and Thomas Martitz (2008)
12 * for backlight thread fading
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.
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
22 ****************************************************************************/
36 #include "backlight.h"
38 #include "screendump.h"
40 #ifdef HAVE_REMOTE_LCD
41 #include "lcd-remote.h"
44 #include "backlight-target.h"
47 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
48 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
49 #include "backlight-sw-fading.h"
53 static inline void _backlight_on(void)
58 static inline void _backlight_off(void)
63 static inline void _backlight_set_brightness(int val
)
68 static inline void _buttonlight_on(void)
72 static inline void _buttonlight_off(void)
76 static inline void _buttonlight_set_brightness(int val
)
80 #ifdef HAVE_REMOTE_LCD
81 static inline void _remote_backlight_on(void)
83 sim_remote_backlight(100);
86 static inline void _remote_backlight_off(void)
88 sim_remote_backlight(0);
90 #endif /* HAVE_REMOTE_LCD */
92 #endif /* SIMULATOR */
94 #if defined(HAVE_BACKLIGHT) && defined(BACKLIGHT_FULL_INIT)
96 #define BACKLIGHT_THREAD_TIMEOUT HZ
101 BACKLIGHT_TMO_CHANGED
,
102 #ifdef HAVE_REMOTE_LCD
104 REMOTE_BACKLIGHT_OFF
,
105 REMOTE_BACKLIGHT_TMO_CHANGED
,
107 #if defined(_BACKLIGHT_FADE_BOOST) || defined(_BACKLIGHT_FADE_ENABLE)
108 BACKLIGHT_FADE_FINISH
,
110 #ifdef HAVE_LCD_SLEEP
113 #ifdef HAVE_BUTTON_LIGHT
116 BUTTON_LIGHT_TMO_CHANGED
,
118 #ifdef BACKLIGHT_DRIVER_CLOSE
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;
131 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
132 int backlight_brightness
= DEFAULT_BRIGHTNESS_SETTING
;
134 static int backlight_timer SHAREDBSS_ATTR
;
135 static int backlight_timeout_normal
= 5*HZ
;
137 static int backlight_timeout_plugged
= 5*HZ
;
139 #ifdef HAS_BUTTON_HOLD
140 static int backlight_on_button_hold
= 0;
142 static void backlight_timeout_handler(void);
144 #ifdef HAVE_BUTTON_LIGHT
145 static int buttonlight_timer
;
146 static int buttonlight_timeout
= 5*HZ
;
148 /* Update state of buttonlight according to timeout setting */
149 static void buttonlight_update_state(void)
151 buttonlight_timer
= buttonlight_timeout
;
153 /* Buttonlight == OFF in the setting? */
154 if (buttonlight_timer
< 0)
156 buttonlight_timer
= 0; /* Disable the timeout */
163 /* external interface */
164 void buttonlight_on(void)
166 queue_remove_from_head(&backlight_queue
, BUTTON_LIGHT_ON
);
167 queue_post(&backlight_queue
, BUTTON_LIGHT_ON
, 0);
170 void buttonlight_off(void)
172 queue_post(&backlight_queue
, BUTTON_LIGHT_OFF
, 0);
175 void buttonlight_set_timeout(int value
)
177 buttonlight_timeout
= HZ
* value
;
178 queue_post(&backlight_queue
, BUTTON_LIGHT_TMO_CHANGED
, 0);
181 int buttonlight_get_current_timeout(void)
183 return buttonlight_timeout
;
186 #endif /* HAVE_BUTTON_LIGHT */
188 #ifdef HAVE_REMOTE_LCD
189 static int remote_backlight_timer
;
190 static int remote_backlight_timeout_normal
= 5*HZ
;
192 static int remote_backlight_timeout_plugged
= 5*HZ
;
194 #ifdef HAS_REMOTE_BUTTON_HOLD
195 static int remote_backlight_on_button_hold
= 0;
197 #endif /* HAVE_REMOTE_LCD */
199 #ifdef HAVE_LCD_SLEEP
200 #ifdef HAVE_LCD_SLEEP_SETTING
201 const signed char lcd_sleep_timeout_value
[10] =
203 -1, 0, 5, 10, 15, 20, 30, 45, 60, 90
205 static int lcd_sleep_timeout
= 10*HZ
;
207 /* Target defines needed value */
208 #define lcd_sleep_timeout LCD_SLEEP_TIMEOUT
211 static int lcd_sleep_timer SHAREDDATA_ATTR
= 0;
213 void backlight_lcd_sleep_countdown(bool start
)
217 /* Cancel the LCD sleep countdown */
222 /* Start LCD sleep countdown */
223 if (lcd_sleep_timeout
< 0)
225 lcd_sleep_timer
= 0; /* Setting == Always */
226 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_PWM)
227 /* Ensure lcd_sleep() is called from backlight_thread() */
228 queue_post(&backlight_queue
, LCD_SLEEP
, 0);
235 lcd_sleep_timer
= lcd_sleep_timeout
;
238 #endif /* HAVE_LCD_SLEEP */
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
;
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)
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;
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;
263 static void backlight_isr(void)
265 int timer_period
= (TIMER_FREQ
*BL_PWM_INTERVAL
/1000);
268 switch (bl_dim_state
)
271 case DIM_STATE_START
:
272 bl_dim_current
= bl_dim_fraction
>> 16;
274 if (bl_dim_current
> 0 && bl_dim_current
< BL_PWM_COUNT
)
277 timer_period
= (timer_period
* bl_dim_current
) >> BL_PWM_BITS
;
278 bl_dim_state
= DIM_STATE_MAIN
;
285 _backlight_off_isr();
286 if (bl_dim_current
== bl_dim_target
)
289 if (bl_dim_current
< bl_dim_target
)
291 bl_dim_fraction
= MIN(bl_dim_fraction
+ bl_fade_in_step
,
294 else if (bl_dim_current
> bl_dim_target
)
296 bl_dim_fraction
= MAX(bl_dim_fraction
- bl_fade_out_step
, 0);
300 /* Dim main screen */
302 _backlight_off_isr();
303 timer_period
= (timer_period
* (BL_PWM_COUNT
- bl_dim_current
))
305 bl_dim_state
= DIM_STATE_START
;
310 #if defined(_BACKLIGHT_FADE_BOOST) || defined(_BACKLIGHT_FADE_ENABLE)
311 queue_post(&backlight_queue
, BACKLIGHT_FADE_FINISH
, 0);
314 bl_timer_active
= false;
316 #ifdef HAVE_LCD_SLEEP
317 if (bl_dim_current
== 0)
318 backlight_lcd_sleep_countdown(true);
322 timer_set_period(timer_period
);
325 static void backlight_switch(void)
327 if (bl_dim_target
> (BL_PWM_COUNT
/2))
329 _backlight_on_normal();
330 bl_dim_fraction
= (BL_PWM_COUNT
<<16);
334 _backlight_off_normal();
337 #ifdef HAVE_LCD_SLEEP
338 backlight_lcd_sleep_countdown(true);
343 static void backlight_release_timer(void)
345 #ifdef _BACKLIGHT_FADE_BOOST
349 bl_timer_active
= false;
353 static void backlight_dim(int value
)
355 /* protect from extraneous calls with the same target value */
356 if (value
== bl_dim_target
)
359 bl_dim_target
= value
;
364 if (timer_register(0, backlight_release_timer
, 2, 0, backlight_isr
367 #ifdef _BACKLIGHT_FADE_BOOST
368 /* Prevent cpu frequency changes while dimming. */
371 bl_timer_active
= true;
377 static void _backlight_on(void)
379 #ifdef HAVE_LCD_SLEEP
380 backlight_lcd_sleep_countdown(false);
383 if (bl_fade_in_step
> 0)
385 #ifdef _BACKLIGHT_FADE_ENABLE
386 _backlight_hw_enable(true);
388 backlight_dim(BL_PWM_COUNT
);
392 bl_dim_target
= BL_PWM_COUNT
;
393 bl_dim_fraction
= (BL_PWM_COUNT
<<16);
394 _backlight_on_normal();
398 static void _backlight_off(void)
400 if (bl_fade_out_step
> 0)
406 bl_dim_target
= bl_dim_fraction
= 0;
407 _backlight_off_normal();
409 #ifdef HAVE_LCD_SLEEP
410 backlight_lcd_sleep_countdown(true);
415 void backlight_set_fade_in(int value
)
418 bl_fade_in_step
= ((BL_PWM_INTERVAL
*BL_PWM_COUNT
)<<16) / value
;
423 void backlight_set_fade_out(int value
)
426 bl_fade_out_step
= ((BL_PWM_INTERVAL
*BL_PWM_COUNT
)<<16) / value
;
428 bl_fade_out_step
= 0;
431 #elif (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
432 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
434 void backlight_set_fade_out(bool value
)
437 backlight_fading_type
|= FADING_DOWN
;
439 backlight_fading_type
&= FADING_UP
;
442 void backlight_set_fade_in(bool value
)
445 backlight_fading_type
|= FADING_UP
;
447 backlight_fading_type
&= FADING_DOWN
;
450 static void backlight_setup_fade_up(void)
452 if (backlight_fading_type
& FADING_UP
)
454 if (backlight_fading_state
== NOT_FADING
)
456 /* make sure the backlight is at lowest level */
459 backlight_fading_state
= FADING_UP
;
463 backlight_fading_state
= NOT_FADING
;
464 _backlight_fade_update_state(backlight_brightness
);
466 _backlight_set_brightness(backlight_brightness
);
470 static void backlight_setup_fade_down(void)
472 if (backlight_fading_type
& FADING_DOWN
)
474 backlight_fading_state
= FADING_DOWN
;
478 backlight_fading_state
= NOT_FADING
;
479 _backlight_fade_update_state(MIN_BRIGHTNESS_SETTING
-1);
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
);
488 #endif /* CONFIG_BACKLIGHT_FADING */
490 /* Update state of backlight according to timeout setting */
491 static void backlight_update_state(void)
494 int timeout
= backlight_get_current_timeout();
496 /* Backlight == OFF in the setting? */
497 if (UNLIKELY(timeout
< 0))
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);
511 backlight_timer
= timeout
;
512 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
513 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
514 backlight_setup_fade_up();
521 #ifdef HAVE_REMOTE_LCD
522 /* Update state of remote backlight according to timeout setting */
523 static void remote_backlight_update_state(void)
525 int timeout
= remote_backlight_get_current_timeout();
526 /* Backlight == OFF in the setting? */
529 remote_backlight_timer
= 0; /* Disable the timeout */
530 _remote_backlight_off();
534 remote_backlight_timer
= timeout
;
535 _remote_backlight_on();
538 #endif /* HAVE_REMOTE_LCD */
539 static inline void do_backlight_off(void)
542 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
543 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
544 backlight_setup_fade_down();
547 #endif /* CONFIG_BACKLIGHT_FADING */
550 void backlight_thread(void)
552 struct queue_event ev
;
557 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
558 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
559 if (backlight_fading_state
!= NOT_FADING
)
560 queue_wait_w_tmo(&backlight_queue
, &ev
, FADE_DELAY
);
563 queue_wait_w_tmo(&backlight_queue
, &ev
, BACKLIGHT_THREAD_TIMEOUT
);
565 { /* These events must always be processed */
566 #ifdef _BACKLIGHT_FADE_BOOST
567 case BACKLIGHT_FADE_FINISH
:
571 #ifdef _BACKLIGHT_FADE_ENABLE
572 case BACKLIGHT_FADE_FINISH
:
573 _backlight_hw_enable((bl_dim_current
|bl_dim_target
) != 0);
578 /* Here for now or else the aggressive init messes up scrolling */
579 #ifdef HAVE_REMOTE_LCD
580 case SYS_REMOTE_PLUGGED
:
585 case SYS_REMOTE_UNPLUGGED
:
588 #elif defined HAVE_REMOTE_LCD_AS_MAIN
589 case SYS_REMOTE_PLUGGED
:
594 case SYS_REMOTE_UNPLUGGED
:
597 #endif /* HAVE_REMOTE_LCD/ HAVE_REMOTE_LCD_AS_MAIN */
598 #endif /* !SIMULATOR */
599 case SYS_USB_CONNECTED
:
600 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
603 case SYS_USB_DISCONNECTED
:
604 usb_acknowledge(SYS_USB_DISCONNECTED_ACK
);
607 #ifdef BACKLIGHT_DRIVER_CLOSE
608 /* Get out of here */
617 { /* These events are only processed if backlight isn't locked */
618 #ifdef HAVE_REMOTE_LCD
619 case REMOTE_BACKLIGHT_TMO_CHANGED
:
620 case REMOTE_BACKLIGHT_ON
:
621 remote_backlight_update_state();
624 case REMOTE_BACKLIGHT_OFF
:
625 remote_backlight_timer
= 0; /* Disable the timeout */
626 _remote_backlight_off();
628 #endif /* HAVE_REMOTE_LCD */
630 case BACKLIGHT_TMO_CHANGED
:
632 backlight_update_state();
638 #ifdef HAVE_LCD_SLEEP
643 #ifdef HAVE_BUTTON_LIGHT
644 case BUTTON_LIGHT_TMO_CHANGED
:
645 case BUTTON_LIGHT_ON
:
646 buttonlight_update_state();
649 case BUTTON_LIGHT_OFF
:
650 buttonlight_timer
= 0;
655 case SYS_POWEROFF
: /* Lock backlight on poweroff so it doesn't */
656 locked
= true; /* go off before power is actually cut. */
659 case SYS_CHARGER_CONNECTED
:
660 case SYS_CHARGER_DISCONNECTED
:
662 backlight_update_state();
663 #ifdef HAVE_REMOTE_LCD
664 remote_backlight_update_state();
668 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
669 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
670 if (backlight_fading_state
!= NOT_FADING
)
672 if ((_backlight_fade_step(backlight_fading_state
)))
673 backlight_fading_state
= NOT_FADING
; /* finished fading */
676 #endif /* CONFIG_BACKLIGHT_FADING */
677 backlight_timeout_handler();
683 static void backlight_timeout_handler(void)
685 if(backlight_timer
> 0)
687 backlight_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
688 if(backlight_timer
<= 0)
693 #ifdef HAVE_LCD_SLEEP
694 else if(lcd_sleep_timer
> 0)
696 lcd_sleep_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
697 if(lcd_sleep_timer
<= 0)
702 #endif /* HAVE_LCD_SLEEP */
703 #ifdef HAVE_REMOTE_LCD
704 if(remote_backlight_timer
> 0)
706 remote_backlight_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
707 if(remote_backlight_timer
<= 0)
709 _remote_backlight_off();
712 #endif /* HAVE_REMOVE_LCD */
713 #ifdef HAVE_BUTTON_LIGHT
714 if (buttonlight_timer
> 0)
716 buttonlight_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
717 if (buttonlight_timer
<= 0)
722 #endif /* HAVE_BUTTON_LIGHT */
725 void backlight_init(void)
727 queue_init(&backlight_queue
, true);
730 if (_backlight_init())
732 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_PWM)
733 /* If backlight is already on, don't fade in. */
734 bl_dim_target
= BL_PWM_COUNT
;
735 bl_dim_fraction
= (BL_PWM_COUNT
<<16);
739 /* Leave all lights as set by the bootloader here. The settings load will
740 * call the appropriate backlight_set_*() functions, only changing light
741 * status if necessary. */
742 #ifdef BACKLIGHT_DRIVER_CLOSE
743 backlight_thread_id
=
745 create_thread(backlight_thread
, backlight_stack
,
746 sizeof(backlight_stack
), 0, backlight_thread_name
747 IF_PRIO(, PRIORITY_USER_INTERFACE
)
751 #ifdef BACKLIGHT_DRIVER_CLOSE
752 void backlight_close(void)
754 unsigned int thread
= backlight_thread_id
;
756 /* Wait for thread to exit */
760 backlight_thread_id
= 0;
762 queue_post(&backlight_queue
, BACKLIGHT_QUIT
, 0);
765 #endif /* BACKLIGHT_DRIVER_CLOSE */
767 void backlight_on(void)
769 queue_remove_from_head(&backlight_queue
, BACKLIGHT_ON
);
770 queue_post(&backlight_queue
, BACKLIGHT_ON
, 0);
773 void backlight_off(void)
775 queue_post(&backlight_queue
, BACKLIGHT_OFF
, 0);
778 /* returns true when the backlight is on,
779 * and optionally when it's set to always off. */
780 bool is_backlight_on(bool ignore_always_off
)
782 int timeout
= backlight_get_current_timeout();
783 return (backlight_timer
> 0) /* countdown */
784 || (timeout
== 0) /* always on */
785 || ((timeout
< 0) && !ignore_always_off
);
788 /* return value in ticks; 0 means always on, <0 means always off */
789 int backlight_get_current_timeout(void)
791 #ifdef HAS_BUTTON_HOLD
792 if ((backlight_on_button_hold
!= 0)
793 #ifdef HAVE_REMOTE_LCD_AS_MAIN
794 && remote_button_hold()
799 return (backlight_on_button_hold
== 2) ? 0 : -1;
800 /* always on or always off */
804 if (power_input_present())
805 return backlight_timeout_plugged
;
808 return backlight_timeout_normal
;
811 void backlight_set_timeout(int value
)
813 backlight_timeout_normal
= HZ
* value
;
814 queue_post(&backlight_queue
, BACKLIGHT_TMO_CHANGED
, 0);
818 void backlight_set_timeout_plugged(int value
)
820 backlight_timeout_plugged
= HZ
* value
;
821 queue_post(&backlight_queue
, BACKLIGHT_TMO_CHANGED
, 0);
823 #endif /* CONFIG_CHARGING */
825 #ifdef HAS_BUTTON_HOLD
826 /* Hold button change event handler. */
827 void backlight_hold_changed(bool hold_button
)
829 if (!hold_button
|| (backlight_on_button_hold
> 0))
830 /* if unlocked or override in effect */
834 void backlight_set_on_button_hold(int index
)
836 if ((unsigned)index
>= 3)
837 /* if given a weird value, use default */
840 backlight_on_button_hold
= index
;
841 queue_post(&backlight_queue
, BACKLIGHT_TMO_CHANGED
, 0);
843 #endif /* HAS_BUTTON_HOLD */
845 #ifdef HAVE_LCD_SLEEP_SETTING
846 void lcd_set_sleep_after_backlight_off(int index
)
848 if ((unsigned)index
>= sizeof(lcd_sleep_timeout_value
))
849 /* if given a weird value, use default */
852 lcd_sleep_timeout
= HZ
* lcd_sleep_timeout_value
[index
];
854 if (backlight_timer
> 0 || backlight_get_current_timeout() == 0)
855 /* Timer will be set when bl turns off or bl set to on. */
858 /* Backlight is Off */
859 if (lcd_sleep_timeout
< 0)
860 lcd_sleep_timer
= 1; /* Always - sleep next tick */
862 lcd_sleep_timer
= lcd_sleep_timeout
; /* Never, other */
864 #endif /* HAVE_LCD_SLEEP_SETTING */
866 #ifdef HAVE_REMOTE_LCD
867 void remote_backlight_on(void)
869 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_ON
, 0);
872 void remote_backlight_off(void)
874 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_OFF
, 0);
877 void remote_backlight_set_timeout(int value
)
879 remote_backlight_timeout_normal
= HZ
* value
;
880 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_TMO_CHANGED
, 0);
884 void remote_backlight_set_timeout_plugged(int value
)
886 remote_backlight_timeout_plugged
= HZ
* value
;
887 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_TMO_CHANGED
, 0);
889 #endif /* CONFIG_CHARGING */
891 #ifdef HAS_REMOTE_BUTTON_HOLD
892 /* Remote hold button change event handler. */
893 void remote_backlight_hold_changed(bool rc_hold_button
)
895 if (!rc_hold_button
|| (remote_backlight_on_button_hold
> 0))
896 /* if unlocked or override */
897 remote_backlight_on();
900 void remote_backlight_set_on_button_hold(int index
)
902 if ((unsigned)index
>= 3)
903 /* if given a weird value, use default */
906 remote_backlight_on_button_hold
= index
;
907 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_TMO_CHANGED
, 0);
909 #endif /* HAS_REMOTE_BUTTON_HOLD */
911 /* return value in ticks; 0 means always on, <0 means always off */
912 int remote_backlight_get_current_timeout(void)
914 #ifdef HAS_REMOTE_BUTTON_HOLD
915 if (remote_button_hold() && (remote_backlight_on_button_hold
!= 0))
916 return (remote_backlight_on_button_hold
== 2)
917 ? 0 : -1; /* always on or always off */
921 if (power_input_present())
922 return remote_backlight_timeout_plugged
;
925 return remote_backlight_timeout_normal
;
928 /* returns true when the backlight is on, and
929 * optionally when it's set to always off */
930 bool is_remote_backlight_on(bool ignore_always_off
)
932 int timeout
= remote_backlight_get_current_timeout();
933 return (remote_backlight_timer
> 0) /* countdown */
934 || (timeout
== 0) /* always on */
935 || ((timeout
< 0) && !ignore_always_off
);
938 #endif /* HAVE_REMOTE_LCD */
940 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
941 void backlight_set_brightness(int val
)
943 if (val
< MIN_BRIGHTNESS_SETTING
)
944 val
= MIN_BRIGHTNESS_SETTING
;
945 else if (val
> MAX_BRIGHTNESS_SETTING
)
946 val
= MAX_BRIGHTNESS_SETTING
;
948 backlight_brightness
= val
;
949 _backlight_set_brightness(val
);
950 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
951 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
952 /* receive backlight brightness */
953 _backlight_fade_update_state(val
);
956 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
958 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
959 void buttonlight_set_brightness(int val
)
961 if (val
< MIN_BRIGHTNESS_SETTING
)
962 val
= MIN_BRIGHTNESS_SETTING
;
963 else if (val
> MAX_BRIGHTNESS_SETTING
)
964 val
= MAX_BRIGHTNESS_SETTING
;
966 _buttonlight_set_brightness(val
);
968 #endif /* HAVE_BUTTONLIGHT_BRIGHTNESS */
970 #else /* !defined(HAVE_BACKLIGHT) || !defined(BACKLIGHT_FULL_INIT)
971 -- no backlight, empty dummy functions */
973 #if defined(HAVE_BACKLIGHT) && !defined(BACKLIGHT_FULL_INIT)
974 void backlight_init(void)
976 (void)_backlight_init();
981 void backlight_on(void) {}
982 void backlight_off(void) {}
983 void buttonlight_on(void) {}
984 void backlight_set_timeout(int value
) {(void)value
;}
986 bool is_backlight_on(bool ignore_always_off
)
988 (void)ignore_always_off
;
991 #ifdef HAVE_REMOTE_LCD
992 void remote_backlight_on(void) {}
993 void remote_backlight_off(void) {}
994 void remote_backlight_set_timeout(int value
) {(void)value
;}
996 bool is_remote_backlight_on(bool ignore_always_off
)
998 (void)ignore_always_off
;
1001 #endif /* HAVE_REMOTE_LCD */
1002 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
1003 void backlight_set_brightness(int val
) { (void)val
; }
1005 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
1006 void buttonlight_set_brightness(int val
) { (void)val
; }
1008 #endif /* defined(HAVE_BACKLIGHT) && defined(BACKLIGHT_FULL_INIT) */