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 static 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 /* Ensure lcd_sleep() is called from backlight_thread() */
227 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_PWM)
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 if (bl_fade_in_step
> 0)
381 #ifdef _BACKLIGHT_FADE_ENABLE
382 _backlight_hw_enable(true);
384 backlight_dim(BL_PWM_COUNT
);
388 bl_dim_target
= BL_PWM_COUNT
;
389 bl_dim_fraction
= (BL_PWM_COUNT
<<16);
390 _backlight_on_normal();
394 static void _backlight_off(void)
396 if (bl_fade_out_step
> 0)
402 bl_dim_target
= bl_dim_fraction
= 0;
403 _backlight_off_normal();
407 void backlight_set_fade_in(int value
)
410 bl_fade_in_step
= ((BL_PWM_INTERVAL
*BL_PWM_COUNT
)<<16) / value
;
415 void backlight_set_fade_out(int value
)
418 bl_fade_out_step
= ((BL_PWM_INTERVAL
*BL_PWM_COUNT
)<<16) / value
;
420 bl_fade_out_step
= 0;
423 #elif (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
424 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
426 void backlight_set_fade_out(bool value
)
429 backlight_fading_type
|= FADING_DOWN
;
431 backlight_fading_type
&= FADING_UP
;
434 void backlight_set_fade_in(bool value
)
437 backlight_fading_type
|= FADING_UP
;
439 backlight_fading_type
&= FADING_DOWN
;
442 static void backlight_setup_fade_up(void)
444 if (backlight_fading_type
& FADING_UP
)
446 if (backlight_fading_state
== NOT_FADING
)
448 /* make sure the backlight is at lowest level */
451 backlight_fading_state
= FADING_UP
;
455 backlight_fading_state
= NOT_FADING
;
456 _backlight_fade_update_state(backlight_brightness
);
458 _backlight_set_brightness(backlight_brightness
);
462 static void backlight_setup_fade_down(void)
464 if (backlight_fading_type
& FADING_DOWN
)
466 backlight_fading_state
= FADING_DOWN
;
470 backlight_fading_state
= NOT_FADING
;
471 _backlight_fade_update_state(MIN_BRIGHTNESS_SETTING
-1);
473 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
474 /* write the lowest brightness level to the hardware so that
475 * fading up is glitch free */
476 _backlight_set_brightness(MIN_BRIGHTNESS_SETTING
);
480 #endif /* CONFIG_BACKLIGHT_FADING */
482 /* Update state of backlight according to timeout setting */
483 static void backlight_update_state(void)
486 int timeout
= backlight_get_current_timeout();
488 /* Backlight == OFF in the setting? */
489 if (UNLIKELY(timeout
< 0))
491 backlight_timer
= 0; /* Disable the timeout */
492 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
493 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
494 backlight_setup_fade_down();
495 /* necessary step to issue fading down when the setting is selected */
496 queue_post(&backlight_queue
, SYS_TIMEOUT
, 0);
499 #ifdef HAVE_LCD_SLEEP
500 backlight_lcd_sleep_countdown(true); /* start sleep countdown */
506 backlight_timer
= timeout
;
508 #ifdef HAVE_LCD_SLEEP
509 backlight_lcd_sleep_countdown(false); /* wake up lcd */
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 { /* finished fading */
674 #ifdef HAVE_LCD_SLEEP
675 if (backlight_fading_state
== FADING_DOWN
)
676 { /* start sleep countdown */
677 backlight_lcd_sleep_countdown(true);
680 backlight_fading_state
= NOT_FADING
;
684 #endif /* CONFIG_BACKLIGHT_FADING */
685 backlight_timeout_handler();
691 static void backlight_timeout_handler(void)
693 if(backlight_timer
> 0)
695 backlight_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
696 if(backlight_timer
<= 0)
701 #ifdef HAVE_LCD_SLEEP
702 else if(lcd_sleep_timer
> 0)
704 lcd_sleep_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
705 if(lcd_sleep_timer
<= 0)
710 #endif /* HAVE_LCD_SLEEP */
711 #ifdef HAVE_REMOTE_LCD
712 if(remote_backlight_timer
> 0)
714 remote_backlight_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
715 if(remote_backlight_timer
<= 0)
717 _remote_backlight_off();
720 #endif /* HAVE_REMOVE_LCD */
721 #ifdef HAVE_BUTTON_LIGHT
722 if (buttonlight_timer
> 0)
724 buttonlight_timer
-= BACKLIGHT_THREAD_TIMEOUT
;
725 if (buttonlight_timer
<= 0)
730 #endif /* HAVE_BUTTON_LIGHT */
733 void backlight_init(void)
735 queue_init(&backlight_queue
, true);
738 if (_backlight_init())
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);
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
=
753 create_thread(backlight_thread
, backlight_stack
,
754 sizeof(backlight_stack
), 0, backlight_thread_name
755 IF_PRIO(, PRIORITY_USER_INTERFACE
)
759 #ifdef BACKLIGHT_DRIVER_CLOSE
760 void backlight_close(void)
762 unsigned int thread
= backlight_thread_id
;
764 /* Wait for thread to exit */
768 backlight_thread_id
= 0;
770 queue_post(&backlight_queue
, BACKLIGHT_QUIT
, 0);
773 #endif /* BACKLIGHT_DRIVER_CLOSE */
775 void backlight_on(void)
777 queue_remove_from_head(&backlight_queue
, BACKLIGHT_ON
);
778 queue_post(&backlight_queue
, BACKLIGHT_ON
, 0);
781 void backlight_off(void)
783 queue_post(&backlight_queue
, BACKLIGHT_OFF
, 0);
786 /* returns true when the backlight is on,
787 * and optionally when it's set to always off. */
788 bool is_backlight_on(bool ignore_always_off
)
790 int timeout
= backlight_get_current_timeout();
791 return (backlight_timer
> 0) /* countdown */
792 || (timeout
== 0) /* always on */
793 || ((timeout
< 0) && !ignore_always_off
);
796 /* return value in ticks; 0 means always on, <0 means always off */
797 int backlight_get_current_timeout(void)
799 #ifdef HAS_BUTTON_HOLD
800 if ((backlight_on_button_hold
!= 0)
801 #ifdef HAVE_REMOTE_LCD_AS_MAIN
802 && remote_button_hold()
807 return (backlight_on_button_hold
== 2) ? 0 : -1;
808 /* always on or always off */
812 if (power_input_present())
813 return backlight_timeout_plugged
;
816 return backlight_timeout_normal
;
819 void backlight_set_timeout(int value
)
821 backlight_timeout_normal
= HZ
* value
;
822 queue_post(&backlight_queue
, BACKLIGHT_TMO_CHANGED
, 0);
826 void backlight_set_timeout_plugged(int value
)
828 backlight_timeout_plugged
= HZ
* value
;
829 queue_post(&backlight_queue
, BACKLIGHT_TMO_CHANGED
, 0);
831 #endif /* CONFIG_CHARGING */
833 #ifdef HAS_BUTTON_HOLD
834 /* Hold button change event handler. */
835 void backlight_hold_changed(bool hold_button
)
837 if (!hold_button
|| (backlight_on_button_hold
> 0))
838 /* if unlocked or override in effect */
842 void backlight_set_on_button_hold(int index
)
844 if ((unsigned)index
>= 3)
845 /* if given a weird value, use default */
848 backlight_on_button_hold
= index
;
849 queue_post(&backlight_queue
, BACKLIGHT_TMO_CHANGED
, 0);
851 #endif /* HAS_BUTTON_HOLD */
853 #ifdef HAVE_LCD_SLEEP_SETTING
854 void lcd_set_sleep_after_backlight_off(int index
)
856 if ((unsigned)index
>= sizeof(lcd_sleep_timeout_value
))
857 /* if given a weird value, use default */
860 lcd_sleep_timeout
= HZ
* lcd_sleep_timeout_value
[index
];
862 if (is_backlight_on(true))
863 /* Timer will be set when bl turns off or bl set to on. */
866 /* Backlight is Off */
867 if (lcd_sleep_timeout
< 0)
868 lcd_sleep_timer
= 1; /* Always - sleep next tick */
870 lcd_sleep_timer
= lcd_sleep_timeout
; /* Never, other */
872 #endif /* HAVE_LCD_SLEEP_SETTING */
874 #ifdef HAVE_REMOTE_LCD
875 void remote_backlight_on(void)
877 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_ON
, 0);
880 void remote_backlight_off(void)
882 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_OFF
, 0);
885 void remote_backlight_set_timeout(int value
)
887 remote_backlight_timeout_normal
= HZ
* value
;
888 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_TMO_CHANGED
, 0);
892 void remote_backlight_set_timeout_plugged(int value
)
894 remote_backlight_timeout_plugged
= HZ
* value
;
895 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_TMO_CHANGED
, 0);
897 #endif /* CONFIG_CHARGING */
899 #ifdef HAS_REMOTE_BUTTON_HOLD
900 /* Remote hold button change event handler. */
901 void remote_backlight_hold_changed(bool rc_hold_button
)
903 if (!rc_hold_button
|| (remote_backlight_on_button_hold
> 0))
904 /* if unlocked or override */
905 remote_backlight_on();
908 void remote_backlight_set_on_button_hold(int index
)
910 if ((unsigned)index
>= 3)
911 /* if given a weird value, use default */
914 remote_backlight_on_button_hold
= index
;
915 queue_post(&backlight_queue
, REMOTE_BACKLIGHT_TMO_CHANGED
, 0);
917 #endif /* HAS_REMOTE_BUTTON_HOLD */
919 /* return value in ticks; 0 means always on, <0 means always off */
920 int remote_backlight_get_current_timeout(void)
922 #ifdef HAS_REMOTE_BUTTON_HOLD
923 if (remote_button_hold() && (remote_backlight_on_button_hold
!= 0))
924 return (remote_backlight_on_button_hold
== 2)
925 ? 0 : -1; /* always on or always off */
929 if (power_input_present())
930 return remote_backlight_timeout_plugged
;
933 return remote_backlight_timeout_normal
;
936 /* returns true when the backlight is on, and
937 * optionally when it's set to always off */
938 bool is_remote_backlight_on(bool ignore_always_off
)
940 int timeout
= remote_backlight_get_current_timeout();
941 return (remote_backlight_timer
> 0) /* countdown */
942 || (timeout
== 0) /* always on */
943 || ((timeout
< 0) && !ignore_always_off
);
946 #endif /* HAVE_REMOTE_LCD */
948 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
949 void backlight_set_brightness(int val
)
951 if (val
< MIN_BRIGHTNESS_SETTING
)
952 val
= MIN_BRIGHTNESS_SETTING
;
953 else if (val
> MAX_BRIGHTNESS_SETTING
)
954 val
= MAX_BRIGHTNESS_SETTING
;
956 backlight_brightness
= val
;
957 _backlight_set_brightness(val
);
958 #if (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_SETTING) \
959 || (CONFIG_BACKLIGHT_FADING == BACKLIGHT_FADING_SW_HW_REG)
960 /* receive backlight brightness */
961 _backlight_fade_update_state(val
);
964 #endif /* HAVE_BACKLIGHT_BRIGHTNESS */
966 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
967 void buttonlight_set_brightness(int val
)
969 if (val
< MIN_BRIGHTNESS_SETTING
)
970 val
= MIN_BRIGHTNESS_SETTING
;
971 else if (val
> MAX_BRIGHTNESS_SETTING
)
972 val
= MAX_BRIGHTNESS_SETTING
;
974 _buttonlight_set_brightness(val
);
976 #endif /* HAVE_BUTTONLIGHT_BRIGHTNESS */
978 #else /* !defined(HAVE_BACKLIGHT) || !defined(BACKLIGHT_FULL_INIT)
979 -- no backlight, empty dummy functions */
981 #if defined(HAVE_BACKLIGHT) && !defined(BACKLIGHT_FULL_INIT)
982 void backlight_init(void)
984 (void)_backlight_init();
989 void backlight_on(void) {}
990 void backlight_off(void) {}
991 void buttonlight_on(void) {}
992 void backlight_set_timeout(int value
) {(void)value
;}
994 bool is_backlight_on(bool ignore_always_off
)
996 (void)ignore_always_off
;
999 #ifdef HAVE_REMOTE_LCD
1000 void remote_backlight_on(void) {}
1001 void remote_backlight_off(void) {}
1002 void remote_backlight_set_timeout(int value
) {(void)value
;}
1004 bool is_remote_backlight_on(bool ignore_always_off
)
1006 (void)ignore_always_off
;
1009 #endif /* HAVE_REMOTE_LCD */
1010 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
1011 void backlight_set_brightness(int val
) { (void)val
; }
1013 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
1014 void buttonlight_set_brightness(int val
) { (void)val
; }
1016 #endif /* defined(HAVE_BACKLIGHT) && defined(BACKLIGHT_FULL_INIT) */