rt-thread/bsp/allwinner_tina/drivers/drv_gpio.c

565 lines
16 KiB
C
Raw Normal View History

/*
* File : drv_gpio.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2017, RT-Thread Development Team
*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Change Logs:
* Date Author Notes
* 2018-02-08 RT-Thread the first version
*/
#include <rtthread.h>
#include <rthw.h>
#include "drv_gpio.h"
#include "interrupt.h"
#define DBG_ENABLE
#define DBG_SECTION_NAME "GPIO"
#define DBG_LEVEL DBG_WARNING
#define DBG_COLOR
#include <rtdbg.h>
#define readl(addr) (*(volatile unsigned int *)(addr))
#define writel(value,addr) (*(volatile unsigned int *)(addr) = (value))
// Todo: add RT_ASSERT.
/*********************************************************
** IO
*********************************************************/
int gpio_set_func(enum gpio_port port, enum gpio_pin pin, rt_uint8_t func)
{
rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_A <= port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
if (func & 0x8)
{
LOG_W("[line]:%d There is a warning with parameter input", __LINE__);
return RT_EINVAL;
}
addr = GPIOn_CFG_ADDR(port) + (pin / 8) * 4;
offset = (pin % 8) * 4;
data = readl(addr);
data &= ~(0x7 << offset);
data |= func << offset;
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
return RT_EOK;
}
int gpio_set_value(enum gpio_port port, enum gpio_pin pin, rt_uint8_t value)
{
rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_A <= port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
if (value & 0xE)
{
LOG_W("[line]:%d There is a warning with parameter input", __LINE__);
return RT_EINVAL;
}
addr = GPIOn_DATA_ADDR(port);
offset = pin;
data = readl(addr);
data &= ~(0x1 << offset);
data |= value << offset;
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
return RT_EOK;
}
int gpio_get_value(enum gpio_port port, enum gpio_pin pin)
{
rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_A <= port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
addr = GPIOn_DATA_ADDR(port);
offset = pin;
data = readl(addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
return (data >> offset) & 0x01;
}
int gpio_set_pull_mode(enum gpio_port port, enum gpio_pin pin, enum gpio_pull pull)
{
rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_A <= port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
if (pull & 0xC)
{
LOG_W("[line]:%d There is a warning with parameter input", __LINE__);
return RT_EINVAL;
}
addr = GPIOn_PUL_ADDR(port);
addr += pin > GPIO_PIN_15 ? 0x4 : 0x0;
offset = (pin & 0xf) << 1;
data = readl(addr);
data &= ~(0x3 << offset);
data |= pull << offset;
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
return RT_EOK;
}
int gpio_set_drive_level(enum gpio_port port, enum gpio_pin pin, enum gpio_drv_level level)
{
volatile rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_A <= port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
if (level & 0xC)
{
LOG_W("[line]:%d There is a warning with parameter input", __LINE__);
return RT_EINVAL;
}
addr = GPIOn_DRV_ADDR(port);
addr += pin > GPIO_PIN_15 ? 0x4 : 0x0;
offset = (pin & 0xf) << 1;
data = readl(addr);
data &= ~(0x3 << offset);
data |= level << offset;
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
return RT_EOK;
}
void gpio_direction_input(enum gpio_port port, enum gpio_pin pin)
{
volatile rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_A <= port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
addr = GPIOn_CFG_ADDR(port) + (pin / 8) * 4;
offset = (pin % 8) * 4;
data = readl(addr);
data &= ~(0x7 << offset);
data |= IO_INPUT << offset;
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
}
void gpio_direction_output(enum gpio_port port, enum gpio_pin pin, int value)
{
volatile rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_A <= port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
gpio_set_value(port, pin, value);
addr = GPIOn_CFG_ADDR(port) + (pin / 8) * 4;
offset = (pin % 8) * 4;
data = readl(addr);
data &= ~(0x7 << offset);
data |= IO_OUTPUT << offset;
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
}
/*********************************************************
** IRQ
*********************************************************/
static void gpio_ack_irq(enum gpio_port port, enum gpio_pin pin)
{
rt_uint32_t addr;
rt_uint32_t data;
addr = GPIOn_INT_STA_ADDR(port);
data = readl(addr);
data |= 0x1 << pin;
writel(data, addr);
}
void gpio_select_irq_clock(enum gpio_port port, enum gpio_irq_clock clock)
{
rt_uint32_t addr;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_C < port) && (port < GPIO_PORT_NUM));
addr = GPIOn_INT_DEB_ADDR(port - GPIO_PORT_D);
data = readl(addr);
data &= ~0x01;
data |= clock;
writel(data, addr);
LOG_D("[line]:%d addr:%08x data:%08x", __LINE__, addr, *((rt_uint32_t *)addr));
}
void gpio_set_debounce(enum gpio_port port, enum gpio_direction_type prescaler)
{
rt_uint32_t addr;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_C < port) && (port < GPIO_PORT_NUM));
addr = GPIOn_INT_DEB_ADDR(port - GPIO_PORT_D);
data = readl(addr);
data &= ~(0x07 << 4);
data |= prescaler << 4;
writel(data, addr);
LOG_D("[line]:%d addr:%08x data:%08x", __LINE__, addr, *((rt_uint32_t *)addr));
}
void gpio_irq_enable(enum gpio_port port, enum gpio_pin pin)
{
rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_C < port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
addr = GPIOn_INT_CTRL_ADDR(port - GPIO_PORT_D);
offset = pin;
data = readl(addr);
data |= 0x1 << offset;
writel(data, addr);
gpio_select_irq_clock(port, GPIO_IRQ_HOSC_24MHZ);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
}
void gpio_irq_disable(enum gpio_port port, enum gpio_pin pin)
{
rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_C < port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
gpio_ack_irq(port - GPIO_PORT_D, pin);
addr = GPIOn_INT_CTRL_ADDR(port - GPIO_PORT_D);
offset = pin;
data = readl(addr);
data &= ~(0x1 << offset);
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
}
void gpio_set_irq_type(enum gpio_port port, enum gpio_pin pin, enum gpio_irq_type irq_type)
{
rt_uint32_t addr;
rt_uint32_t offset;
rt_uint32_t data;
RT_ASSERT((GPIO_PORT_C < port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
addr = GPIOn_INT_CFG_ADDR(port - GPIO_PORT_D) + (pin / 8) * 4;
offset = (pin % 8) * 4;
data = readl(addr);
data &= ~(0x7 << offset);
data |= irq_type << offset;
writel(data, addr);
LOG_D("[line]:%d offset:%d addr:%08x data:%08x", __LINE__, offset, addr, *((rt_uint32_t *)addr));
}
static struct gpio_irq_def _g_gpio_irq_tbl[GPIO_PORT_NUM];
void gpio_set_irq_callback(enum gpio_port port, enum gpio_pin pin, void (*irq_cb)(void *), void *irq_arg)
{
RT_ASSERT((GPIO_PORT_C < port) && (port < GPIO_PORT_NUM));
RT_ASSERT((GPIO_PIN_0 <= pin) && (pin < GPIO_PIN_NUM));
_g_gpio_irq_tbl[port].irq_cb[pin] = irq_cb;
_g_gpio_irq_tbl[port].irq_arg[pin] = irq_arg;
}
void gpio_clear_irq_callback(enum gpio_port port, enum gpio_pin pin)
{
gpio_irq_disable(port, pin);
_g_gpio_irq_tbl[port].irq_cb[pin] = RT_NULL;
_g_gpio_irq_tbl[port].irq_arg[pin] = RT_NULL;
}
static void gpio_irq_handler(int irq, void *param)
{
struct gpio_irq_def *irq_def = (struct gpio_irq_def *)param;
rt_uint32_t pend, enable;
int port, pin;
rt_uint32_t addr;
pin = 0;
port = irq - PIOD_INTERRUPT;
addr = GPIOn_INT_STA_ADDR(port);
pend = readl(addr);
addr = GPIOn_INT_CTRL_ADDR(port);
enable = readl(addr);
pend &= enable;
while (pend)
{
if ((pend & 0x1) && (irq_def->irq_cb[pin] != RT_NULL))
{
LOG_D("do irq callback...", port, pin);
irq_def->irq_cb[pin](irq_def->irq_arg[pin]);
}
pin++;
pend = pend >> 1;
gpio_ack_irq(port, pin);
}
}
#ifdef RT_USING_PIN
#include <rtdevice.h>
#define PIN_MAGIC (0x5A)
#define PIN_NUM(_N) (sizeof(_N) / sizeof(_N[0]))
struct _pin_index
{
rt_uint8_t id;
rt_uint8_t pin_port;
rt_uint8_t pin;
rt_uint8_t magic;
};
static struct _pin_index pin_index[] =
{
{0, 0, 0, 0},
{1, 0, 0, 0},
{2, 0, 0, 0},
{3, 0, 0, 0},
{4, 0, 0, 0},
{5, 0, 0, 0},
{6, GPIO_PORT_D, GPIO_PIN_0, PIN_MAGIC},
{7, GPIO_PORT_D, GPIO_PIN_1, PIN_MAGIC},
{8, GPIO_PORT_D, GPIO_PIN_2, PIN_MAGIC},
{9, GPIO_PORT_D, GPIO_PIN_3, PIN_MAGIC},
{10, GPIO_PORT_D, GPIO_PIN_4, PIN_MAGIC},
{11, GPIO_PORT_D, GPIO_PIN_5, PIN_MAGIC},
{12, GPIO_PORT_D, GPIO_PIN_6, PIN_MAGIC},
{13, GPIO_PORT_D, GPIO_PIN_7, PIN_MAGIC},
{14, GPIO_PORT_D, GPIO_PIN_8, PIN_MAGIC},
{15, GPIO_PORT_D, GPIO_PIN_9, PIN_MAGIC},
{16, GPIO_PORT_D, GPIO_PIN_10, PIN_MAGIC},
{17, GPIO_PORT_D, GPIO_PIN_11, PIN_MAGIC},
{18, GPIO_PORT_D, GPIO_PIN_12, PIN_MAGIC},
{19, GPIO_PORT_D, GPIO_PIN_13, PIN_MAGIC},
{20, 0, 0, 0},
{21, GPIO_PORT_D, GPIO_PIN_14, PIN_MAGIC},
{22, 0, 0, 0},
{23, GPIO_PORT_D, GPIO_PIN_15, PIN_MAGIC},
{24, GPIO_PORT_D, GPIO_PIN_16, PIN_MAGIC},
{25, GPIO_PORT_D, GPIO_PIN_17, PIN_MAGIC},
{26, GPIO_PORT_D, GPIO_PIN_18, PIN_MAGIC},
{27, GPIO_PORT_D, GPIO_PIN_19, PIN_MAGIC},
{28, GPIO_PORT_D, GPIO_PIN_20, PIN_MAGIC},
{29, GPIO_PORT_D, GPIO_PIN_21, PIN_MAGIC},
{30, 0, 0, 0},
{31, 0, 0, 0},
{32, 0, 0, 0},
{33, 0, 0, 0},
{34, 0, 0, 0},
{35, 0, 0, 0},
{36, 0, 0, 0},
{37, GPIO_PORT_E, GPIO_PIN_12, PIN_MAGIC},
{38, GPIO_PORT_E, GPIO_PIN_11, PIN_MAGIC},
{39, GPIO_PORT_E, GPIO_PIN_10, PIN_MAGIC},
{40, GPIO_PORT_E, GPIO_PIN_9, PIN_MAGIC},
{41, GPIO_PORT_E, GPIO_PIN_8, PIN_MAGIC},
{42, GPIO_PORT_E, GPIO_PIN_7, PIN_MAGIC},
{43, GPIO_PORT_E, GPIO_PIN_6, PIN_MAGIC},
{44, GPIO_PORT_E, GPIO_PIN_5, PIN_MAGIC},
{45, GPIO_PORT_E, GPIO_PIN_4, PIN_MAGIC},
{46, GPIO_PORT_E, GPIO_PIN_3, PIN_MAGIC},
{47, GPIO_PORT_E, GPIO_PIN_2, PIN_MAGIC},
{48, GPIO_PORT_E, GPIO_PIN_1, PIN_MAGIC},
{49, GPIO_PORT_E, GPIO_PIN_0, PIN_MAGIC},
{50, 0, 0, 0},
{51, 0, 0, 0},
{52, 0, 0, 0},
{53, GPIO_PORT_F, GPIO_PIN_5, PIN_MAGIC},
{54, GPIO_PORT_F, GPIO_PIN_4, PIN_MAGIC},
{55, GPIO_PORT_F, GPIO_PIN_3, PIN_MAGIC},
{56, GPIO_PORT_F, GPIO_PIN_2, PIN_MAGIC},
{57, GPIO_PORT_F, GPIO_PIN_1, PIN_MAGIC},
{58, GPIO_PORT_F, GPIO_PIN_0, PIN_MAGIC},
{59, GPIO_PORT_C, GPIO_PIN_0, PIN_MAGIC},
{60, GPIO_PORT_C, GPIO_PIN_1, PIN_MAGIC},
{61, GPIO_PORT_C, GPIO_PIN_2, PIN_MAGIC},
{62, GPIO_PORT_C, GPIO_PIN_3, PIN_MAGIC},
{63, GPIO_PORT_A, GPIO_PIN_3, PIN_MAGIC},
{64, GPIO_PORT_A, GPIO_PIN_2, PIN_MAGIC},
{65, GPIO_PORT_A, GPIO_PIN_1, PIN_MAGIC},
{66, GPIO_PORT_A, GPIO_PIN_0, PIN_MAGIC},
};
static void pin_mode(struct rt_device *dev, rt_base_t pin, rt_base_t mode)
{
if ((pin > PIN_NUM(pin_index)) || (pin_index[pin].magic != PIN_MAGIC))
{
LOG_E("pin:%d value wrongful", pin);
return;
}
gpio_set_func(pin_index[pin].pin_port, pin_index[pin].pin, mode);
}
static void pin_write(struct rt_device *dev, rt_base_t pin, rt_base_t value)
{
if ((pin > PIN_NUM(pin_index)) || (pin_index[pin].magic != PIN_MAGIC))
{
LOG_E("pin:%d value wrongful", pin);
return;
}
gpio_set_value(pin_index[pin].pin_port, pin_index[pin].pin, value);
}
static int pin_read(struct rt_device *device, rt_base_t pin)
{
if ((pin > PIN_NUM(pin_index)) || (pin_index[pin].magic != PIN_MAGIC))
{
LOG_E("pin:%d value wrongful", pin);
return 0;
}
return gpio_get_value(pin_index[pin].pin_port, pin_index[pin].pin);
}
static rt_err_t pin_attach_irq(struct rt_device *device, rt_int32_t pin, rt_uint32_t mode, void (*hdr)(void *args), void *args)
{
if ((pin > PIN_NUM(pin_index)) || (pin_index[pin].magic != PIN_MAGIC))
{
LOG_E("pin:%d value wrongful", pin);
return RT_ERROR;
}
gpio_set_irq_callback(pin_index[pin].pin_port, pin_index[pin].pin, hdr, args);
gpio_set_irq_type(pin_index[pin].pin_port, pin_index[pin].pin, mode);
return RT_EOK;
}
static rt_err_t pin_detach_irq(struct rt_device *device, rt_int32_t pin)
{
if ((pin > PIN_NUM(pin_index)) || (pin_index[pin].magic != PIN_MAGIC))
{
LOG_E("pin:%d value wrongful", pin);
return RT_ERROR;
}
gpio_clear_irq_callback(pin_index[pin].pin_port, pin_index[pin].pin);
return RT_EOK;
}
rt_err_t pin_irq_enable(struct rt_device *device, rt_base_t pin, rt_uint32_t enabled)
{
if ((pin > PIN_NUM(pin_index)) || (pin_index[pin].magic != PIN_MAGIC))
{
LOG_E("pin:%d value wrongful", pin);
return RT_ERROR;
}
if (enabled)
gpio_irq_enable(pin_index[pin].pin_port, pin_index[pin].pin);
else
gpio_irq_disable(pin_index[pin].pin_port, pin_index[pin].pin);
return RT_EOK;
}
/*
ID GPIO ID GPIO ID GPIO ID GPIO ID GPIO ID GPIO ID GPIO
6 PD0 13 PD7 21 PD14 29 PD21 43 PE6 53 PF5 60 PC1
7 PD1 14 PD8 23 PD15 37 PE12 44 PE5 54 PF4 61 PC2
8 PD2 15 PD9 24 PD16 38 PE11 45 PE4 55 PF3 62 PC3
9 PD3 16 PD10 25 PD17 39 PE10 46 PE3 56 PF2 63 PA3
10 PD4 17 PD11 26 PD18 40 PE9 47 PE2 57 PF1 64 PA2
11 PD5 18 PD12 27 PD19 41 PE8 48 PE1 58 PF0 65 PA1
12 PD6 19 PD13 28 PD20 42 PE7 49 PE0 59 PC0 66 PA0
*/
static const struct rt_pin_ops ops =
{
pin_mode,
pin_write,
pin_read,
pin_attach_irq,
pin_detach_irq,
pin_irq_enable,
};
#endif
int rt_hw_gpio_init(void)
{
#ifdef RT_USING_PIN
rt_device_pin_register("gpio", &ops, RT_NULL);
#endif
/* install ISR */
rt_hw_interrupt_install(PIOD_INTERRUPT, gpio_irq_handler, &_g_gpio_irq_tbl[GPIO_PORT_D], "gpiod_irq");
rt_hw_interrupt_umask(PIOD_INTERRUPT);
rt_hw_interrupt_install(PIOE_INTERRUPT, gpio_irq_handler, &_g_gpio_irq_tbl[GPIO_PORT_E], "gpioe_irq");
rt_hw_interrupt_umask(PIOE_INTERRUPT);
rt_hw_interrupt_install(PIOF_INTERRUPT, gpio_irq_handler, &_g_gpio_irq_tbl[GPIO_PORT_F], "gpiof_irq");
rt_hw_interrupt_umask(PIOF_INTERRUPT);
return 0;
}
INIT_DEVICE_EXPORT(rt_hw_gpio_init);