//@board schematic: m3_skt_v1.pdf
//@pinmax: AppNote-M3-CorePinMux.xlsx
//GPIOA_26 used to set VCCX2_EN: 0 to enable power and 1 to disable power
static void gpio_set_vbus_power(char is_power_on)
{
#if 0
if(is_power_on)
{
//@WA-AML8726-M3_REF_V1.0.pdf
//GPIOA_26 -- VCCX2_EN
set_gpio_mode(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), 0);
//@WA-AML8726-M3_REF_V1.0.pdf
//GPIOD_9 -- USB_PWR_CTL
set_gpio_mode(GPIOD_bank_bit0_9(9), GPIOD_bit_bit0_9(9), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOD_bank_bit0_9(9), GPIOD_bit_bit0_9(9), 1);
udelay(100000);
}
else
{
set_gpio_mode(GPIOD_bank_bit0_9(9), GPIOD_bit_bit0_9(9), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOD_bank_bit0_9(9), GPIOD_bit_bit0_9(9), 0);
set_gpio_mode(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), 1);
}
#endif
}
int board_eth_init(bd_t *bis)
{
/* Use Misc PLL for the source of ethernet */
eth_clk_set(ETH_CLKSRC_MISC_CLK, get_misc_pll_clk(), (50 * CLK_1M));
/* Use Internal clock output from GPIOY0*/
eth_set_pinmux(ETH_BANK0_GPIOY1_Y9, ETH_CLK_OUT_GPIOY0_REG6_17, 0);
/*disalbe*/
//reset:LCD_G5
writel(readl(ETH_PLL_CNTL) & ~(1 << 0), ETH_PLL_CNTL); // Disable the Ethernet clocks
// ---------------------------------------------
// Test 50Mhz Input Divide by 2
// ---------------------------------------------
// Select divide by 2
writel(readl(ETH_PLL_CNTL) | (0 << 3), ETH_PLL_CNTL); // desc endianess "same order"
writel(readl(ETH_PLL_CNTL) | (0 << 2), ETH_PLL_CNTL); // data endianess "little"
writel(readl(ETH_PLL_CNTL) | (1 << 1), ETH_PLL_CNTL); // divide by 2 for 100M
writel(readl(ETH_PLL_CNTL) | (1 << 0), ETH_PLL_CNTL); // enable Ethernet clocks
udelay(100);
/* reset phy with GPIOA_23*/
set_gpio_mode(GPIOA_bank_bit0_27(23), GPIOA_bit_bit0_27(23), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(23), GPIOA_bit_bit0_27(23), 0);
udelay(100); //GPIOE_bank_bit16_21(16) reset end;
set_gpio_val(GPIOA_bank_bit0_27(23), GPIOA_bit_bit0_27(23), 1);
udelay(100); //waiting reset end;
aml_eth_init(bis);
return 0;
}
/*
* When BAT_SEL(GPIOA_22) is High Vbat=Vadc*2
*/
static inline int measure_voltage(void)
{
int val;
msleep(2);
set_gpio_mode(GPIOA_bank_bit0_27(22), GPIOA_bit_bit0_27(22), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(22), GPIOA_bit_bit0_27(22), 1);
val = get_adc_sample(5) * (2 * 2500000 / 1023);
printf("%s: get from adc is %duV.\n", __FUNCTION__, val);
return val;
}
int camera_power_off(void)
{
printf( "amlogic camera driver: ov2655_v4l2_uninit. \n");
set_gpio_val(GPIOA_bank_bit0_27(24), GPIOA_bit_bit0_27(24), 1); // set camera power disable
set_gpio_mode(GPIOA_bank_bit0_27(24), GPIOA_bit_bit0_27(24), GPIO_OUTPUT_MODE);
printf( "amlogic camera driver: gc0308_v4l2_uninit. \n");
set_gpio_val(GPIOA_bank_bit0_27(25), GPIOA_bit_bit0_27(25), 1); // set camera power disable
set_gpio_mode(GPIOA_bank_bit0_27(25), GPIOA_bit_bit0_27(25), GPIO_OUTPUT_MODE);
}
int is_ac_connected2(void)
{
int val;
SET_CBUS_REG_MASK(PAD_PULL_UP_REG0, (1<<20)); //enable internal pullup
set_gpio_mode(GPIOA_bank_bit0_27(20), GPIOA_bit_bit0_27(20), GPIO_INPUT_MODE);
val = get_gpio_val(GPIOA_bank_bit0_27(20), GPIOA_bit_bit0_27(20));
printf( "2nd is_ac_connected=%x\n", val);
return val;
}
static void gpio_set_vbus_power(char is_power_on)
{
if(is_power_on){
set_gpio_mode(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), 0);
udelay(100000);
}else{
set_gpio_mode(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), 1);
}
}
/*
* DC_DET(GPIOA_20) enable internal pullup
* High: Disconnect
* Low: Connect
*/
static inline int is_ac_online(void)
{
int val;
SET_CBUS_REG_MASK(PAD_PULL_UP_REG0, (1<<20)); //enable internal pullup
set_gpio_mode(GPIOA_bank_bit0_27(20), GPIOA_bit_bit0_27(20), GPIO_INPUT_MODE);
val = get_gpio_val(GPIOA_bank_bit0_27(20), GPIOA_bit_bit0_27(20));
printf("%s: get from gpio is %d.\n", __FUNCTION__, val);
return !val;
}
static void gpio_keys_init(void)
{
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 3, 1);
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 4, 1);
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 5, 1);
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 6, 1);
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 7, 1);
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 8, 1);
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 9, 1);
WRITE_CBUS_REG_BITS(PAD_PULL_UP_REG0, 1, 10, 1);
WRITE_CBUS_REG_BITS(PERIPHS_PIN_MUX_0, 0, 6, 1);
WRITE_CBUS_REG_BITS(PERIPHS_PIN_MUX_3, 0, 0, 3);
WRITE_CBUS_REG_BITS(PERIPHS_PIN_MUX_3, 0, 5, 1);
WRITE_CBUS_REG_BITS(PERIPHS_PIN_MUX_6, 0, 19, 5);
set_gpio_mode(GPIOA_bank_bit0_27(3), GPIOA_bit_bit0_27(3), GPIO_INPUT_MODE);
set_gpio_mode(GPIOA_bank_bit0_27(4), GPIOA_bit_bit0_27(4), GPIO_INPUT_MODE);
set_gpio_mode(GPIOA_bank_bit0_27(5), GPIOA_bit_bit0_27(5), GPIO_INPUT_MODE);
set_gpio_mode(GPIOA_bank_bit0_27(6), GPIOA_bit_bit0_27(6), GPIO_INPUT_MODE);
set_gpio_mode(GPIOA_bank_bit0_27(7), GPIOA_bit_bit0_27(7), GPIO_INPUT_MODE);
set_gpio_mode(GPIOA_bank_bit0_27(8), GPIOA_bit_bit0_27(8), GPIO_INPUT_MODE);
set_gpio_mode(GPIOA_bank_bit0_27(9), GPIOA_bit_bit0_27(9), GPIO_INPUT_MODE);
set_gpio_mode(GPIOA_bank_bit0_27(10), GPIOA_bit_bit0_27(10), GPIO_INPUT_MODE);
}
/*
* Get Vhigh when BAT_SEL(GPIOA_22) is High.
* Get Vlow when BAT_SEL(GPIOA_22) is Low.
* I = Vdiff / 0.02R
* Vdiff = Vhigh - Vlow
*/
static inline int measure_current(void)
{
int val, Vh, Vl, Vdiff;
set_gpio_mode(GPIOA_bank_bit0_27(22), GPIOA_bit_bit0_27(22), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(22), GPIOA_bit_bit0_27(22), 1);
msleep(2);
Vl = get_adc_sample(5) * (2 * 2500000 / 1023);
printf("%s: Vh is %duV.\n", __FUNCTION__, Vh);
set_gpio_mode(GPIOA_bank_bit0_27(22), GPIOA_bit_bit0_27(22), GPIO_OUTPUT_MODE);
set_gpio_val(GPIOA_bank_bit0_27(22), GPIOA_bit_bit0_27(22), 0);
msleep(2);
Vh = get_adc_sample(5) * (2 * 2500000 / 1023);
printf("%s: Vl is %duV.\n", __FUNCTION__, Vl);
Vdiff = Vh - Vl;
val = Vdiff * 50;
printf("%s: get from adc is %duA.\n", __FUNCTION__, val);
return val;
}
static void scan_keys(struct kp *kp)
{
struct input_dev *input = kp->input;
keyl = get_gpio_val(GPIOA_bank_bit0_27(3), GPIOA_bit_bit0_27(3));
keyr = get_gpio_val(GPIOA_bank_bit0_27(5), GPIOA_bit_bit0_27(5));
keya = get_gpio_val(GPIOA_bank_bit0_27(7), GPIOA_bit_bit0_27(7));
keyb = get_gpio_val(GPIOA_bank_bit0_27(8), GPIOA_bit_bit0_27(8));
keyx = get_gpio_val(GPIOA_bank_bit0_27(9), GPIOA_bit_bit0_27(9));
keyy = get_gpio_val(GPIOA_bank_bit0_27(10), GPIOA_bit_bit0_27(10));
if(keyl == keyl_old){
if (key_param[0]) {
if(keyl) {
key_report(kp, key_param[12], key_param[13], 6);
input_report_key(input, BUTTON_L, 1);
kp->flagl = 0;
} else {
input_report_key(input, BUTTON_L, 0);
kp->flagl = 1;
}
} else if (keyl == kp->flagl) {
if(keyl) {
input_report_key(input, BUTTON_L, 1);
input_mt_sync(input);
kp->flagl = 0;
printk("KEY L\n");
} else {
input_report_key(input, BUTTON_L, 0);
input_mt_sync(input);
kp->flagl = 1;
printk("KEY L release\n");
}
}
}
if(keyr == keyr_old){
if (key_param[0]) {
if(keyr) {
key_report(kp, key_param[14], key_param[15], 7);
kp->flagr = 0;
} else {
kp->flagr = 1;
}
} else if (keyr == kp->flagr) {
if(keyr) {
input_report_key(input, BUTTON_R, 1);
input_mt_sync(input);
kp->flagr = 0;
printk("KEY R\n");
} else {
input_report_key(input, BUTTON_R, 0);
input_mt_sync(input);
kp->flagr = 1;
printk("KEY R release\n");
}
}
}
if(keya == keya_old){
if (key_param[0]) {
if(keya) {
key_report(kp, key_param[4], key_param[5], 2);
kp->flaga = 0;
} else {
kp->flaga = 1;
}
} else if (keya == kp->flaga) {
if(keya) {
input_report_key(input, BUTTON_A, 1);
input_mt_sync(input);
kp->flaga = 0;
printk("KEY A\n");
} else {
input_report_key(input, BUTTON_A, 0);
input_mt_sync(input);
kp->flaga = 1;
printk("KEY A release\n");
}
}
}
if(keyb == keyb_old){
if (key_param[0]) {
if(keyb) {
key_report(kp, key_param[6], key_param[7], 3);
kp->flagb = 0;
} else {
kp->flagb = 1;
}
} else if (keyb == kp->flagb) {
if(keyb) {
input_report_key(input, BUTTON_B, 1);
input_mt_sync(input);
kp->flagb = 0;
printk("KEY B\n");
} else {
input_report_key(input, BUTTON_B, 0);
input_mt_sync(input);
printk("KEY B release\n");
kp->flagb = 1;
}
}
}
if(keyx == keyx_old){
if (key_param[0]) {
if(keyx) {
key_report(kp, key_param[8], key_param[9], 4);
kp->flagx = 0;
} else {
kp->flagx = 1;
}
} else if (keyx == kp->flagx) {
if(keyx) {
input_report_key(input, BUTTON_X, 1);
input_mt_sync(input);
kp->flagx = 0;
printk("KEY X\n");
} else {
input_report_key(input, BUTTON_X, 0);
input_mt_sync(input);
kp->flagx = 1;
printk("KEY X release\n");
}
}
}
if(keyy == keyy_old){
if (key_param[0]) {
if(keyy) {
key_report(kp, key_param[10], key_param[11], 5);
kp->flagy = 0;
} else {
kp->flagy = 1;
}
} else if (keyy == kp->flagy) {
if(keyy) {
input_report_key(input, BUTTON_Y, 1);
input_mt_sync(input);
kp->flagy = 0;
printk("KEY Y\n");
} else {
input_report_key(input, BUTTON_Y, 0);
input_mt_sync(input);
kp->flagy = 1;
printk("KEY Y release\n");
}
}
}
keyl_old = keyl;
keyr_old = keyr;
keya_old = keya;
keyb_old = keyb;
keyx_old = keyx;
keyy_old = keyy;
}
static inline int _gpio_setup_bank_bit(cmd_t *op)
{
switch (op->bank) {
case 'a': //bank a
op->bank = GPIOA_bank_bit0_27(0);
if (op->bit < 28) { //bit0..27
op->bit = GPIOA_bit_bit0_27(op->bit);
} else {
return -1;
}
break;
case 'b': //bank b
op->bank = GPIOB_bank_bit0_23(0);
if (op->bit < 24) { //bit0..23
op->bit = GPIOB_bit_bit0_23(op->bit);
} else {
return -1;
}
break;
case 'c': //bank c
op->bank = GPIOC_bank_bit0_15(0);
if (op->bit < 16) { //bit0..15
op->bit = GPIOC_bit_bit0_15(op->bit);
} else {
return -1;
}
break;
case 'd': //bank d
op->bank = GPIOD_bank_bit0_9(0);
if (op->bit < 10) { //bit0..9
op->bit = GPIOD_bit_bit0_9(op->bit);
} else {
return -1;
}
break;
case 'x': //bank x
if (op->bit < 32) { //bit0..31 ,bit no change .
op->bank = GPIOX_bank_bit0_31(0); //bit 0..15 16..21 share one bank
} else if (op->bit <36) { //bit 32..35
op->bank = GPIOX_bank_bit32_35(0);
op->bit = GPIOX_bit_bit32_35(op->bit);
} else {
return -1;
}
break;
case 'y': //bank y
if (op->bit < 23) { //bit0..22 ,bit no change .
op->bank = GPIOY_bank_bit0_22(0); //bit 0..15 16..21 share one bank
} else {
return -1;
}
break;
case 'o': //bank ao
if (op->bit < 12) { //bit0..11 ,bit no change .
op->bank = GPIOAO_bank_bit0_11(0); //bit 0..11
op->bit = GPIOAO_bit_bit0_11(op->bit);
} else {
return -1;
}
break;
/* FIXME AO/BOOT/CARD GPIO can not controle todo */
default:
printk("GPIO, invalid selection.\n");
return -1;
}
return 0;
}
char* name;
unsigned gpio_bank;
unsigned gpio_bit;
int inverse_flag;
} device_power_t;
#define DEF_DEVICE_POWER(name_param, gpio_bank_param, gpio_bit_param, inverse_flag_param) \
{ \
.name = (name_param), \
.gpio_bank = (gpio_bank_param), \
.gpio_bit = (gpio_bit_param), \
.inverse_flag = (inverse_flag_param), \
}
static device_power_t devices_power[] = {
DEF_DEVICE_POWER("VCCX2_EN", GPIOA_bank_bit0_27(26), GPIOA_bit_bit0_27(26), 1),
DEF_DEVICE_POWER("VCCX3_EN", GPIOC_bank_bit0_15(2), GPIOC_bit_bit0_15(2), 0),
DEF_DEVICE_POWER("LCD_POWER_EN", GPIOA_bank_bit0_27(27), GPIOA_bit_bit0_27(27), 1),
DEF_DEVICE_POWER("BL_EN", GPIOD_bank_bit0_9(1), GPIOD_bit_bit0_9(1), 0),
DEF_DEVICE_POWER("CARD_EN", GPIOCARD_bank_bit0_8(8), GPIOCARD_bit_bit0_8(8), 1),
DEF_DEVICE_POWER("USB_PWR_CTRL", GPIOD_bank_bit0_9(9), GPIOD_bit_bit0_9(9), 0),
DEF_DEVICE_POWER("SPK", GPIOC_bank_bit0_15(4), GPIOC_bit_bit0_15(4), 0),
DEF_DEVICE_POWER("CAP_TP_EN", GPIOC_bank_bit0_15(3), GPIOC_bit_bit0_15(3), 0),
DEF_DEVICE_POWER("WIFI_PWREN", GPIOC_bank_bit0_15(8), GPIOC_bit_bit0_15(8), 0),
DEF_DEVICE_POWER("WL_RST_N", GPIOC_bank_bit0_15(7), GPIOC_bit_bit0_15(7), 0),
DEF_DEVICE_POWER("BT_RST_N", GPIOC_bank_bit0_15(6), GPIOC_bit_bit0_15(6), 0),
DEF_DEVICE_POWER("GPS_RSTN", GPIOC_bank_bit0_15(5), GPIOC_bit_bit0_15(5), 0),
};
static int get_dev_power_state(char* info_buf)
{
