/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Copyright (C) 2002 by Linus Nielsen Feltzing * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ #include "config.h" #include #include "cpu.h" #include "kernel.h" #include "thread.h" #include "i2c.h" #include "debug.h" #include "rtc.h" #include "usb.h" #include "power.h" #include "system.h" #ifdef HAVE_REMOTE_LCD #include "lcd-remote.h" #endif #if defined(CONFIG_BACKLIGHT) && !defined(BOOTLOADER) const char backlight_timeout_value[19] = { -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 45, 60, 90 }; #define BACKLIGHT_ON 1 #define BACKLIGHT_OFF 2 #define REMOTE_BACKLIGHT_ON 3 #define REMOTE_BACKLIGHT_OFF 4 static void backlight_thread(void); static long backlight_stack[DEFAULT_STACK_SIZE/sizeof(long)]; static const char backlight_thread_name[] = "backlight"; static struct event_queue backlight_queue; static bool charger_was_inserted = 0; static bool backlight_on_when_charging = 0; static int backlight_timer; static unsigned int backlight_timeout = 5; #ifdef HAVE_REMOTE_LCD static int remote_backlight_timer; static unsigned int remote_backlight_timeout = 5; #endif #if CONFIG_BACKLIGHT == BL_IRIVER /* backlight fading */ #define BL_PWM_INTERVAL 5000 /* Cycle interval in µs */ #define BL_PWM_COUNT 100 static const char backlight_fade_value[8] = { 0, 1, 2, 4, 6, 8, 10, 20 }; static int fade_in_count = 1; static int fade_out_count = 4; static bool timer_allowed = true; static bool bl_timer_active = false; static int bl_dim_current = BL_PWM_COUNT; static int bl_dim_target = BL_PWM_COUNT; static int bl_pwm_counter = 0; static volatile int bl_cycle_counter = 0; static enum {DIM_STATE_START, DIM_STATE_MAIN} bl_dim_state = DIM_STATE_START; void backlight_start_timer(void) { unsigned int count; if (bl_timer_active) return ; /* Prevent cpu frequency changes while dimming. */ cpu_boost(true); count = 1; bl_timer_active = true; /* We are using timer 1 */ TRR1 = count; /* The reference count */ TCN1 = 0; /* reset the timer */ TMR1 = 0x011d; /* prescaler=2, restart, CLK/16, enabled */ TER1 = 0xff; /* Clear all events */ /* ICR2 (Timer2) */ ICR0 = (ICR0 & 0xffff00ff) | 0x00009000; /* Interrupt on level 4.0 */ IMR &= ~(1<<10); } void TIMER1(void) __attribute__ ((interrupt_handler)); void TIMER1(void) { int timer_period; bool idle = false; timer_period = FREQ / 2000 * BL_PWM_INTERVAL / 1000 / 32; switch (bl_dim_state) { /* New cycle */ case DIM_STATE_START: bl_pwm_counter = 0; bl_cycle_counter++; if (bl_dim_current > 0 && bl_dim_current < BL_PWM_COUNT) { and_l(~0x00020000, &GPIO1_OUT); bl_pwm_counter = bl_dim_current; timer_period = timer_period * bl_pwm_counter / BL_PWM_COUNT; bl_dim_state = DIM_STATE_MAIN; } else { if (bl_dim_current) and_l(~0x00020000, &GPIO1_OUT); else or_l(0x00020000, &GPIO1_OUT); if (bl_dim_current == bl_dim_target) idle = true; } break ; /* Dim main screen */ case DIM_STATE_MAIN: or_l(0x00020000, &GPIO1_OUT); bl_dim_state = DIM_STATE_START; timer_period = timer_period * (BL_PWM_COUNT - bl_pwm_counter) / BL_PWM_COUNT; break ; } if ((bl_dim_target > bl_dim_current) && (bl_cycle_counter >= fade_in_count)) { bl_dim_current++; bl_cycle_counter = 0; } if ((bl_dim_target < bl_dim_current) && (bl_cycle_counter >= fade_out_count)) { bl_dim_current--; bl_cycle_counter = 0; } if (idle) { cpu_boost(false); bl_timer_active = false; TMR1 = 0; } TRR1 = timer_period; TCN1 = 0; TER1 = 0xff; /* Clear all events */ } static void __backlight_dim(int value) { bl_dim_target = value; backlight_start_timer(); } void backlight_allow_timer(bool on) { timer_allowed = on; if (!timer_allowed && bl_timer_active) { cpu_boost(false); bl_dim_current = bl_dim_target; bl_timer_active = false; TMR1 = 0; if (bl_dim_current) and_l(~0x00020000, &GPIO1_OUT); else or_l(0x00020000, &GPIO1_OUT); } } void backlight_set_fade_in(int index) { fade_in_count = backlight_fade_value[index]; } void backlight_set_fade_out(int index) { fade_out_count = backlight_fade_value[index]; } #endif static void __backlight_off(void) { #if CONFIG_BACKLIGHT == BL_IRIVER if (timer_allowed && (fade_out_count > 0)) __backlight_dim(0); else { bl_dim_target = bl_dim_current = 0; or_l(0x00020000, &GPIO1_OUT); } #elif CONFIG_BACKLIGHT == BL_RTC /* Disable square wave */ rtc_write(0x0a, rtc_read(0x0a) & ~0x40); #elif CONFIG_BACKLIGHT == BL_PA14_LO /* Player */ and_b(~0x40, &PAIORH); /* let it float (up) */ #elif CONFIG_BACKLIGHT == BL_PA14_HI /* Ondio */ and_b(~0x40, &PADRH); /* drive it low */ #elif CONFIG_BACKLIGHT == BL_GMINI P1 &= ~0x10; #endif } static void __backlight_on(void) { #if CONFIG_BACKLIGHT == BL_IRIVER if (timer_allowed && (fade_in_count > 0)) __backlight_dim(BL_PWM_COUNT); else { bl_dim_target = bl_dim_current = BL_PWM_COUNT; and_l(~0x00020000, &GPIO1_OUT); } #elif CONFIG_BACKLIGHT == BL_RTC /* Enable square wave */ rtc_write(0x0a, rtc_read(0x0a) | 0x40); #elif CONFIG_BACKLIGHT == BL_PA14_LO /* Player */ and_b(~0x40, &PADRH); /* drive and set low */ or_b(0x40, &PAIORH); #elif CONFIG_BACKLIGHT == BL_PA14_HI /* Ondio */ or_b(0x40, &PADRH); /* drive it high */ #elif CONFIG_BACKLIGHT == BL_GMINI P1 |= 0x10; #endif } void backlight_thread(void) { struct event ev; while(1) { queue_wait(&backlight_queue, &ev); switch(ev.id) { #ifdef HAVE_REMOTE_LCD case REMOTE_BACKLIGHT_ON: remote_backlight_timer = HZ*backlight_timeout_value[remote_backlight_timeout]; /* Backlight == OFF in the setting? */ if(remote_backlight_timer < 0) { remote_backlight_timer = 0; /* Disable the timeout */ lcd_remote_backlight_off(); } else { lcd_remote_backlight_on(); } break; case REMOTE_BACKLIGHT_OFF: lcd_remote_backlight_off(); break; #endif case BACKLIGHT_ON: if( backlight_on_when_charging && charger_inserted() ) { /* Forcing to zero keeps the lights on */ backlight_timer = 0; } else { backlight_timer = HZ*backlight_timeout_value[backlight_timeout]; } if(backlight_timer < 0) /* Backlight == OFF in the setting? */ { backlight_timer = 0; /* Disable the timeout */ __backlight_off(); } else { __backlight_on(); } break; case BACKLIGHT_OFF: __backlight_off(); break; case SYS_USB_CONNECTED: /* Tell the USB thread that we are safe */ DEBUGF("backlight_thread got SYS_USB_CONNECTED\n"); usb_acknowledge(SYS_USB_CONNECTED_ACK); break; case SYS_USB_DISCONNECTED: usb_acknowledge(SYS_USB_DISCONNECTED_ACK); break; } } } void backlight_on(void) { queue_post(&backlight_queue, BACKLIGHT_ON, NULL); } void backlight_off(void) { queue_post(&backlight_queue, BACKLIGHT_OFF, NULL); } #ifdef HAVE_REMOTE_LCD void remote_backlight_on(void) { queue_post(&backlight_queue, REMOTE_BACKLIGHT_ON, NULL); } void remote_backlight_off(void) { queue_post(&backlight_queue, REMOTE_BACKLIGHT_OFF, NULL); } void remote_backlight_set_timeout(int index) { if((unsigned)index >= sizeof(backlight_timeout_value)) /* if given a weird value, use 0 */ index=0; remote_backlight_timeout = index; /* index in the backlight_timeout_value table */ remote_backlight_on(); } #endif int backlight_get_timeout(void) { return backlight_timeout; } void backlight_set_timeout(int index) { if((unsigned)index >= sizeof(backlight_timeout_value)) /* if given a weird value, use 0 */ index=0; backlight_timeout = index; /* index in the backlight_timeout_value table */ backlight_on(); } #ifdef HAVE_CHARGE_CTRL bool backlight_get_on_when_charging(void) { return backlight_on_when_charging; } #endif void backlight_set_on_when_charging(bool yesno) { backlight_on_when_charging = yesno; backlight_on(); } void backlight_tick(void) { bool charger_is_inserted = charger_inserted(); if( backlight_on_when_charging && (charger_was_inserted != charger_is_inserted) ) { backlight_on(); } charger_was_inserted = charger_is_inserted; if(backlight_timer) { backlight_timer--; if(backlight_timer == 0) { backlight_off(); } } #ifdef HAVE_REMOTE_LCD if(remote_backlight_timer) { remote_backlight_timer--; if(remote_backlight_timer == 0) { remote_backlight_off(); } } #endif } void backlight_init(void) { queue_init(&backlight_queue); create_thread(backlight_thread, backlight_stack, sizeof(backlight_stack), backlight_thread_name); #if CONFIG_BACKLIGHT == BL_IRIVER or_l(0x00020000, &GPIO1_ENABLE); or_l(0x00020000, &GPIO1_FUNCTION); #elif CONFIG_BACKLIGHT == BL_PA14_LO || CONFIG_BACKLIGHT == BL_PA14_HI PACR1 &= ~0x3000; /* Set PA14 (backlight control) to GPIO */ or_b(0x40, &PAIORH); /* ..and output */ #elif CONFIG_BACKLIGHT == BL_GMINI P1CON |= 0x10; /* P1.4 C-MOS output mode */ #endif backlight_on(); #ifdef HAVE_REMOTE_LCD remote_backlight_on(); #endif } #else /* no backlight, empty dummy functions */ void backlight_init(void) {} void backlight_on(void) {} void backlight_off(void) {} void backlight_tick(void) {} int backlight_get_timeout(void) {return 0;} void backlight_set_timeout(int index) {(void)index;} void backlight_set_on_when_charging(bool yesno) {(void)yesno;} #ifdef HAVE_REMOTE_LCD void remote_backlight_on(void) {} void remote_backlight_off(void) {} void remote_backlight_set_timeout(int index) {(void)index;} #endif #endif /* #ifdef CONFIG_BACKLIGHT */