int stm32_gpio_set_pin_mode(int pin, gpio_pin_mode_t mode)
{
GPIO_InitTypeDef GPIO_InitStructure;
STM32_GPIO_PERIPH_ENABLE(GPIO_PERIPH(pin));
GPIO_InitStructure.GPIO_Pin = GPIO_BIT(pin);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
/* XXX: not all pins are actually available */
switch (mode)
{
case GPIO_PM_INPUT:
STM32_GPIO_PIN_TYPE_IN(GPIO_InitStructure);
GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);
break;
case GPIO_PM_OUTPUT:
STM32_GPIO_PIN_TYPE_OUT(GPIO_InitStructure);
GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);
break;
case GPIO_PM_INPUT_PULLUP:
STM32_GPIO_PIN_TYPE_IN_PU(GPIO_InitStructure);
GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);
break;
case GPIO_PM_INPUT_PULLDOWN:
STM32_GPIO_PIN_TYPE_IN_PD(GPIO_InitStructure);
GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);
break;
default:
tp_err("Pinmode %d is not supported yet\n", mode);
return -1;
}
return 0;
}
void stm32_gpio_enable_pin(GPIO_DRV* gpio, PIN pin, STM32_GPIO_MODE mode, bool pullup)
{
if (gpio->used_pins[GPIO_PORT(pin)]++ == 0)
GPIO_POWER_PORT |= 1 << GPIO_POWER_PINS[GPIO_PORT(pin)];
GPIO_CR_SET(pin, mode);
GPIO_ODR_SET(pin, pullup);
}
void gpio_set_pin(PIN pin, bool set)
{
if (set)
GPIO[GPIO_PORT(pin)]->BSRR = 1 << GPIO_PIN(pin);
else
GPIO[GPIO_PORT(pin)]->BRR = 1 << GPIO_PIN(pin);
}
void stm32_gpio_digital_write(int pin, int value)
{
if (value)
GPIO_SetBits(GPIO_PORT(pin), GPIO_BIT(pin));
else
GPIO_ResetBits(GPIO_PORT(pin), GPIO_BIT(pin));
}
void gpio_enable_pin(unsigned int pin, GPIO_MODE mode)
{
unsigned int param = 0;
#ifdef LPC11Uxx
if (GPIO_PORT(pin) == 0)
{
if ((1 << pin) & GPIO_I2C_MASK)
param = IOCON_PIO_I2CMODE_GPIO;
else if ((1 << pin) & GPIO_AD_MASK)
param = IOCON_PIO_ADMODE;
if ((1 << pin) & GPIO_MODE1_MASK)
param |= (1 << 0);
}
switch (mode)
{
case GPIO_MODE_IN_PULLUP:
param |= IOCON_PIO_MODE_PULL_UP | IOCON_PIO_HYS;
break;
case GPIO_MODE_IN_PULLDOWN:
param |= IOCON_PIO_MODE_PULL_DOWN | IOCON_PIO_HYS;
break;
case GPIO_MODE_IN_FLOAT:
param |= IOCON_PIO_HYS;
break;
default:
break;
}
#else //LPC18xx
if (GPIO_PORT(pin) >= 5)
param = (4 << 0);
switch (mode)
{
case GPIO_MODE_IN_PULLUP:
param |= SCU_SFS_EZI | SCU_SFS_ZIF;
break;
case GPIO_MODE_IN_PULLDOWN:
param |= SCU_SFS_EPUN | SCU_SFS_EPD | SCU_SFS_EZI | SCU_SFS_ZIF;
break;
case GPIO_MODE_IN_FLOAT:
param |= SCU_SFS_EPUN | SCU_SFS_EZI | SCU_SFS_ZIF;
break;
default:
break;
}
#endif //LPC11Uxx
pin_enable(PIN_RAW(pin), param, 0);
if (mode == GPIO_MODE_OUT)
LPC_GPIO->DIR[GPIO_PORT(pin)] |= 1 << GPIO_PIN(pin);
else
LPC_GPIO->DIR[GPIO_PORT(pin)] &= ~(1 << GPIO_PIN(pin));
}
void stm32_gpio_enable_pin(GPIO_DRV* gpio, PIN pin, unsigned int mode, AF af)
{
#if defined(STM32L0)
if (GPIO_PORT(pin) >= GPIO_COUNT || (gpio->used_pins[GPIO_PORT(pin)]++ == 0))
RCC->IOPENR |= 1 << GPIO_PORT(pin);
#else
if (gpio->used_pins[GPIO_PORT(pin)]++ == 0)
GPIO_POWER_PORT |= 1 << GPIO_POWER_PINS[GPIO_PORT(pin)];
#endif
GPIO_SET_MODE(pin, (mode >> 0) & 3);
GPIO_SET_OT(pin, (mode >> 2) & 1);
GPIO_SET_SPEED(pin, (mode >> 3) & 3);
GPIO_SET_PUPD(pin, (mode >> 5) & 3);
GPIO_AFR_SET(pin, af);
}
int
hal_gpio_init_out(int pin, int val)
{
gpio_pin_config_t gconfig;
port_pin_config_t pconfig;
gconfig.pinDirection = kGPIO_DigitalOutput;
pconfig.mux = kPORT_MuxAsGpio;
CLOCK_EnableClock(s_portClocks[GPIO_PORT(pin)]);
PORT_SetPinConfig(s_portBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &pconfig);
GPIO_PinInit(s_gpioBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &gconfig);
return 0;
}
/* The following functions don't check the gpio value, for speed */
u32 __gpio_get(int gpio)
{
int port = GPIO_PORT(gpio);
int bit = GPIO_BIT(gpio);
return readl(__GPIO_DAT(port)) & (1 << bit);
}
void __gpio_set(int gpio, u32 value)
{
int port = GPIO_PORT(gpio);
int bit = GPIO_BIT(gpio);
writel(value, __GPIO_BASE(port) + (0x4 << bit));
}
void pinRemap(uint8_t pin, uint8_t GPIO_AF)
{
GPIO_TypeDef * GPIOx = GPIO_PORT(pin);
uint8_t pin2 = (pin & 0x7) * 4;
pin = (pin & 0x0F) >> 3;
GPIOx->AFR[pin] = (GPIOx->AFR[pin] & ~((uint32_t)0xF << pin2)) | ((uint32_t)GPIO_AF << pin2);
}
EFI_STATUS
Get (
IN EMBEDDED_GPIO *This,
IN EMBEDDED_GPIO_PIN Gpio,
OUT UINTN *Value
)
{
UINTN Port;
UINTN Pin;
UINT32 DataInRegister;
if (Value == NULL)
{
return EFI_UNSUPPORTED;
}
Port = GPIO_PORT(Gpio);
Pin = GPIO_PIN(Gpio);
DataInRegister = GpioBase(Port) + GPIO_DATAIN;
if (MmioRead32 (DataInRegister) & GPIO_DATAIN_MASK(Pin)) {
*Value = 1;
} else {
*Value = 0;
}
return EFI_SUCCESS;
}
int
hal_gpio_toggle(int pin)
{
GPIO_TogglePinsOutput(s_gpioBases[GPIO_PORT(pin)], 1 << GPIO_INDEX(pin));
return 0;
}
int
hal_gpio_init_in(int pin, hal_gpio_pull_t pull)
{
gpio_pin_config_t gconfig;
port_pin_config_t pconfig;
gconfig.pinDirection = kGPIO_DigitalInput;
pconfig.pullSelect = hal_to_fsl_pull(pull);
pconfig.mux = kPORT_MuxAsGpio;
CLOCK_EnableClock(s_portClocks[GPIO_PORT(pin)]);
PORT_SetPinConfig(s_portBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &pconfig);
GPIO_PinInit(s_gpioBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &gconfig);
return 0;
}
int gpio_get_value(unsigned gpio)
{
unsigned l = readl(GPIO_FULLPORT(gpio));
if (GPIO_PORT(gpio) == 0) /* PORT A */
return (l >> GPIO_BIT(gpio)) & 0x1;
return (l >> GPIO_BIT(gpio)) & 0x3;
}
void pinToggle(u8 pin)
{
GPIO_TypeDef * GPIOx = GPIO_PORT(pin);
uint16_t mask = (1 << (pin & 0xF));
if (GPIOx->ODR & mask)
GPIOx->BSRRH = mask;
else
GPIOx->BSRRL = mask;
}
void gpio_enable_pin(PIN pin, unsigned int mode, AF af)
{
RCC->IOPENR |= 1 << GPIO_PORT(pin);
GPIO_SET_MODE(pin, (mode >> 0) & 3);
GPIO_SET_OT(pin, (mode >> 2) & 1);
GPIO_SET_SPEED(pin, (mode >> 3) & 3);
GPIO_SET_PUPD(pin, (mode >> 5) & 3);
GPIO_AFR_SET(pin, af);
}
void stm32_gpio_enable_exti(GPIO_DRV* gpio, PIN pin, unsigned int flags)
{
#if defined(STM32F1)
AFIO->EXTICR[GPIO_PIN(pin) / 4] &= ~(0xful << (uint32_t)(GPIO_PIN(pin) & 3ul));
AFIO->EXTICR[GPIO_PIN(pin) / 4] |= ((uint32_t)GPIO_PORT(pin) << (uint32_t)(GPIO_PIN(pin) & 3ul));
#else
SYSCFG->EXTICR[GPIO_PIN(pin) / 4] &= ~(0xful << (uint32_t)(GPIO_PIN(pin) & 3ul));
SYSCFG->EXTICR[GPIO_PIN(pin) / 4] |= ((uint32_t)GPIO_PORT(pin) << (uint32_t)(GPIO_PIN(pin) & 3ul));
#endif
EXTI->RTSR &= ~(1ul << GPIO_PIN(pin));
EXTI->FTSR &= ~(1ul << GPIO_PIN(pin));
if (flags & EXTI_FLAGS_RISING)
EXTI->RTSR |= 1ul << GPIO_PIN(pin);
if (flags & EXTI_FLAGS_FALLING)
EXTI->FTSR |= 1ul << GPIO_PIN(pin);
EXTI->IMR |= 1ul << GPIO_PIN(pin);
EXTI->EMR |= 1ul << GPIO_PIN(pin);
}
/**
* gpio read
*
* Reads the specified pin.
*
* @param pin Pin number to read
*
* @return int 0: low, 1: high
*/
int gpio_read(int pin)
{
int port;
uint32_t mcu_pin_mask;
port = GPIO_PORT(pin);
mcu_pin_mask = GPIO_MASK(pin);
return HAL_GPIO_ReadPin(portmap[port], mcu_pin_mask);
}
/**
* gpio clear
*
* Sets specified pin to 0 (low).
*
* @param pin
*/
void gpio_clear(int pin)
{
int port;
uint32_t mcu_pin_mask;
port = GPIO_PORT(pin);
mcu_pin_mask = GPIO_MASK(pin);
HAL_GPIO_WritePin(portmap[port], mcu_pin_mask, GPIO_PIN_RESET);
}
/**
* gpio read
*
* Reads the specified pin.
*
* @param pin Pin number to read
*
* @return int 0: low, 1: high
*/
int
gpio_read(int pin)
{
int port;
uint32_t mcu_pin_mask;
port = GPIO_PORT(pin);
mcu_pin_mask = GPIO_MASK(pin);
return GPIO_ReadInputDataBit(portmap[port], mcu_pin_mask);
}
/**
* gpio write
*
* Write a value (either high or low) to the specified pin.
*
* @param pin Pin to set
* @param val Value to set pin (0:low 1:high)
*/
void
gpio_write(int pin, int val)
{
int port;
uint32_t mcu_pin_mask;
port = GPIO_PORT(pin);
mcu_pin_mask = GPIO_MASK(pin);
GPIO_WriteBit(portmap[port], mcu_pin_mask, val);
}
void ldr_init(void)
{
//set AD4 to output and low
IOCON_SETRPIN(ADC_PORT, ADC_4, IOCON_R_PIO | IOCON_NOPULL | IOCON_DIGITAL);
GPIO_CLRPIN(ADC_PORT, ADC_4);
GPIO_PORT(ADC_PORT)->DIR |= (1<<ADC_4);
//set AD5 to analog
IOCON_SETPIN(ADC_PORT, ADC_5, IOCON_ADC | IOCON_NOPULL | IOCON_ANALOG);
return;
}
int gpio_get(int gpio)
{
int port = GPIO_PORT(gpio);
int bit = GPIO_BIT(gpio);
if (port < 0 || port > 3)
return -1;
if (bit < 0 || bit > 11)
return -1;
volatile u32 *reg;
reg = (volatile u32 *)(GPIO_BASE + PORT_BASE*port + GPIO_DATA);
return ((*reg & (1<<bit)) ? 1 : 0);
}
void stm32_gpio_disable_pin(GPIO_DRV* gpio, PIN pin)
{
#if defined(STM32F1)
GPIO_CR_SET(pin, GPIO_MODE_IN_FLOAT);
#else
GPIO_SET_MODE(pin, STM32_GPIO_MODE_INPUT >> 0);
#if defined(STM32L0)
GPIO_SET_SPEED(pin, GPIO_SPEED_VERY_LOW >> 3);
#else
GPIO_SET_SPEED(pin, GPIO_SPEED_LOW >> 3);
#endif
GPIO_SET_PUPD(pin, GPIO_PUPD_NO_PULLUP >> 5);
GPIO_AFR_SET(pin, AF0);
#endif
#if defined(STM32L0)
if (GPIO_PORT(pin) >= GPIO_COUNT || (--gpio->used_pins[GPIO_PORT(pin)] == 0))
RCC->IOPENR &= ~(1 << GPIO_PORT(pin));
#else
if (--gpio->used_pins[GPIO_PORT(pin)] == 0)
GPIO_POWER_PORT &= ~(1 << GPIO_POWER_PINS[GPIO_PORT(pin)]);
#endif
}
void gpio_set(int gpio, int value)
{
int port = GPIO_PORT(gpio);
int bit = GPIO_BIT(gpio);
volatile u32 *reg;
if (port < 0 || port > 3)
return;
if (bit < 0 || bit > 11)
return;
reg = (volatile u32 *)(GPIO_BASE + PORT_BASE*port + GPIO_DATA);
if (value)
*reg &= ~(1 << bit);
else
*reg |= (1 << bit);
}
void pinMode(u8 pin, PinMode_Type mode)
{
GPIO_TypeDef * GPIOx = GPIO_PORT(pin);
u8 pin2 = (pin & 0x0F) * 2;
u32 mask = ~(0x03 << pin2);
pin &= 0x0F;
GPIOx->MODER = (GPIOx->MODER & mask) | ((mode & 0x3) << pin2);
mode >>= 2;
GPIOx->PUPDR = (GPIOx->PUPDR & mask) | ((mode & 0x3) << pin2);
mode >>= 2;
GPIOx->OSPEEDR = (GPIOx->OSPEEDR & mask) | ((mode & 0x3) << pin2);
mode >>= 2;
GPIOx->OTYPER = (GPIOx->OTYPER & ~(1 << pin)) | ((mode & 0x1) << pin);
}
void _stm32_gpio_set_pin_function(int pin, int od, stm32_gpio_af_t af)
{
GPIO_InitTypeDef GPIO_InitStructure;
if (af)
STM32_GPIO_AF_CONFIG(pin, af);
GPIO_InitStructure.GPIO_Pin = GPIO_BIT(pin);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
if (od)
STM32_GPIO_PIN_TYPE_AF_OD(GPIO_InitStructure);
else
STM32_GPIO_PIN_TYPE_AF(GPIO_InitStructure);
GPIO_Init(GPIO_PORT(pin), &GPIO_InitStructure);
}
void gpio_dir(int gpio, int dir)
{
int port = GPIO_PORT(gpio);
int bit = GPIO_BIT(gpio);
if (port < 0 || port > 3)
return;
if (bit < 0 || bit > 11)
return;
volatile u32 *reg;
reg = (volatile u32 *)(GPIO_BASE + PORT_BASE*port + GPIO_DIR);
if (dir)
*reg |= (1 << bit);
else
*reg &= ~(1 << bit);
}
void pinMode(uint8_t pin, PinMode_Type mode)
{
__IO uint32_t * crx;
uint32_t mask;
uint8_t pin2;
GPIO_TypeDef * port = GPIO_PORT(pin);
crx = (pin & 0x08) ? &(port->CRH) : &(port->CRL);
pin2 = (pin & 0x07) << 2;
mask = ~(0x0F << pin2);
*crx = (*crx & mask) | ((mode & 0x0F) << pin2);
if (mode == GPIO_Mode_IPD)
port->BRR = (1 << pin);
else if (mode == GPIO_Mode_IPU)
port->BSRR = (1 << pin);
}
/*
@func int32 | _rtl865x_getGpioDataBit | Get the bit value of a specified GPIO ID.
@parm uint32 | gpioId | GPIO ID
@parm uint32* | data | Pointer to store return value
@rvalue SUCCESS | success.
@rvalue FAILED | failed. Parameter error.
@comm
*/
int32 _rtl865x_getGpioDataBit( uint32 gpioId, uint32* pData )
{
uint32 port = GPIO_PORT( gpioId );
uint32 pin = GPIO_PIN( gpioId );
if ( port >= GPIO_PORT_MAX ) return FAILED;
if ( pin >= 8 ) return FAILED;
if ( pData == NULL ) return FAILED;
*pData = _getGpio( GPIO_FUNC_DATA, port, pin );
#if _GPIO_DEBUG_ >= 3
rtlglue_printf("[%s():%d] (port=%d,pin=%d)=%d\n", __FUNCTION__, __LINE__, port, pin, *pData );
#endif
return SUCCESS;
}
