static void uart_init(size_t baud_rate)
{
GPIO_REG(GPIO_IOF_SEL) &= ~IOF0_UART0_MASK;
GPIO_REG(GPIO_IOF_EN) |= IOF0_UART0_MASK;
UART0_REG(UART_REG_DIV) = get_cpu_freq() / baud_rate - 1;
UART0_REG(UART_REG_TXCTRL) |= UART_TXEN;
}
static inline gpioregs *tcc892x_gpio_to_reg(unsigned gpio_port)
{
switch(gpio_port)
{
case GPIO_PORTA:
return (gpioregs *) GPIO_REG(HwGPIOA_BASE);
case GPIO_PORTB:
return (gpioregs *) GPIO_REG(HwGPIOB_BASE);
case GPIO_PORTC:
return (gpioregs *) GPIO_REG(HwGPIOC_BASE);
case GPIO_PORTD:
return (gpioregs *) GPIO_REG(HwGPIOD_BASE);
case GPIO_PORTE:
return (gpioregs *) GPIO_REG(HwGPIOE_BASE);
case GPIO_PORTF:
return (gpioregs *) GPIO_REG(HwGPIOF_BASE);
case GPIO_PORTG:
return (gpioregs *) GPIO_REG(HwGPIOG_BASE);
case GPIO_PORTHDMI:
return (gpioregs *) GPIO_REG(HwGPIOHDMI_BASE);
case GPIO_PORTADC:
return (gpioregs *) GPIO_REG(HwGPIOADC_BASE);
default:
break;
}
return NULL;
}
int gpio_amlogic_direction_output(struct gpio_chip *chip,unsigned offset, int value)
{
unsigned int reg,bit;
if(offset==GPIO_BSD_EN){
aml_clr_reg32_mask(P_PREG_PAD_GPIO0_O,1<<29);
#ifndef CONFIG_MESON_TRUSTZONE
aml_set_reg32_mask(P_AO_SECURE_REG0,1<<0);
#else
meson_secure_reg_write(P_AO_SECURE_REG0, meson_secure_reg_read(P_AO_SECURE_REG0) | (1<<0));
#endif
if(value)
aml_set_reg32_mask(P_PREG_PAD_GPIO0_O,1<<31);//out put high
else
aml_clr_reg32_mask(P_PREG_PAD_GPIO0_O,1<<31);//out put low
aml_clr_reg32_mask(P_PREG_PAD_GPIO0_O,1<<30);//out put enable
return 0;
}
if(offset==GPIO_TEST_N){
if(value)
aml_set_reg32_mask(P_AO_GPIO_O_EN_N,1<<31);//out put high
else
aml_clr_reg32_mask(P_AO_GPIO_O_EN_N,1<<31);//out put low
#ifndef CONFIG_MESON_TRUSTZONE
aml_set_reg32_mask(P_AO_SECURE_REG0,1);// out put enable
#else
meson_secure_reg_write(P_AO_SECURE_REG0, meson_secure_reg_read(P_AO_SECURE_REG0) | (1<<0));
#endif
return 0;
}
if(value){
reg=GPIO_REG(amlogic_pins[offset].out_value_reg_bit);
bit=GPIO_BIT(amlogic_pins[offset].out_value_reg_bit);
aml_set_reg32_mask(p_gpio_output_addr[reg],1<<bit);
gpio_print("out reg=%x,value=%x\n",p_gpio_output_addr[reg],aml_read_reg32(p_gpio_output_addr[reg]));
}
else{
reg=GPIO_REG(amlogic_pins[offset].out_value_reg_bit);
bit=GPIO_BIT(amlogic_pins[offset].out_value_reg_bit);
aml_clr_reg32_mask(p_gpio_output_addr[reg],1<<bit);
gpio_print("out reg=%x,value=%x\n",p_gpio_output_addr[reg],aml_read_reg32(p_gpio_output_addr[reg]));
}
reg=GPIO_REG(amlogic_pins[offset].out_en_reg_bit);
bit=GPIO_BIT(amlogic_pins[offset].out_en_reg_bit);
aml_clr_reg32_mask(p_gpio_oen_addr[reg],1<<bit);
gpio_print("==%s==%d\n",__FUNCTION__,__LINE__);
gpio_print("oen reg=%x,value=%x\n",p_gpio_oen_addr[reg],aml_read_reg32(p_gpio_oen_addr[reg]));
gpio_print("value=%d\n",value);
return 0;
}
static int clocksource_init (void)
{
/* disable timer initially */
GPIO_REG(GPIO_COUNTER_CTRL(0)) = 0;
/* Reset the timer value to zero */
GPIO_REG(GPIO_COUNTER_CURRENT(0)) = 0;
GPIO_REG(GPIO_COUNTER_MAX(0)) = 0xffffffff;
GPIO_REG(GPIO_COUNTER_CTRL(0)) = COUNTER_CTRL_RUN;
cs.mult = clocksource_hz2mult(100 * 1000 * 1000, cs.shift);
init_clock(&cs);
return 0;
}
int gpio_amlogic_get(struct gpio_chip *chip,unsigned offset)
{
unsigned int reg,bit;
gpio_print("==%s==%d\n",__FUNCTION__,__LINE__);
reg=GPIO_REG(amlogic_pins[offset].input_value_reg_bit);
bit=GPIO_BIT(amlogic_pins[offset].input_value_reg_bit);
return aml_get_reg32_bits(p_gpio_input_addr[reg],bit,1);
}
int gpio_amlogic_direction_input(struct gpio_chip *chip,unsigned offset)
{
unsigned int reg,bit;
gpio_print("==%s==%d\n",__FUNCTION__,__LINE__);
reg=GPIO_REG(amlogic_pins[offset].out_en_reg_bit);
bit=GPIO_BIT(amlogic_pins[offset].out_en_reg_bit);
aml_set_reg32_mask(p_gpio_oen_addr[reg],1<<bit);
return 0;
}
void gpio_amlogic_set(struct gpio_chip *chip,unsigned offset, int value)
{
unsigned int reg,bit;
reg=GPIO_REG(amlogic_pins[offset].out_value_reg_bit);
bit=GPIO_BIT(amlogic_pins[offset].out_value_reg_bit);
gpio_print("==%s==%d\n",__FUNCTION__,__LINE__);
if(value)
aml_set_reg32_mask(p_gpio_output_addr[reg],1<<bit);
else
aml_clr_reg32_mask(p_gpio_output_addr[reg],1<<bit);
}
int gpio_amlogic_requst(struct gpio_chip *chip,unsigned offset)
{
int ret;
unsigned int i,reg,bit;
unsigned int *gpio_reg=&gpio_to_pin[offset][0];
ret=pinctrl_request_gpio(offset);
gpio_print("==%s==%d\n",__FUNCTION__,__LINE__);
if(!ret){
for(i=0;i<sizeof(gpio_to_pin[offset])/sizeof(gpio_to_pin[offset][0]);i++){
if(gpio_reg[i]!=NONE)
{
reg=GPIO_REG(gpio_reg[i]);
bit=GPIO_BIT(gpio_reg[i]);
aml_clr_reg32_mask(p_pin_mux_reg_addr[reg],1<<bit);
gpio_print("clr reg=%d,bit =%d\n",reg,bit);
}
}
}
return ret;
}
int tcc_gpio_config_ext_intr(unsigned intr, unsigned source) /* intr: irq num, source: external interrupt source */
{
int extint;
GPIO *reg = (GPIO *) GPIO_REG(HwGPIO_BASE);
switch (intr) {
case INT_EI0: extint = EXINT_EI0; break;
case INT_EI1: extint = EXINT_EI1; break;
case INT_EI2: extint = EXINT_EI2; break;
case INT_EI3: extint = EXINT_EI3; break;
case INT_EI4: extint = EXINT_EI4; break;
case INT_EI5: extint = EXINT_EI5; break;
case INT_EI6: extint = EXINT_EI6; break;
case INT_EI7: extint = EXINT_EI7; break;
case INT_EI8: extint = EXINT_EI8; break;
case INT_EI9: extint = EXINT_EI9; break;
case INT_EI10: extint = EXINT_EI10; break;
case INT_EI11: extint = EXINT_EI11; break;
default:
extint = -1;
break;
}
if (extint < 0)
return -1;
if(extint < 4) {
RMWREG32(®->EINTSEL0.nREG, extint*8, 7, source);
}
else if(extint < 8) {
RMWREG32(®->EINTSEL1.nREG, (extint-4)*8, 7, source);
}
else if(extint < 12) {
RMWREG32(®->EINTSEL2.nREG, (extint-8)*8, 7, source);
}
return 0;
}
uint64_t netx_clocksource_read(void)
{
return GPIO_REG(GPIO_COUNTER_CURRENT(0));
}
//#define gpio_dump
//#define pull_dump
//#define dire_dump
static int amlogic_gpio_probe(struct platform_device *pdev)
{
#ifdef CONFIG_OF_GPIO
amlogic_gpio_chip.of_node = pdev->dev.of_node;
#endif
amlogic_gpio_chip.base=0;
amlogic_gpio_chip.ngpio=ARRAY_SIZE(amlogic_pins);
gpiochip_add(&amlogic_gpio_chip);
pullup_ops.meson_set_pullup=m8b_set_pullup;
dev_info(&pdev->dev, "Probed amlogic GPIO driver\n");
#ifdef gpio_dump
int gi;
for(gi=0;gi<GPIO_MAX;gi++)
printk("%s,amlogic_pins[%d]=%d,%d,out en reg=%x,bit=%d,out val reg=%x,bit=%d,input reg=%x,bit=%d\n",
amlogic_pins[gi].name,gi,amlogic_pins[gi].num,
gpio_amlogic_name_to_num(amlogic_pins[gi].name),
(p_gpio_oen_addr[GPIO_REG(amlogic_pins[gi].out_en_reg_bit)]&0xffff)>>2,
GPIO_BIT(amlogic_pins[gi].out_en_reg_bit),
(p_gpio_output_addr[GPIO_REG(amlogic_pins[gi].out_value_reg_bit)]&0xffff)>>2,
GPIO_BIT(amlogic_pins[gi].out_value_reg_bit),
(p_gpio_input_addr[GPIO_REG(amlogic_pins[gi].input_value_reg_bit)]&0xffff)>>2,
GPIO_BIT(amlogic_pins[gi].input_value_reg_bit)
);
#endif
#ifdef irq_dump
for(i=GPIO_IRQ0;i<GPIO_IRQ7+1;i++){
gpio_flag=AML_GPIO_IRQ(i,FILTER_NUM7,GPIO_IRQ_HIGH);
gpio_amlogic_to_irq(NULL,50);
}
for(i=GPIO_IRQ_HIGH;i<GPIO_IRQ_FALLING+1;i++){
gpio_flag=AML_GPIO_IRQ(GPIO_IRQ0,FILTER_NUM7,i);
gpio_amlogic_to_irq(NULL,50);
}
#endif
#ifdef pull_dump
int preg,pbit,penbit,pi;
for(pi=0;pi<GPIO_TEST_N;pi++){
m8b_pin_to_pullup(pi,&preg,&pbit,&penbit);
printk("%s \t,pull up en reg:%x \t,enbit:%d \t,==,pull up reg:%x \t,bit:%d \t\n",
amlogic_pins[pi].name,
(p_pull_upen_addr[preg]&0xffff)>>2,
penbit,
(p_pull_up_addr[preg]&0xffff)>>2,
pbit);
}
#endif
#ifdef dire_dump
extern int m8b_pin_map_to_direction(unsigned int pin,unsigned int *reg,unsigned int *bit);
int dreg,dbit,di;
for(di=0;di<GPIO_TEST_N;di++){
m8b_pin_map_to_direction(di,&dreg,&dbit);
printk("%s \t,output en reg:%x \t,enbit:%d \t\n",
amlogic_pins[di].name,
(p_gpio_oen_addr[dreg]&0xffff)>>2,
dbit);
}
#endif
return 0;
}
