mirror of
https://github.com/Rockbox/rockbox.git
synced 2025-12-09 05:05:20 -05:00
2df3a5b04c
Allow Lineout to behave like headphone port in regards to plug/unplug pause/resume Change-Id: I9cb2c9c40e0bdf3bf7e1e272164acd343f6b3850
309 lines
8.2 KiB
C
309 lines
8.2 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2016 by Roman Stolyarov
|
|
* Copyright (C) 2020 by William Wilgus
|
|
*
|
|
* 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 "config.h"
|
|
#include "system.h"
|
|
#include "cpu.h"
|
|
#include "button.h"
|
|
#include "button-target.h"
|
|
#include "powermgmt.h"
|
|
#include "kernel.h"
|
|
#include "backlight.h"
|
|
#include "logf.h"
|
|
#include "adc.h"
|
|
|
|
#define BATT_WAIT_TIME HZ * 30
|
|
|
|
#define PIN_BTN_POWER (32*0+30)
|
|
#define PIN_BTN_HOLD (32*1+15)
|
|
|
|
#define PIN_KEY_INT (32*4+13)
|
|
#define KEY_INT_IRQ GPIO141
|
|
|
|
#define PIN_COM_BOP (32*3+17) /* common pin for Back Option Play */
|
|
|
|
#define PIN_CHARGE_CON (32*1+7)
|
|
|
|
#define PIN_PH_DECT (32*1+11)
|
|
#define IRQ_PH_DECT GPIO_IRQ(PIN_PH_DECT)
|
|
#define GPIO_PH_DECT GPIO43
|
|
|
|
#define PIN_LO_DECT (32*1+12)
|
|
#define IRQ_LO_DECT GPIO_IRQ(PIN_LO_DECT)
|
|
#define GPIO_LO_DECT GPIO44
|
|
|
|
#define KEY_IS_DOWN(pin) (__gpio_get_pin(pin) == 0)
|
|
|
|
#define ADC_MASK 0x0FFF
|
|
|
|
static volatile unsigned short bat_val, key_val;
|
|
static volatile int btn_last = BUTTON_NONE;
|
|
static volatile long btn_last_tick;
|
|
|
|
bool headphones_inserted(void)
|
|
{
|
|
return (__gpio_get_pin(PIN_PH_DECT) != 0);
|
|
}
|
|
|
|
bool lineout_inserted(void)
|
|
{
|
|
/* We want to prevent LO being "enabled" if HP is attached
|
|
to avoid potential eardrum damage */
|
|
return (__gpio_get_pin(PIN_LO_DECT) == 0) && !headphones_inserted();
|
|
}
|
|
|
|
void button_init_device(void)
|
|
{
|
|
key_val = ADC_MASK;
|
|
|
|
__gpio_as_input(PIN_BTN_POWER);
|
|
__gpio_as_input(PIN_BTN_HOLD);
|
|
|
|
__gpio_disable_pull(PIN_BTN_POWER);
|
|
__gpio_disable_pull(PIN_BTN_HOLD);
|
|
|
|
__gpio_as_irq_fall_edge(PIN_KEY_INT);
|
|
__gpio_disable_pull(PIN_KEY_INT);
|
|
system_enable_irq(GPIO_IRQ(PIN_KEY_INT));
|
|
|
|
__gpio_set_pin(PIN_CHARGE_CON); /* 0.7 A */
|
|
__gpio_as_output(PIN_CHARGE_CON);
|
|
|
|
__gpio_as_input(PIN_PH_DECT);
|
|
__gpio_enable_pull(PIN_PH_DECT);
|
|
/*__gpio_disable_pull(PIN_PH_DECT); // Spurious Detections */
|
|
|
|
__gpio_as_input(PIN_LO_DECT);
|
|
__gpio_enable_pull(PIN_LO_DECT);
|
|
/*__gpio_disable_pull(PIN_LO_DECT); // Spurious Detections */
|
|
}
|
|
|
|
bool button_hold(void)
|
|
{
|
|
bool hold_button = __gpio_get_pin(PIN_BTN_HOLD) == 1;
|
|
#ifndef BOOTLOADER
|
|
static bool hold_button_old = false;
|
|
if (hold_button != hold_button_old)
|
|
{
|
|
hold_button_old = hold_button;
|
|
backlight_hold_changed(hold_button);
|
|
}
|
|
#endif
|
|
return hold_button;
|
|
}
|
|
|
|
/* NOTE: Due to how this is wired, button combinations are not allowed
|
|
* unless one of the two buttons is the POWER
|
|
*
|
|
* Note --Update 2020
|
|
* by toggling BOP common I was able to remove BACK, OPTION, PLAY from the
|
|
* loop selectively and test which keys were pressed but this took two adc rounds
|
|
* and proved to be minimally useful for the added overhead
|
|
*
|
|
* NOW multiple button presses are emulated but button priority needs to be taken
|
|
* into consideration; higher priority keys 'overide' the lower priority keys
|
|
* VOLUP[7] VOLDN[6] PREV[5] NEXT[4] PLAY[3] OPTION[2] HOME[1]
|
|
*/
|
|
int button_read_device(void)
|
|
{
|
|
unsigned short key;
|
|
int btn = BUTTON_NONE;
|
|
int btn_pwr = BUTTON_NONE;
|
|
|
|
if (button_hold())
|
|
return BUTTON_NONE;
|
|
|
|
if (KEY_IS_DOWN(PIN_BTN_POWER))
|
|
btn_pwr = BUTTON_POWER;
|
|
|
|
if (!KEY_IS_DOWN(PIN_KEY_INT))
|
|
{
|
|
__intc_mask_irq(IRQ_SADC);
|
|
REG_SADC_ADENA &= ~ADENA_AUXEN;
|
|
return btn_pwr;
|
|
}
|
|
|
|
key = (key_val & ADC_MASK);
|
|
|
|
/* Don't initiate a new request if we have one pending */
|
|
if(!(REG_SADC_ADENA & (ADENA_AUXEN)))
|
|
{
|
|
REG_SADC_ADENA |= ADENA_AUXEN;
|
|
}
|
|
|
|
if (key < 261)
|
|
btn = BUTTON_VOL_UP;
|
|
else
|
|
if (key < 653)
|
|
btn = BUTTON_VOL_DOWN;
|
|
else
|
|
if (key < 1101)
|
|
btn = BUTTON_PREV;
|
|
else
|
|
if (key < 1498)
|
|
btn = BUTTON_NEXT;
|
|
else
|
|
if (key < 1839)
|
|
btn = BUTTON_PLAY;
|
|
else
|
|
if (key < 2213)
|
|
btn = BUTTON_OPTION;
|
|
else
|
|
if (key < 2600)
|
|
btn = BUTTON_HOME;
|
|
|
|
if (btn_last == BUTTON_NONE && TIME_AFTER(current_tick, btn_last_tick + HZ/20))
|
|
btn_last = btn;
|
|
|
|
if (btn_pwr != BUTTON_NONE)
|
|
btn |= BUTTON_PWRALT;
|
|
|
|
return btn | btn_last;
|
|
}
|
|
|
|
/* called on button press interrupt */
|
|
void KEY_INT_IRQ(void)
|
|
{
|
|
btn_last = BUTTON_NONE;
|
|
key_val = ADC_MASK;
|
|
__intc_unmask_irq(IRQ_SADC);
|
|
REG_SADC_ADENA |= ADENA_AUXEN;
|
|
btn_last_tick = current_tick;
|
|
}
|
|
|
|
/* Notes on batteries
|
|
|
|
xDuoo shipped two types of batteries:
|
|
|
|
First is the 2000mAh battery shipped in newer units
|
|
Second is the 1500mAh battery shipped in older units
|
|
|
|
*/
|
|
|
|
const unsigned short battery_level_dangerous[BATTERY_TYPES_COUNT] =
|
|
{
|
|
/* 5% */
|
|
3414, 3634
|
|
};
|
|
|
|
const unsigned short battery_level_shutoff[BATTERY_TYPES_COUNT] =
|
|
{
|
|
/* 0% */
|
|
3307, 3307
|
|
};
|
|
|
|
/* voltages (millivolt) of 0%, 10%, ... 100% when charging disabled */
|
|
const unsigned short percent_to_volt_discharge[BATTERY_TYPES_COUNT][11] =
|
|
{
|
|
{ 3307, 3459, 3530, 3575, 3608, 3648, 3723, 3819, 3918, 4022, 4162 },
|
|
{ 3300, 3652, 3704, 3730, 3753, 3786, 3836, 3906, 3973, 4061, 4160 }
|
|
};
|
|
|
|
#if CONFIG_CHARGING
|
|
/* voltages (millivolt) of 0%, 10%, ... 100% when charging enabled */
|
|
const unsigned short percent_to_volt_charge[11] =
|
|
// { 3300, 3652, 3704, 3730, 3753, 3786, 3836, 3906, 3973, 4061, 4160 };
|
|
{ 3444, 3827, 3893, 3909, 3931, 4001, 4067, 4150, 4206, 4207, 4208 };
|
|
#endif /* CONFIG_CHARGING */
|
|
|
|
/* VBAT = (BDATA/1024) * 2.5V */
|
|
#define BATTERY_SCALE_FACTOR 2460
|
|
|
|
/* Returns battery voltage from ADC [millivolts] */
|
|
int _battery_voltage(void)
|
|
{
|
|
static long last_tick = 0;
|
|
|
|
if (TIME_AFTER(current_tick, last_tick) && REG_SADC_ADENA == 0)
|
|
{
|
|
last_tick = current_tick;
|
|
__intc_mask_irq(IRQ_SADC);
|
|
REG_SADC_ADENA |= ADENA_VBATEN;
|
|
/* poll for value from our context instead of ISR */
|
|
while (!(REG_SADC_ADSTATE & ADCTRL_VRDYM) &&
|
|
TIME_BEFORE(current_tick, last_tick + HZ / 20))
|
|
;;
|
|
if ((REG_SADC_ADSTATE & ADCTRL_VRDYM))
|
|
{
|
|
last_tick += BATT_WAIT_TIME;
|
|
bat_val = REG_SADC_ADVDAT;
|
|
REG_SADC_ADSTATE &= ADCTRL_VRDYM; /* clear ready bit by writing 1*/
|
|
}
|
|
__intc_unmask_irq(IRQ_SADC);
|
|
}
|
|
|
|
return (bat_val*BATTERY_SCALE_FACTOR)>>10;
|
|
}
|
|
|
|
/* 12MHz XTAL
|
|
/61 = 196 MHz base clock (max is 200, err on the side of safety)
|
|
/(1+1) = 98.4KHz "us_clk (ie ~10us/tick)
|
|
/(199+1) = 983.6KHz "ms_clk" (ie ~1ms/tick)
|
|
*/
|
|
void adc_init(void)
|
|
{
|
|
bat_val = ADC_MASK;
|
|
/* don't re-init*/
|
|
if (!(REG_CPM_CLKGR0 & CLKGR0_SADC) && !(REG_SADC_ADENA & ADENA_POWER))
|
|
{
|
|
system_enable_irq(IRQ_SADC);
|
|
return;
|
|
}
|
|
|
|
__cpm_start_sadc();
|
|
mdelay(20);
|
|
REG_SADC_ADENA = 0; /* Power Up */
|
|
mdelay(70);
|
|
REG_SADC_ADSTATE = 0;
|
|
REG_SADC_ADCTRL = ADCTRL_MASK_ALL - ADCTRL_ARDYM - ADCTRL_VRDYM;
|
|
REG_SADC_ADCFG = ADCFG_VBAT_SEL | ADCFG_CMD_AUX(1); /* VBAT_SEL is undocumented but required! */
|
|
REG_SADC_ADCLK = (199 << 16) | (1 << 8) | 61;
|
|
system_enable_irq(IRQ_SADC);
|
|
REG_SADC_ADENA |= ADENA_AUXEN | ADENA_VBATEN;
|
|
}
|
|
|
|
void adc_close(void)
|
|
{
|
|
REG_SADC_ADENA = ADENA_POWER; /* Power Down */
|
|
__intc_mask_irq(IRQ_SADC);
|
|
mdelay(20);
|
|
__cpm_stop_sadc();
|
|
}
|
|
|
|
/* Interrupt handler */
|
|
void SADC(void)
|
|
{
|
|
unsigned char state;
|
|
unsigned char sadcstate;
|
|
sadcstate = REG_SADC_ADSTATE;
|
|
state = REG_SADC_ADSTATE & (~REG_SADC_ADCTRL);
|
|
REG_SADC_ADSTATE &= sadcstate;
|
|
|
|
if(state & ADCTRL_ARDYM)
|
|
{
|
|
key_val = REG_SADC_ADADAT;
|
|
}
|
|
else if(UNLIKELY(state & ADCTRL_VRDYM))
|
|
{
|
|
bat_val = REG_SADC_ADVDAT;
|
|
}
|
|
}
|