/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Copyright (C) 2002 by Daniel Stenberg * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ /* * Rockbox button functions */ #include #include "config.h" #include "system.h" #include "button.h" #include "kernel.h" #include "thread.h" #include "backlight.h" #include "serial.h" #include "power.h" #include "powermgmt.h" #ifdef HAVE_SDL #include "button-sdl.h" #else #include "button-target.h" #endif #ifdef HAVE_REMOTE_LCD #include "lcd-remote.h" #endif #if defined(HAVE_TRANSFLECTIVE_LCD) && defined(HAVE_LCD_SLEEP) #include "lcd.h" /* lcd_active() prototype */ #endif struct event_queue button_queue SHAREDBSS_ATTR; static long lastbtn; /* Last valid button status */ static long last_read; /* Last button status, for debouncing/filtering */ static intptr_t button_data; /* data value from last message dequeued */ static bool flipped; /* buttons can be flipped to match the LCD flip */ #ifdef HAVE_BACKLIGHT /* Filter first keypress function pointer */ static bool (*keypress_filter_fn)(int, int); #ifdef HAVE_REMOTE_LCD static bool (*remote_keypress_filter_fn)(int, int); #endif #endif /* HAVE_BACKLIGHT */ #ifdef HAVE_SW_POWEROFF static bool enable_sw_poweroff = true; #endif /* how long until repeat kicks in, in centiseconds */ #define REPEAT_START (30*HZ/100) /* The next two make repeat "accelerate", which is nice for lists * which begin to scroll a bit faster when holding until the * real list acceleration kicks in (this smooths acceleration). * * Note that touchscreen pointing events are not subject to this * acceleration and always use REPEAT_INTERVAL_TOUCH. (Do repeat * events even do anything sane for touchscreens??) */ /* the speed repeat starts at, in centiseconds */ #define REPEAT_INTERVAL_START (16*HZ/100) /* speed repeat finishes at, in centiseconds */ #define REPEAT_INTERVAL_FINISH (5*HZ/100) /* repeat interval for touch events */ #define REPEAT_INTERVAL_TOUCH (5*HZ/100) static int lastdata = 0; static int button_read(int *data); #ifdef HAVE_TOUCHSCREEN static long last_touchscreen_touch; #endif static void button_remote_post(void) { #if defined(HAS_SERIAL_REMOTE) && !defined(SIMULATOR) /* Post events for the remote control */ int btn = remote_control_rx(); if(btn) button_try_post(btn, 0); #endif } #if defined(HAVE_HEADPHONE_DETECTION) static int hp_detect_callback(struct timeout *tmo) { /* Try to post only transistions */ const long id = tmo->data ? SYS_PHONE_PLUGGED : SYS_PHONE_UNPLUGGED; queue_remove_from_head(&button_queue, id); queue_post(&button_queue, id, 0); return 0; /*misc.c:hp_unplug_change*/ } #endif #if defined(HAVE_LINEOUT_DETECTION) static int lo_detect_callback(struct timeout *tmo) { /* Try to post only transistions */ const long id = tmo->data ? SYS_LINEOUT_PLUGGED : SYS_LINEOUT_UNPLUGGED; queue_remove_from_head(&button_queue, id); queue_post(&button_queue, id, 0); return 0; /*misc.c:lo_unplug_change*/ } #endif static void check_audio_peripheral_state(void) { #if defined(HAVE_HEADPHONE_DETECTION) static struct timeout hp_detect_timeout; /* Debouncer for headphone plug/unplug */ static bool phones_present = false; if (headphones_inserted() != phones_present) { /* Use the autoresetting oneshot to debounce the detection signal */ phones_present = !phones_present; timeout_register(&hp_detect_timeout, hp_detect_callback, HZ/2, phones_present); } #endif #if defined(HAVE_LINEOUT_DETECTION) static struct timeout lo_detect_timeout; /* Debouncer for lineout plug/unplug */ static bool lineout_present = false; if (lineout_inserted() != lineout_present) { /* Use the autoresetting oneshot to debounce the detection signal */ lineout_present = !lineout_present; timeout_register(&lo_detect_timeout, lo_detect_callback, HZ/2, lineout_present); } #endif } static bool button_try_post(int button, int data) { #ifdef HAVE_TOUCHSCREEN /* one can swipe over the scren very quickly, * for this to work we want to forget about old presses and * only respect the very latest ones */ const bool force_post = true; #else /* Only post events if the queue is empty, * to avoid afterscroll effects. * i.e. don't post new buttons if previous ones haven't been * processed yet - but always post releases */ const bool force_post = button & BUTTON_REL; #endif bool ret = queue_empty(&button_queue); if (!ret && force_post) { queue_remove_from_head(&button_queue, button); ret = true; } if (ret) queue_post(&button_queue, button, data); /* on touchscreen we posted unconditionally */ return ret; } #ifdef HAVE_BACKLIGHT /* disabled function is shared between Main & Remote LCDs */ static bool filter_first_keypress_disabled(int button, int data) { button_try_post(button, data); return false; } static bool filter_first_keypress_enabled(int button, int data) { #if defined(HAVE_TRANSFLECTIVE_LCD) && defined(HAVE_LCD_SLEEP) if (is_backlight_on(false) && lcd_active()) #else if (is_backlight_on(false)) #endif { return filter_first_keypress_disabled(button, data); } return true; } #ifdef HAVE_REMOTE_LCD static bool filter_first_remote_keypress_enabled(int button, int data) { if (is_remote_backlight_on(false) #if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES) || (remote_type()==REMOTETYPE_H300_NONLCD) #endif ) { return filter_first_keypress_disabled(button, data); } return true; } #endif /* def HAVE_REMOTE_LCD */ #endif /* def HAVE_BACKLIGHT */ static void button_tick(void) { static int count = 0; static int repeat_speed = REPEAT_INTERVAL_START; static int repeat_count = 0; static bool repeat = false; static bool post = false; #ifdef HAVE_BACKLIGHT static bool skip_release = false; #ifdef HAVE_REMOTE_LCD static bool skip_remote_release = false; #endif #endif int diff; int btn; int data = 0; button_remote_post(); btn = button_read(&data); check_audio_peripheral_state(); /* Find out if a key has been released */ diff = btn ^ lastbtn; if(diff && (btn & diff) == 0) { #ifdef HAVE_BACKLIGHT #ifdef HAVE_REMOTE_LCD if(diff & BUTTON_REMOTE) if(!skip_remote_release) button_try_post(BUTTON_REL | diff, data); else skip_remote_release = false; else #endif if(!skip_release) button_try_post(BUTTON_REL | diff, data); else skip_release = false; #else button_try_post(BUTTON_REL | diff, data); #endif } else { if ( btn ) { /* normal keypress */ if ( btn != lastbtn ) { post = true; repeat = false; repeat_speed = REPEAT_INTERVAL_START; } else /* repeat? */ { #if defined(DX50) || defined(DX90) /* Power button on these devices reports two distinct key codes, which are triggerd by a short or medium duration press. Additionlly a long duration press will trigger a hard reset, which is hardwired. The time delta between medium and long duration press is not large enough to register here as power off repeat. A hard reset is triggered before Rockbox can power off. To cirumvent the hard reset, Rockbox will shutdown on the first POWEROFF_BUTTON repeat. POWEROFF_BUTTON is associated with the a medium duration press of the power button. */ if(btn & POWEROFF_BUTTON) { sys_poweroff(); } #endif if ( repeat ) { if (!post) count--; if (count == 0) { post = true; /* yes we have repeat */ if (repeat_speed > REPEAT_INTERVAL_FINISH) repeat_speed--; #ifdef HAVE_TOUCHSCREEN if(btn & BUTTON_TOUCHSCREEN) repeat_speed = REPEAT_INTERVAL_TOUCH; #endif count = repeat_speed; repeat_count++; /* Send a SYS_POWEROFF event if we have a device which doesn't shut down easily with the OFF key */ #ifdef HAVE_SW_POWEROFF if (enable_sw_poweroff && (btn & POWEROFF_BUTTON #ifdef RC_POWEROFF_BUTTON || btn == RC_POWEROFF_BUTTON #endif ) && #if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING) !charger_inserted() && #endif repeat_count > POWEROFF_COUNT) { /* Tell the main thread that it's time to power off */ sys_poweroff(); /* Safety net for players without hardware poweroff */ #if (CONFIG_PLATFORM & PLATFORM_NATIVE) if(repeat_count > POWEROFF_COUNT * 10) power_off(); #endif } #endif } } else { if (count++ > REPEAT_START) { post = true; repeat = true; repeat_count = 0; /* initial repeat */ count = REPEAT_INTERVAL_START; } #ifdef HAVE_TOUCHSCREEN else if (lastdata != data && btn == lastbtn) { /* only coordinates changed, post anyway */ if (touchscreen_get_mode() == TOUCHSCREEN_POINT) post = true; } #endif } } if ( post ) { if (repeat) { /* Only post repeat events if the queue is empty, * to avoid afterscroll effects. */ if (button_try_post(BUTTON_REPEAT | btn, data)) { #ifdef HAVE_BACKLIGHT #ifdef HAVE_REMOTE_LCD skip_remote_release = false; #endif skip_release = false; #endif post = false; } } else { #ifdef HAVE_BACKLIGHT #ifdef HAVE_REMOTE_LCD if (btn & BUTTON_REMOTE) { skip_remote_release = remote_keypress_filter_fn(btn, data); remote_backlight_on(); } else #endif { skip_release = keypress_filter_fn(btn, data); backlight_on(); buttonlight_on(); } #else /* no backlight, nothing to skip */ button_try_post(btn, data); #endif post = false; } reset_poweroff_timer(); } } else { repeat = false; count = 0; } } lastbtn = btn & ~(BUTTON_REL | BUTTON_REPEAT); lastdata = data; } #ifdef HAVE_ADJUSTABLE_CPU_FREQ static bool button_boosted = false; static long button_unboost_tick; #define BUTTON_UNBOOST_TMO HZ static void button_boost(bool state) { if (state) { button_unboost_tick = current_tick + BUTTON_UNBOOST_TMO; if (!button_boosted) { button_boosted = true; cpu_boost(true); } } else if (!state && button_boosted) { button_boosted = false; cpu_boost(false); } } static void button_queue_wait(struct queue_event *evp, int timeout) { /* Loop once after wait time if boosted in order to unboost and wait the full remaining time */ do { int ticks = timeout; if (ticks == 0) /* TIMEOUT_NOBLOCK */ ; else if (ticks > 0) { if (button_boosted && ticks > BUTTON_UNBOOST_TMO) ticks = BUTTON_UNBOOST_TMO; timeout -= ticks; } else /* TIMEOUT_BLOCK (ticks < 0) */ { if (button_boosted) ticks = BUTTON_UNBOOST_TMO; } queue_wait_w_tmo(&button_queue, evp, ticks); if (evp->id != SYS_TIMEOUT) { /* GUI boost build gets immediate kick, otherwise at least 3 messages had to be there */ #ifndef HAVE_GUI_BOOST if (queue_count(&button_queue) >= 2) #endif button_boost(true); break; } if (button_boosted && TIME_AFTER(current_tick, button_unboost_tick)) button_boost(false); } while (timeout); } #else /* ndef HAVE_ADJUSTABLE_CPU_FREQ */ static inline void button_queue_wait(struct queue_event *evp, int timeout) { queue_wait_w_tmo(&button_queue, evp, timeout); } #endif /* HAVE_ADJUSTABLE_CPU_FREQ */ int button_queue_count( void ) { return queue_count(&button_queue); } long button_get(bool block) { struct queue_event ev; button_queue_wait(&ev, block ? TIMEOUT_BLOCK : TIMEOUT_NOBLOCK); if (ev.id == SYS_TIMEOUT) ev.id = BUTTON_NONE; else button_data = ev.data; return ev.id; } long button_get_w_tmo(int ticks) { struct queue_event ev; button_queue_wait(&ev, ticks); if (ev.id == SYS_TIMEOUT) ev.id = BUTTON_NONE; else button_data = ev.data; return ev.id; } intptr_t button_get_data(void) { return button_data; } void button_init(void) { int temp; /* Init used objects first */ queue_init(&button_queue, true); /* hardware inits */ button_init_device(); button_read(&temp); lastbtn = button_read(&temp); reset_poweroff_timer(); flipped = false; #ifdef HAVE_BACKLIGHT set_backlight_filter_keypress(false); #ifdef HAVE_REMOTE_LCD set_remote_backlight_filter_keypress(false); #endif #endif #ifdef HAVE_TOUCHSCREEN last_touchscreen_touch = -1; #endif /* Start polling last */ tick_add_task(button_tick); } #ifdef BUTTON_DRIVER_CLOSE void button_close(void) { tick_remove_task(button_tick); } #endif /* BUTTON_DRIVER_CLOSE */ #ifdef HAVE_LCD_FLIP /* * helper function to swap LEFT/RIGHT, UP/DOWN (if present) */ static int button_flip(int button) { int newbutton = button; #if (CONFIG_PLATFORM & PLATFORM_NATIVE) newbutton &= ~( #if defined(BUTTON_LEFT) && defined(BUTTON_RIGHT) BUTTON_LEFT | BUTTON_RIGHT #else #warning "LEFT/RIGHT not defined!" 0 #endif #if defined(BUTTON_UP) && defined(BUTTON_DOWN) | BUTTON_UP | BUTTON_DOWN #endif #if defined(BUTTON_SCROLL_BACK) && defined(BUTTON_SCROLL_FWD) | BUTTON_SCROLL_BACK | BUTTON_SCROLL_FWD #endif #if (CONFIG_KEYPAD == SANSA_C200_PAD) || (CONFIG_KEYPAD == SANSA_CLIP_PAD) ||\ (CONFIG_KEYPAD == GIGABEAT_PAD) || (CONFIG_KEYPAD == GIGABEAT_S_PAD) | BUTTON_VOL_UP | BUTTON_VOL_DOWN #endif #if CONFIG_KEYPAD == PHILIPS_SA9200_PAD | BUTTON_VOL_UP | BUTTON_VOL_DOWN | BUTTON_NEXT | BUTTON_PREV #endif ); #if defined(BUTTON_LEFT) && defined(BUTTON_RIGHT) if (button & BUTTON_LEFT) newbutton |= BUTTON_RIGHT; if (button & BUTTON_RIGHT) newbutton |= BUTTON_LEFT; #else #warning "LEFT/RIGHT not defined!" #endif #if defined(BUTTON_UP) && defined(BUTTON_DOWN) if (button & BUTTON_UP) newbutton |= BUTTON_DOWN; if (button & BUTTON_DOWN) newbutton |= BUTTON_UP; #endif #if defined(BUTTON_SCROLL_BACK) && defined(BUTTON_SCROLL_FWD) if (button & BUTTON_SCROLL_BACK) newbutton |= BUTTON_SCROLL_FWD; if (button & BUTTON_SCROLL_FWD) newbutton |= BUTTON_SCROLL_BACK; #endif #if (CONFIG_KEYPAD == SANSA_C200_PAD) || (CONFIG_KEYPAD == SANSA_CLIP_PAD) ||\ (CONFIG_KEYPAD == GIGABEAT_PAD) || (CONFIG_KEYPAD == GIGABEAT_S_PAD) if (button & BUTTON_VOL_UP) newbutton |= BUTTON_VOL_DOWN; if (button & BUTTON_VOL_DOWN) newbutton |= BUTTON_VOL_UP; #endif #if CONFIG_KEYPAD == PHILIPS_SA9200_PAD if (button & BUTTON_VOL_UP) newbutton |= BUTTON_VOL_DOWN; if (button & BUTTON_VOL_DOWN) newbutton |= BUTTON_VOL_UP; if (button & BUTTON_NEXT) newbutton |= BUTTON_PREV; if (button & BUTTON_PREV) newbutton |= BUTTON_NEXT; #endif #endif /* !SIMULATOR */ return newbutton; } /* * set the flip attribute * better only call this when the queue is empty */ void button_set_flip(bool flip) { if (flip != flipped) /* not the current setting */ { /* avoid race condition with the button_tick() */ int oldlevel = disable_irq_save(); lastbtn = button_flip(lastbtn); flipped = flip; restore_irq(oldlevel); } } #endif /* HAVE_LCD_FLIP */ #ifdef HAVE_BACKLIGHT void set_backlight_filter_keypress(bool value) { if (!value) keypress_filter_fn = filter_first_keypress_disabled; else keypress_filter_fn = filter_first_keypress_enabled; } #ifdef HAVE_REMOTE_LCD void set_remote_backlight_filter_keypress(bool value) { if (!value) remote_keypress_filter_fn = filter_first_keypress_disabled; else remote_keypress_filter_fn = filter_first_remote_keypress_enabled; } #endif #endif /* * Get button pressed from hardware */ static int button_read(int *data) { #ifdef HAVE_BUTTON_DATA int btn = button_read_device(data); #else (void) data; int btn = button_read_device(); #endif int retval; #ifdef HAVE_LCD_FLIP if (btn && flipped) btn = button_flip(btn); /* swap upside down */ #endif /* HAVE_LCD_FLIP */ #ifdef HAVE_TOUCHSCREEN if (btn & BUTTON_TOUCHSCREEN) last_touchscreen_touch = current_tick; #endif /* Filter the button status. It is only accepted if we get the same status twice in a row. */ #ifndef HAVE_TOUCHSCREEN if (btn != last_read) retval = lastbtn; else #endif retval = btn; last_read = btn; return retval; } int button_status(void) { return lastbtn; } #ifdef HAVE_BUTTON_DATA int button_status_wdata(int *pdata) { *pdata = lastdata; return lastbtn; } #endif void button_clear_queue(void) { queue_clear(&button_queue); } #ifdef HAVE_TOUCHSCREEN long touchscreen_last_touch(void) { return last_touchscreen_touch; } #endif #ifdef HAVE_WHEEL_ACCELERATION /* WHEEL_ACCEL_FACTOR = 2^16 / WHEEL_ACCEL_START */ #define WHEEL_ACCEL_FACTOR (1<<16)/WHEEL_ACCEL_START /** * data: * [31] Use acceleration * [30:24] Message post count (skipped + 1) (1-127) * [23:0] Velocity - degree/sec * * WHEEL_ACCEL_FACTOR: * Value in degree/sec -- configurable via settings -- above which * the accelerated scrolling starts. Factor is internally scaled by * 1<<16 in respect to the following 32bit integer operations. */ int button_apply_acceleration(const unsigned int data) { int delta = (data >> 24) & 0x7f; if ((data & (1 << 31)) != 0) { /* read driver's velocity from data */ unsigned int v = data & 0xffffff; /* v = 28.4 fixed point */ v = (WHEEL_ACCEL_FACTOR * v)>>(16-4); /* Calculate real numbers item to scroll based upon acceleration * setting, use correct roundoff */ #if (WHEEL_ACCELERATION == 1) v = (v*v + (1<< 7))>> 8; #elif (WHEEL_ACCELERATION == 2) v = (v*v*v + (1<<11))>>12; #elif (WHEEL_ACCELERATION == 3) v = (v*v*v*v + (1<<15))>>16; #endif if (v > 1) delta *= v; } return delta; } #endif /* HAVE_WHEEL_ACCELERATION */ #if (defined(HAVE_TOUCHPAD) || defined(HAVE_TOUCHSCREEN)) && !defined(HAS_BUTTON_HOLD) void button_enable_touch(bool en) { #ifdef HAVE_TOUCHPAD touchpad_enable(en); #endif #ifdef HAVE_TOUCHSCREEN touchscreen_enable(en); #endif } #endif #ifdef HAVE_SW_POWEROFF void button_set_sw_poweroff_state(bool en) { enable_sw_poweroff = en; } bool button_get_sw_poweroff_state() { return enable_sw_poweroff; } #endif