mirror of
https://github.com/Rockbox/rockbox.git
synced 2025-10-13 18:17:39 -04:00
adbd0125fd
Check for the ES9018K2M dac in the bootloader for hw1/hw2 devices. Assume that all devices newer than hw2 have ES9018K2M DAC unconditionally. All devices will now report the correct hw revision in the debug menu under Device Data. Add devicedata.version field, current version 0. Rename device_data.lcd_version to device_data.hw_rev. hw2 devices with older bootloaders which ID as hw1 are special- cased to keep using hwvol on them. They should still upgrade though. Change-Id: If0fd5ce3bc6e85e511047721ec18e42fb89312e7
325 lines
10 KiB
C
325 lines
10 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2021 Aidan MacDonald, Dana Conrad
|
|
*
|
|
* 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 "button.h"
|
|
#include "kernel.h"
|
|
#include "backlight.h"
|
|
#include "powermgmt.h"
|
|
#include "panic.h"
|
|
#include "axp-pmu.h"
|
|
#include "gpio-x1000.h"
|
|
#include "irq-x1000.h"
|
|
#include "i2c-x1000.h"
|
|
#include "eros_qn_codec.h"
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include "devicedata.h"
|
|
|
|
#ifndef BOOTLOADER
|
|
# include "lcd.h"
|
|
# include "font.h"
|
|
#endif
|
|
|
|
/* ===========================================
|
|
* | OLD STATE | NEW STATE | DIRECTION |
|
|
* | 0 0 | 0 0 | 0: NO CHANGE |
|
|
* | 0 0 | 0 1 | -1: CCW |
|
|
* | 0 0 | 1 0 | 1: CW |
|
|
* | 0 0 | 1 1 | 0: INVALID |
|
|
* | 0 1 | 0 0 | 1: CW |
|
|
* | 0 1 | 0 1 | 0: NO CHANGE |
|
|
* | 0 1 | 1 0 | 0: INVALID |
|
|
* | 0 1 | 1 1 | -1: CCW |
|
|
* | 1 0 | 0 0 | -1: CCW |
|
|
* | 1 0 | 0 1 | 0: INVALID |
|
|
* | 1 0 | 1 0 | 0: NO CHANGE |
|
|
* | 1 0 | 1 1 | 1: CW |
|
|
* | 1 1 | 0 0 | 0: INVALID |
|
|
* | 1 1 | 0 1 | 1: CW |
|
|
* | 1 1 | 1 0 | -1: CCW |
|
|
* | 1 1 | 1 1 | 0: NO CHANGE |
|
|
* ===========================================
|
|
*
|
|
* Quadrature explanation since it's not plainly obvious how this works:
|
|
*
|
|
* If either of the quadrature lines change, we can look up the combination
|
|
* of previous state and new state in the table above (enc_state[] below)
|
|
* and it tells us whether to add 1, subtract 1, or no change from the sum (enc_position).
|
|
* This also gives us a nice debounce, since each state can only have 1 pin change
|
|
* at a time. I didn't come up with this, but I've used it before and it works well.
|
|
*
|
|
* Old state is 2 higher bits, new state is 2 lower bits of enc_current_state. */
|
|
|
|
/* list of valid quadrature states and their directions */
|
|
signed char enc_state[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0};
|
|
volatile unsigned char enc_current_state = 0;
|
|
volatile signed int enc_position = 0;
|
|
|
|
/* Value of headphone detect register */
|
|
static uint8_t hp_detect_reg = 0x00;
|
|
static uint8_t hp_detect_reg_old = 0x00;
|
|
#ifndef BOOTLOADER
|
|
static uint8_t hp_detect_debounce1 = 0x00;
|
|
#endif
|
|
static uint8_t hp_detect_debounce2 = 0x00;
|
|
static uint8_t debounce_count = 0;
|
|
|
|
/* Interval to poll the register */
|
|
#define HPD_POLL_TIME (HZ/4)
|
|
|
|
#ifndef BOOTLOADER
|
|
static int hp_detect_tmo_cb(struct timeout* tmo)
|
|
{
|
|
if (hp_detect_debounce1 == hp_detect_debounce2){
|
|
if (debounce_count >= 2){
|
|
debounce_count = 2;
|
|
} else {
|
|
debounce_count = debounce_count + 1;
|
|
}
|
|
} else {
|
|
debounce_count = 0;
|
|
hp_detect_debounce2 = hp_detect_debounce1;
|
|
}
|
|
|
|
i2c_descriptor* d = (i2c_descriptor*)tmo->data;
|
|
i2c_async_queue(AXP_PMU_BUS, TIMEOUT_NOBLOCK, I2C_Q_ADD, 0, d);
|
|
return HPD_POLL_TIME;
|
|
}
|
|
|
|
static void hp_detect_init(int version)
|
|
{
|
|
if (version <= 3) {
|
|
static struct timeout tmo;
|
|
static const uint8_t gpio_reg = AXP192_REG_GPIOSTATE1;
|
|
static i2c_descriptor desc = {
|
|
.slave_addr = AXP_PMU_ADDR,
|
|
.bus_cond = I2C_START | I2C_STOP,
|
|
.tran_mode = I2C_READ,
|
|
.buffer[0] = (void*)&gpio_reg,
|
|
.count[0] = 1,
|
|
.buffer[1] = &hp_detect_debounce1,
|
|
.count[1] = 1,
|
|
.callback = NULL,
|
|
.arg = 0,
|
|
.next = NULL,
|
|
};
|
|
|
|
/* Headphone and LO detects are wired to AXP192 GPIOs 0 and 1,
|
|
* set them to inputs. */
|
|
i2c_reg_write1(AXP_PMU_BUS, AXP_PMU_ADDR, AXP192_REG_GPIO0FUNCTION, 0x01); /* HP detect */
|
|
i2c_reg_write1(AXP_PMU_BUS, AXP_PMU_ADDR, AXP192_REG_GPIO1FUNCTION, 0x01); /* LO detect */
|
|
|
|
/* Get an initial reading before startup */
|
|
int r = i2c_reg_read1(AXP_PMU_BUS, AXP_PMU_ADDR, gpio_reg);
|
|
if(r >= 0)
|
|
{
|
|
hp_detect_reg = r;
|
|
hp_detect_debounce1 = r;
|
|
hp_detect_debounce2 = r;
|
|
hp_detect_reg_old = hp_detect_reg;
|
|
}
|
|
|
|
/* Poll the register every second */
|
|
timeout_register(&tmo, &hp_detect_tmo_cb, HPD_POLL_TIME, (intptr_t)&desc);
|
|
} else {
|
|
uint32_t b = REG_GPIO_PIN(GPIO_B);
|
|
|
|
// initialize headphone detect variables
|
|
// HP_detect PB14 --> bit 4
|
|
// LO_detect PB22 --> bit 5
|
|
hp_detect_reg = ( (b>>10)&(0x10) | (b>>17)&(0x20) );
|
|
hp_detect_debounce1 = hp_detect_reg;
|
|
hp_detect_debounce2 = hp_detect_reg;
|
|
hp_detect_reg_old = hp_detect_reg;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
bool headphones_inserted(void)
|
|
{
|
|
if (debounce_count > 1){
|
|
hp_detect_reg = hp_detect_debounce2;
|
|
}
|
|
/* if the status has changed, set the output volume accordingly */
|
|
if ((hp_detect_reg & 0x30) != (hp_detect_reg_old & 0x30))
|
|
{
|
|
hp_detect_reg_old = hp_detect_reg;
|
|
#if !defined(BOOTLOADER)
|
|
eros_qn_set_outputs();
|
|
#endif
|
|
}
|
|
return hp_detect_reg & 0x10 ? false : true;
|
|
}
|
|
|
|
bool lineout_inserted(void)
|
|
{
|
|
if (debounce_count > 1){
|
|
hp_detect_reg = hp_detect_debounce2;
|
|
}
|
|
/* if the status has changed, set the output volume accordingly */
|
|
if ((hp_detect_reg & 0x30) != (hp_detect_reg_old & 0x30))
|
|
{
|
|
hp_detect_reg_old = hp_detect_reg;
|
|
#if !defined(BOOTLOADER)
|
|
eros_qn_set_outputs();
|
|
#endif
|
|
}
|
|
return hp_detect_reg & 0x20 ? false : true;
|
|
}
|
|
|
|
/* Rockbox interface */
|
|
void button_init_device(void)
|
|
{
|
|
/* set both quadrature lines to interrupts */
|
|
gpio_set_function(GPIO_BTN_SCROLL_A, GPIOF_IRQ_EDGE(1));
|
|
gpio_set_function(GPIO_BTN_SCROLL_B, GPIOF_IRQ_EDGE(1));
|
|
|
|
/* set interrupts to fire on the next edge based on current state */
|
|
gpio_flip_edge_irq(GPIO_BTN_SCROLL_A);
|
|
gpio_flip_edge_irq(GPIO_BTN_SCROLL_B);
|
|
|
|
/* get current state of both encoder gpios */
|
|
enc_current_state = (REG_GPIO_PIN(GPIO_B)>>21) & 0x0c;
|
|
|
|
/* enable quadrature interrupts */
|
|
gpio_enable_irq(GPIO_BTN_SCROLL_A);
|
|
gpio_enable_irq(GPIO_BTN_SCROLL_B);
|
|
|
|
/* Set up headphone and line out detect polling */
|
|
#ifndef BOOTLOADER
|
|
hp_detect_init(device_data.hw_rev);
|
|
#endif
|
|
}
|
|
|
|
/* wheel Quadrature line A interrupt */
|
|
void GPIOB24(void)
|
|
{
|
|
/* fill state with previous (2 higher bits) and current (2 lower bits) */
|
|
enc_current_state = (enc_current_state & 0x0c) | ((REG_GPIO_PIN(GPIO_B)>>23) & 0x03);
|
|
|
|
/* look up in table */
|
|
enc_position = enc_position + enc_state[(enc_current_state)];
|
|
|
|
/* move current state to previous state if valid data */
|
|
if (enc_state[(enc_current_state)] != 0)
|
|
enc_current_state = (enc_current_state << 2);
|
|
|
|
/* we want the other edge next time */
|
|
gpio_flip_edge_irq(GPIO_BTN_SCROLL_A);
|
|
}
|
|
|
|
/* wheel Quadrature line B interrupt */
|
|
void GPIOB23(void)
|
|
{
|
|
/* fill state with previous (2 higher bits) and current (2 lower bits) */
|
|
enc_current_state = (enc_current_state & 0x0c) | ((REG_GPIO_PIN(GPIO_B)>>23) & 0x03);
|
|
|
|
/* look up in table */
|
|
enc_position = enc_position + enc_state[(enc_current_state)];
|
|
|
|
/* move current state to previous state if valid data */
|
|
if (enc_state[(enc_current_state)] != 0)
|
|
enc_current_state = (enc_current_state << 2);
|
|
|
|
/* we want the other edge next time */
|
|
gpio_flip_edge_irq(GPIO_BTN_SCROLL_B);
|
|
}
|
|
|
|
int button_read_device(void)
|
|
{
|
|
int r = 0;
|
|
|
|
/* Read GPIOs for normal buttons */
|
|
uint32_t a = REG_GPIO_PIN(GPIO_A);
|
|
uint32_t b = REG_GPIO_PIN(GPIO_B);
|
|
uint32_t c = REG_GPIO_PIN(GPIO_C);
|
|
uint32_t d = REG_GPIO_PIN(GPIO_D);
|
|
|
|
/* All buttons are active low */
|
|
if((a & (1 << 16)) == 0) r |= BUTTON_PLAY;
|
|
if((a & (1 << 17)) == 0) r |= BUTTON_VOL_UP;
|
|
if((a & (1 << 19)) == 0) r |= BUTTON_VOL_DOWN;
|
|
#ifdef BOOTLOADER
|
|
# if EROSQN_VER >= 4
|
|
if((b & (1 << 31)) == 0) r |= BUTTON_POWER;
|
|
if((a & (1 << 18)) == 0) r |= BUTTON_BACK;
|
|
# else
|
|
if((b & (1 << 7)) == 0) r |= BUTTON_POWER;
|
|
if((d & (1 << 5)) == 0) r |= BUTTON_BACK;
|
|
# endif
|
|
#else
|
|
if (device_data.hw_rev >= 4){
|
|
if((b & (1 << 31)) == 0) r |= BUTTON_POWER;
|
|
if((a & (1 << 18)) == 0) r |= BUTTON_BACK;
|
|
} else {
|
|
if((b & (1 << 7)) == 0) r |= BUTTON_POWER;
|
|
if((d & (1 << 5)) == 0) r |= BUTTON_BACK;
|
|
}
|
|
#endif
|
|
if((b & (1 << 28)) == 0) r |= BUTTON_MENU;
|
|
|
|
if((d & (1 << 4)) == 0) r |= BUTTON_PREV;
|
|
if((c & (1 << 24)) == 0) r |= BUTTON_NEXT;
|
|
|
|
#ifndef BOOTLOADER
|
|
if (device_data.hw_rev >= 4){
|
|
// get new HP/LO detect states
|
|
// HP_detect PB14 --> hp_detect bit 4
|
|
// LO_detect PB22 --> hp_detect bit 5
|
|
hp_detect_debounce1 = ( (b>>10)&(0x10) | (b>>17)&(0x20) );
|
|
|
|
// enter them into the debounce process
|
|
if (hp_detect_debounce1 == hp_detect_debounce2){
|
|
if (debounce_count >= 2){
|
|
debounce_count = 2;
|
|
} else {
|
|
debounce_count = debounce_count + 1;
|
|
}
|
|
} else {
|
|
debounce_count = 0;
|
|
hp_detect_debounce2 = hp_detect_debounce1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* check encoder - from testing, each indent is 2 state changes or so */
|
|
if (enc_position > 1)
|
|
{
|
|
/* need to use queue_post() in order to do BUTTON_SCROLL_*,
|
|
* Rockbox treats these buttons differently. */
|
|
button_queue_post(BUTTON_SCROLL_FWD, 0);
|
|
enc_position = 0;
|
|
reset_poweroff_timer();
|
|
backlight_on();
|
|
}
|
|
else if (enc_position < -1)
|
|
{
|
|
/* need to use queue_post() in order to do BUTTON_SCROLL_*,
|
|
* Rockbox treats these buttons differently. */
|
|
button_queue_post(BUTTON_SCROLL_BACK, 0);
|
|
enc_position = 0;
|
|
reset_poweroff_timer();
|
|
backlight_on();
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|