rockbox/firmware/target/arm/tms320dm320/sansa-connect/avr-sansaconnect.c

491 lines
12 KiB
C
Raw Normal View History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id: $
*
* Copyright (C) 2011 by Tomasz Moń
*
* 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.
*
****************************************************************************/
#include <stdio.h>
#include "config.h"
#include "system.h"
#include "kernel.h"
#include "logf.h"
#include "avr-sansaconnect.h"
#include "uart-target.h"
#include "button.h"
#include "backlight.h"
#include "powermgmt.h"
#include "aic3x.h"
//#define BUTTON_DEBUG
#ifdef BUTTON_DEBUG
#include "lcd-target.h"
#include "lcd.h"
#include "font.h"
#include "common.h"
#endif
#ifdef BUTTON_DEBUG
#define dbgprintf DEBUGF
#else
#define dbgprintf(...)
#endif
#define CMD_SYNC 0xAA
#define CMD_CLOSE 0xCC
#define CMD_LCM_POWER 0xC9
#define LCM_POWER_OFF 0x00
#define LCM_POWER_ON 0x01
#define LCM_POWER_SLEEP 0x02
#define LCM_POWER_WAKE 0x03
#define LCM_REPOWER_ON 0x04
#define CMD_STATE 0xBB
#define CMD_VER 0xBC
#define CMD_WHEEL_EN 0xD0
#define CMD_SET_INTCHRG 0xD1
#define CMD_CODEC_RESET 0xD7
#define CMD_FILL 0xFF
#define CMD_SYS_CTRL 0xDA
#define SYS_CTRL_POWEROFF 0x00
/* protects spi avr commands from concurrent access */
static struct mutex avr_mtx;
/* buttons thread */
#define BTN_INTERRUPT 1
static int btn = 0;
static bool hold_switch;
#ifndef BOOTLOADER
static long btn_stack[DEFAULT_STACK_SIZE/sizeof(long)];
static const char btn_thread_name[] = "buttons";
static struct event_queue btn_queue;
#endif
static inline unsigned short be2short(unsigned char* buf)
{
return (unsigned short)((buf[0] << 8) | buf[1]);
}
#define BUTTON_DIRECT_MASK (BUTTON_LEFT | BUTTON_UP | BUTTON_RIGHT | BUTTON_DOWN | BUTTON_SELECT | BUTTON_VOL_UP | BUTTON_VOL_DOWN | BUTTON_NEXT | BUTTON_PREV)
#ifndef BOOTLOADER
static void handle_wheel(unsigned char wheel)
{
static int key = 0;
static unsigned char velocity = 0;
static unsigned long wheel_delta = 1ul << 24;
static unsigned char wheel_prev = 0;
static long nextbacklight_hw_on = 0;
static int prev_key = -1;
static int prev_key_post = 0;
if (TIME_AFTER(current_tick, nextbacklight_hw_on))
{
backlight_on();
reset_poweroff_timer();
nextbacklight_hw_on = current_tick + HZ/4;
}
if (wheel_prev < wheel)
{
key = BUTTON_SCROLL_FWD;
velocity = wheel - wheel_prev;
}
else if (wheel_prev > wheel)
{
key = BUTTON_SCROLL_BACK;
velocity = wheel_prev - wheel;
}
if (prev_key != key && velocity < 2 /* filter "rewinds" */)
{
/* direction reversal */
prev_key = key;
wheel_delta = 1ul << 24;
return;
}
/* TODO: take velocity into account */
if (queue_empty(&button_queue))
{
if (prev_key_post == key)
{
key |= BUTTON_REPEAT;
}
/* Post directly, don't update btn as avr doesn't give
interrupt on scroll stop */
queue_post(&button_queue, key, wheel_delta);
wheel_delta = 1ul << 24;
prev_key_post = key;
}
else
{
/* skipped post - increment delta and limit to 7 bits */
wheel_delta += 1ul << 24;
if (wheel_delta > (0x7ful << 24))
wheel_delta = 0x7ful << 24;
}
wheel_prev = wheel;
prev_key = key;
}
#endif
/* buf must be 11-byte array of byte (reply from avr_hid_get_state() */
static void parse_button_state(unsigned char *buf)
{
unsigned short main_btns_state = be2short(&buf[4]);
#ifdef BUTTON_DEBUG
unsigned short main_btns_changed = be2short(&buf[6]);
#endif
/* make sure other bits doesn't conflict with our "free bits" buttons */
main_btns_state &= BUTTON_DIRECT_MASK;
if (buf[3] & 0x01) /* is power button pressed? */
{
main_btns_state |= BUTTON_POWER;
}
btn = main_btns_state;
#ifndef BOOTLOADER
/* check if stored hold_switch state changed (prevents lost changes) */
if ((buf[3] & 0x20) /* hold change notification */ ||
(hold_switch != ((buf[3] & 0x02) >> 1)))
{
#endif
hold_switch = (buf[3] & 0x02) >> 1;
#ifdef BUTTON_DEBUG
dbgprintf("HOLD changed (%d)", hold_switch);
#endif
#ifndef BOOTLOADER
backlight_hold_changed(hold_switch);
}
#endif
#ifndef BOOTLOADER
if ((hold_switch == false) && (buf[3] & 0x80)) /* scrollwheel change */
{
handle_wheel(buf[2]);
}
#endif
#ifdef BUTTON_DEBUG
if (buf[3] & 0x10) /* power button change */
{
/* power button state has changed */
main_btns_changed |= BUTTON_POWER;
}
if (btn & BUTTON_LEFT) dbgprintf("LEFT");
if (btn & BUTTON_UP) dbgprintf("UP");
if (btn & BUTTON_RIGHT) dbgprintf("RIGHT");
if (btn & BUTTON_DOWN) dbgprintf("DOWN");
if (btn & BUTTON_SELECT) dbgprintf("SELECT");
if (btn & BUTTON_VOL_UP) dbgprintf("VOL UP");
if (btn & BUTTON_VOL_DOWN) dbgprintf("VOL DOWN");
if (btn & BUTTON_NEXT) dbgprintf("NEXT");
if (btn & BUTTON_PREV) dbgprintf("PREV");
if (btn & BUTTON_POWER) dbgprintf("POWER");
if (btn & BUTTON_HOLD) dbgprintf("HOLD");
if (btn & BUTTON_SCROLL_FWD) dbgprintf("SCROLL FWD");
if (btn & BUTTON_SCROLL_BACK) dbgprintf("SCROLL BACK");
#endif
}
static void spi_txrx(unsigned char *buf_tx, unsigned char *buf_rx, int n)
{
int i;
unsigned short rxdata;
mutex_lock(&avr_mtx);
bitset16(&IO_CLK_MOD2, CLK_MOD2_SIF1);
IO_SERIAL1_TX_ENABLE = 0x0001;
for (i = 0; i<n; i++)
{
IO_SERIAL1_TX_DATA = buf_tx[i];
/* 100 us wait for AVR */
udelay(100);
do
{
rxdata = IO_SERIAL1_RX_DATA;
} while (rxdata & (1<<8));
if (buf_rx != NULL)
buf_rx[i] = rxdata & 0xFF;
/* 100 us wait to give AVR time to process data */
udelay(100);
}
IO_SERIAL1_TX_ENABLE = 0;
bitclr16(&IO_CLK_MOD2, CLK_MOD2_SIF1);
mutex_unlock(&avr_mtx);
}
void avr_hid_sync(void)
{
int i;
unsigned char prg[4] = {CMD_SYNC, CMD_VER, CMD_FILL, CMD_CLOSE};
/* Send SYNC three times */
for (i = 0; i<3; i++)
{
spi_txrx(prg, NULL, sizeof(prg));
}
}
void avr_hid_init(void)
{
/*
setup alternate GIO functions:
GIO29 - SIF1 Enable (Directly connected to AVR's SS)
GIO30 - SIF1 Clock
GIO31 - SIF1 Data In
GIO32 - SIF1 Data Out
*/
IO_GIO_FSEL2 = (IO_GIO_FSEL2 & 0x00FF) | 0xAA00;
/* GIO29, GIO30 - outputs, GIO31 - input */
IO_GIO_DIR1 = (IO_GIO_DIR1 & ~((1 << 13) | (1 << 14))) | (1 << 15);
/* GIO32 - output */
bitclr16(&IO_GIO_DIR2, (1 << 0));
/* RATE = 219 (0xDB) -> 200 kHz */
IO_SERIAL1_MODE = 0x6DB;
mutex_init(&avr_mtx);
}
/* defined in powermgmt-sansaconnect.c */
void set_battery_level(unsigned int level);
static void avr_hid_get_state(void)
{
static unsigned char cmd[11] = {CMD_SYNC, CMD_STATE,
CMD_FILL, CMD_FILL, CMD_FILL, CMD_FILL, CMD_FILL, CMD_FILL, CMD_FILL, CMD_FILL,
CMD_CLOSE};
static unsigned char buf[11];
static unsigned char cmd_empty[1] = {0xCC};
spi_txrx(cmd, buf, sizeof(cmd));
/*
* buf[8] contains some battery/charger related information (unknown)
* buf[9] contains battery level in percents (0-100)
*/
set_battery_level((unsigned int)buf[9]);
spi_txrx(cmd_empty, NULL, 1); /* request interrupt on button press */
parse_button_state(buf);
}
static void avr_hid_enable_wheel(void)
{
unsigned char wheel_en[4] = {CMD_SYNC, CMD_WHEEL_EN, 0x01, CMD_CLOSE};
spi_txrx(wheel_en, NULL, sizeof(wheel_en));
}
/* command that is sent by "hidtool -J 1" issued on every OF boot */
void avr_hid_enable_charger(void)
{
unsigned char charger_en[4] = {CMD_SYNC, CMD_SET_INTCHRG, 0x01, CMD_CLOSE};
spi_txrx(charger_en, NULL, sizeof(charger_en));
}
void avr_hid_lcm_sleep(void)
{
unsigned char lcm_sleep[4] = {CMD_SYNC, CMD_LCM_POWER, LCM_POWER_SLEEP, CMD_CLOSE};
spi_txrx(lcm_sleep, NULL, sizeof(lcm_sleep));
}
void avr_hid_lcm_wake(void)
{
unsigned char lcm_wake[4] = {CMD_SYNC, CMD_LCM_POWER, LCM_POWER_WAKE, CMD_CLOSE};
spi_txrx(lcm_wake, NULL, sizeof(lcm_wake));
}
void avr_hid_lcm_power_on(void)
{
unsigned char lcm_power_on[4] = {CMD_SYNC, CMD_LCM_POWER, LCM_POWER_ON, CMD_CLOSE};
spi_txrx(lcm_power_on, NULL, sizeof(lcm_power_on));
}
void avr_hid_lcm_power_off(void)
{
unsigned char lcm_power_off[4] = {CMD_SYNC, CMD_LCM_POWER, LCM_POWER_OFF, CMD_CLOSE};
spi_txrx(lcm_power_off, NULL, sizeof(lcm_power_off));
}
void avr_hid_reset_codec(void)
{
unsigned char codec_reset[4] = {CMD_SYNC, CMD_CODEC_RESET, CMD_CLOSE, CMD_FILL};
spi_txrx(codec_reset, NULL, sizeof(codec_reset));
}
void avr_hid_power_off(void)
{
unsigned char prg[4] = {CMD_SYNC, CMD_SYS_CTRL, SYS_CTRL_POWEROFF, CMD_CLOSE};
spi_txrx(prg, NULL, sizeof(prg));
}
#ifndef BOOTLOADER
void btn_thread(void)
{
struct queue_event ev;
while (1)
{
queue_wait(&btn_queue, &ev);
if (ev.id == SYS_USB_CONNECTED)
{
/* Allow USB to gain exclusive storage access */
usb_acknowledge(SYS_USB_CONNECTED_ACK);
}
/* Ignore all messages except BTN_INTERRUPT */
if (ev.id != BTN_INTERRUPT)
continue;
/* Enable back button interrupt */
IO_INTC_EINT1 |= INTR_EINT1_EXT0;
/* Read buttons state */
avr_hid_get_state();
yield();
if (queue_empty(&btn_queue) && ((IO_GIO_BITSET0 & 0x1) == 0))
{
/* for some reason we have lost next interrupt */
queue_post(&btn_queue, BTN_INTERRUPT, 0);
}
}
}
void GIO0(void) __attribute__ ((section(".icode")));
void GIO0(void)
{
/* Clear interrupt */
IO_INTC_IRQ1 = (1 << 5);
/* Disable interrupt */
IO_INTC_EINT1 &= ~INTR_EINT1_EXT0;
/* interrupt will be enabled back after button read */
queue_post(&btn_queue, BTN_INTERRUPT, 0);
}
static int headphones_inserted_callback(struct timeout *tmo)
{
(void)tmo;
if (IO_GIO_BITSET0 & 0x04)
{
aic3x_switch_output(false);
}
else
{
aic3x_switch_output(true);
}
return 0;
}
void GIO2(void) __attribute__ ((section(".icode")));
void GIO2(void)
{
static struct timeout headphones_oneshot;
/* Clear interrupt */
IO_INTC_IRQ1 = (1 << 7);
timeout_register(&headphones_oneshot, headphones_inserted_callback,
HZ/2, 0);
}
#endif
void button_init_device(void)
{
btn = 0;
hold_switch = false;
#ifndef BOOTLOADER
queue_init(&btn_queue, true);
create_thread(btn_thread, btn_stack, sizeof(btn_stack), 0,
btn_thread_name IF_PRIO(, PRIORITY_USER_INTERFACE)
IF_COP(, CPU));
#endif
IO_GIO_DIR0 |= 0x01; /* Set GIO0 as input */
/* Enable wheel */
avr_hid_enable_wheel();
/* Read button status and tell avr we want interrupt on next change */
avr_hid_get_state();
#ifndef BOOTLOADER
IO_GIO_IRQPORT |= 0x05; /* Enable GIO0/GIO2 external interrupt */
IO_GIO_INV0 &= ~0x05; /* Clear INV for GIO0/GIO2 */
/* falling edge detection on GIO0, any edge on GIO2 */
IO_GIO_IRQEDGE = (IO_GIO_IRQEDGE & ~0x01) | 0x04;
/* Enable GIO0 and GIO2 interrupts */
IO_INTC_EINT1 |= INTR_EINT1_EXT0 | INTR_EINT1_EXT2;
#endif
}
int button_read_device(void)
{
if(hold_switch)
return 0;
else
return btn;
}
bool button_hold(void)
{
return hold_switch;
}
void lcd_enable(bool on)
{
(void)on;
}