libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/nxp/lpc/lpc55sxx/Libraries/drivers/drv_pin.c

433 lines
13 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2018-03-13 Liuguang the first version.
* 2018-03-19 Liuguang add GPIO interrupt mode support.
* 2018-11-30 yangjie The first version for LPC54114
* 2019-07-20 Magicoe The first version for LPC55S6x
*/
#include "drv_pin.h"
#include "fsl_common.h"
#include "fsl_iocon.h"
#include "fsl_gpio.h"
#include "fsl_gint.h"
#include "fsl_pint.h"
#include "fsl_inputmux.h"
#ifdef RT_USING_PIN
#if defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL
#error "Please don't define 'FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL'!"
#endif
#define get_port(x) ((x-1) / 32)
#define get_pin(x) ((x-1) % 32)
#define PIN_MAX_VAL 64
#define IRQ_MAX_VAL 8
struct lpc_pin
{
rt_uint16_t pin;
GPIO_Type *gpio;
rt_uint8_t gpio_port;
rt_uint32_t gpio_pin;
};
#define __ARRAY_LEN(array) (sizeof(array)/sizeof(array[0]))
#define __LPC55S69_PIN_DEFAULT {0, 0, 0, 0}
#define __LPC55S69_PIN(INDEX, REG, PORT, PIN) {INDEX, REG, PORT, PIN}
static struct rt_pin_ops lpc_pin_ops;
static struct lpc_pin lpc_pin_map[] =
{
__LPC55S69_PIN_DEFAULT,
/* PIO0 / GPIO0 */
__LPC55S69_PIN( 1, GPIO, 0, 0), /* PIO0_00 */
__LPC55S69_PIN( 2, GPIO, 0, 1), /* PIO0_01 */
__LPC55S69_PIN( 3, GPIO, 0, 2), /* PIO0_02 */
__LPC55S69_PIN( 4, GPIO, 0, 3), /* PIO0_04 */
__LPC55S69_PIN( 5, GPIO, 0, 4), /* PIO0_04 */
__LPC55S69_PIN( 6, GPIO, 0, 5), /* PIO0_05 */
__LPC55S69_PIN( 7, GPIO, 0, 6), /* PIO0_06 */
__LPC55S69_PIN( 8, GPIO, 0, 7), /* PIO0_07 */
__LPC55S69_PIN( 9, GPIO, 0, 8), /* PIO0_08 */
__LPC55S69_PIN(10, GPIO, 0, 9), /* PIO0_09 */
__LPC55S69_PIN(11, GPIO, 0, 10), /* PIO0_10 */
__LPC55S69_PIN(12, GPIO, 0, 11), /* PIO0_11 */
__LPC55S69_PIN(13, GPIO, 0, 12), /* PIO0_12 */
__LPC55S69_PIN(14, GPIO, 0, 13), /* PIO0_13 */
__LPC55S69_PIN(15, GPIO, 0, 14), /* PIO0_14 */
__LPC55S69_PIN(16, GPIO, 0, 15), /* PIO0_15 */
__LPC55S69_PIN(17, GPIO, 0, 16), /* PIO0_16 */
__LPC55S69_PIN(18, GPIO, 0, 17), /* PIO0_17 */
__LPC55S69_PIN(19, GPIO, 0, 18), /* PIO0_18 */
__LPC55S69_PIN(20, GPIO, 0, 19), /* PIO0_19 */
__LPC55S69_PIN(21, GPIO, 0, 20), /* PIO0_20 */
__LPC55S69_PIN(22, GPIO, 0, 21), /* PIO0_21 */
__LPC55S69_PIN(23, GPIO, 0, 22), /* PIO0_22 */
__LPC55S69_PIN(24, GPIO, 0, 23), /* PIO0_23 */
__LPC55S69_PIN(25, GPIO, 0, 24), /* PIO0_24 */
__LPC55S69_PIN(26, GPIO, 0, 25), /* PIO0_25 */
__LPC55S69_PIN(27, GPIO, 0, 26), /* PIO0_26 */
__LPC55S69_PIN(28, GPIO, 0, 27), /* PIO0_27 */
__LPC55S69_PIN(29, GPIO, 0, 28), /* PIO0_28 */
__LPC55S69_PIN(30, GPIO, 0, 29), /* PIO0_29 */
__LPC55S69_PIN(31, GPIO, 0, 30), /* PIO0_30 */
__LPC55S69_PIN(32, GPIO, 0, 31), /* PIO0_31 */
/* PIO1 / GPIO, 1 */
__LPC55S69_PIN(33, GPIO, 1, 0), /* PIO1_00 */
__LPC55S69_PIN(34, GPIO, 1, 1), /* PIO1_01 */
__LPC55S69_PIN(35, GPIO, 1, 2), /* PIO1_02 */
__LPC55S69_PIN(36, GPIO, 1, 3), /* PIO1_03 */
__LPC55S69_PIN(37, GPIO, 1, 4), /* PIO1_04 */
__LPC55S69_PIN(38, GPIO, 1, 5), /* PIO1_05 */
__LPC55S69_PIN(39, GPIO, 1, 6), /* PIO1_06 */
__LPC55S69_PIN(40, GPIO, 1, 7), /* PIO1_07 */
__LPC55S69_PIN(41, GPIO, 1, 8), /* PIO1_08 */
__LPC55S69_PIN(42, GPIO, 1, 9), /* PIO1_09 */
__LPC55S69_PIN(43, GPIO, 1, 10), /* PIO1_10 */
__LPC55S69_PIN(44, GPIO, 1, 11), /* PIO1_11 */
__LPC55S69_PIN(45, GPIO, 1, 12), /* PIO1_12 */
__LPC55S69_PIN(46, GPIO, 1, 13), /* PIO1_13 */
__LPC55S69_PIN(47, GPIO, 1, 14), /* PIO1_14 */
__LPC55S69_PIN(48, GPIO, 1, 15), /* PIO1_15 */
__LPC55S69_PIN(49, GPIO, 1, 16), /* PIO1_16 */
__LPC55S69_PIN(50, GPIO, 1, 17), /* PIO1_17 */
__LPC55S69_PIN(51, GPIO, 1, 18), /* PIO1_18 */
__LPC55S69_PIN(52, GPIO, 1, 19), /* PIO1_19 */
__LPC55S69_PIN(53, GPIO, 1, 20), /* PIO1_20 */
__LPC55S69_PIN(54, GPIO, 1, 21), /* PIO1_21 */
__LPC55S69_PIN(55, GPIO, 1, 22), /* PIO1_22 */
__LPC55S69_PIN(56, GPIO, 1, 23), /* PIO1_23 */
__LPC55S69_PIN(57, GPIO, 1, 24), /* PIO1_24 */
__LPC55S69_PIN(58, GPIO, 1, 25), /* PIO1_25 */
__LPC55S69_PIN(59, GPIO, 1, 26), /* PIO1_26 */
__LPC55S69_PIN(60, GPIO, 1, 27), /* PIO1_27 */
__LPC55S69_PIN(61, GPIO, 1, 28), /* PIO1_28 */
__LPC55S69_PIN(62, GPIO, 1, 29), /* PIO1_29 */
__LPC55S69_PIN(63, GPIO, 1, 30), /* PIO1_30 */
__LPC55S69_PIN(64, GPIO, 1, 31), /* PIO1_31 */
};
struct rt_pin_irq_hdr pin_irq_hdr_tab[] =
{
{-1, 0, RT_NULL, RT_NULL},
{-1, 0, RT_NULL, RT_NULL},
{-1, 0, RT_NULL, RT_NULL},
{-1, 0, RT_NULL, RT_NULL},
{-1, 0, RT_NULL, RT_NULL},
{-1, 0, RT_NULL, RT_NULL},
{-1, 0, RT_NULL, RT_NULL},
{-1, 0, RT_NULL, RT_NULL},
};
static void lpc_pin_mode(rt_device_t dev, rt_base_t pin, rt_uint8_t mode)
{
int dir;
uint32_t pin_cfg;
if ((pin > __ARRAY_LEN(lpc_pin_map)) || (pin == 0))
{
return;
}
switch (mode)
{
case PIN_MODE_OUTPUT:
{
dir = kGPIO_DigitalOutput;
pin_cfg = IOCON_FUNC0 | IOCON_DIGITAL_EN | IOCON_MODE_PULLUP;
}
break;
case PIN_MODE_INPUT:
{
dir = kGPIO_DigitalInput;
pin_cfg = IOCON_FUNC0 | IOCON_INPFILT_OFF | IOCON_DIGITAL_EN;
}
break;
case PIN_MODE_INPUT_PULLDOWN:
{
dir = kGPIO_DigitalInput;
pin_cfg = IOCON_FUNC0 | IOCON_INPFILT_OFF | IOCON_DIGITAL_EN | IOCON_MODE_PULLDOWN;
}
break;
case PIN_MODE_INPUT_PULLUP:
{
dir = kGPIO_DigitalInput;
pin_cfg = IOCON_FUNC0 | IOCON_INPFILT_OFF | IOCON_DIGITAL_EN | IOCON_MODE_PULLUP;
}
break;
case PIN_MODE_OUTPUT_OD:
{
dir = kGPIO_DigitalOutput;
pin_cfg = IOCON_FUNC0 | IOCON_OPENDRAIN_EN | IOCON_DIGITAL_EN;
}
break;
}
/* Enable IOCON Clock */
CLOCK_EnableClock(kCLOCK_Iocon);
IOCON->PIO[lpc_pin_map[pin].gpio_port][lpc_pin_map[pin].gpio_pin] = pin_cfg;
/* Disable IOCON Clock -- To Save Power */
CLOCK_DisableClock(kCLOCK_Iocon);
gpio_pin_config_t pin_config = {(gpio_pin_direction_t)dir, 1};
GPIO_PinInit(GPIO, lpc_pin_map[pin].gpio_port, lpc_pin_map[pin].gpio_pin, &pin_config);
}
static void lpc_pin_write(rt_device_t dev, rt_base_t pin, rt_uint8_t value)
{
if ((pin > __ARRAY_LEN(lpc_pin_map)) || (pin == 0))
{
return;
}
GPIO_PinWrite(lpc_pin_map[pin].gpio, lpc_pin_map[pin].gpio_port, lpc_pin_map[pin].gpio_pin, value);
}
static rt_ssize_t lpc_pin_read(rt_device_t dev, rt_base_t pin)
{
rt_ssize_t value;
if ((pin > __ARRAY_LEN(lpc_pin_map)) || (pin == 0))
{
return -RT_ERROR;
}
value = GPIO_PinRead(lpc_pin_map[pin].gpio, lpc_pin_map[pin].gpio_port, lpc_pin_map[pin].gpio_pin);
return value;
}
static void pin_irq_hdr(pint_pin_int_t pintr, uint32_t pmatch_status)
{
int irqno = 0;
for(irqno = 0; irqno < IRQ_MAX_VAL; irqno ++)
{
if((irqno) == pintr)
{
break;
}
}
if(irqno >= IRQ_MAX_VAL)
return;
if (pin_irq_hdr_tab[irqno].hdr)
{
pin_irq_hdr_tab[irqno].hdr(pin_irq_hdr_tab[irqno].args);
}
}
void callback(pint_pin_int_t pintr, uint32_t pmatch_status)
{
pin_irq_hdr(pintr, pmatch_status);
}
/* IRQ handler functions overloading weak symbols in the startup */
void PIN_INT0_IRQHandler(void)
{
uint32_t pmstatus;
/* Reset pattern match detection */
pmstatus = PINT_PatternMatchResetDetectLogic(PINT);
pin_irq_hdr(kPINT_PinInt0, pmstatus);
if ((PINT->ISEL & 0x1U) == 0x0U)
{
/* Edge sensitive: clear Pin interrupt after callback */
PINT_PinInterruptClrStatus(PINT, kPINT_PinInt0);
}
}
static rt_err_t lpc_pin_attach_irq(struct rt_device *device,
rt_base_t pin,
rt_uint8_t mode,
void (*hdr)(void *args),
void *args)
{
int trigger_mode, pin_initx, pintsel, pin_cfg, i;
if ((pin > __ARRAY_LEN(lpc_pin_map)) || (pin == 0))
{
return -RT_ERROR;
}
switch (mode)
{
case PIN_IRQ_MODE_RISING:
trigger_mode = kPINT_PinIntEnableRiseEdge;
break;
case PIN_IRQ_MODE_FALLING:
trigger_mode = kPINT_PinIntEnableFallEdge;
break;
case PIN_IRQ_MODE_RISING_FALLING:
trigger_mode = kPINT_PinIntEnableBothEdges;
break;
case PIN_IRQ_MODE_HIGH_LEVEL:
trigger_mode = kPINT_PinIntEnableHighLevel;
break;
case PIN_IRQ_MODE_LOW_LEVEL:
trigger_mode = kPINT_PinIntEnableLowLevel;
break;
}
/* Get inputmux_connection_t */
pintsel = (pin - 1 + (0xC0U << 20));
for(i = 0; i < IRQ_MAX_VAL; i++)
{
if(pin_irq_hdr_tab[i].pin == -1)
{
pin_initx = kPINT_PinInt0 + i;
pin_irq_hdr_tab[i].pin = pin;
pin_irq_hdr_tab[i].mode = trigger_mode;
pin_irq_hdr_tab[i].hdr = hdr;
pin_irq_hdr_tab[i].args = args;
break;
}
}
if(i >= IRQ_MAX_VAL)
return -RT_ERROR;
/* Initialize PINT */
PINT_Init(PINT);
/* Enable Input and IOCon clk */
/* AttachSignal */
/* Connect trigger sources to PINT */
INPUTMUX_Init(INPUTMUX);
INPUTMUX_AttachSignal(INPUTMUX, i, (inputmux_connection_t)pintsel);
/* Turnoff clock to inputmux to save power. Clock is only needed to make changes */
INPUTMUX_Deinit(INPUTMUX);
pin_cfg = ((IOCON->PIO[lpc_pin_map[pin].gpio_port][lpc_pin_map[pin].gpio_pin] &
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK | IOCON_PIO_FILTEROFF_MASK))) /* Mask bits to zero which are setting */
| IOCON_PIO_FUNC(0) /* Selects pin function.: PORT18 (pin 28) is configured as PIO1_8 */
| IOCON_PIO_DIGIMODE(1) /* Select Analog/Digital mode.: Digital mode. */
| IOCON_PIO_FILTEROFF(0)); /* Controls input glitch filter.: Filter enabled. Noise pulses below approximately 10 ns are filtered out. */
IOCON_PinMuxSet(IOCON, lpc_pin_map[pin].gpio_port, lpc_pin_map[pin].gpio_pin, pin_cfg);
/* PINT_PinInterruptConfig */
PINT_PinInterruptConfig(PINT, (pint_pin_int_t)pin_initx, (pint_pin_enable_t)(pin_irq_hdr_tab[i].mode), callback);
/* Enable callbacks for PINTx by Index */
PINT_EnableCallbackByIndex(PINT, (pint_pin_int_t)pin_initx);
return RT_EOK;
}
static rt_err_t lpc_pin_detach_irq(struct rt_device *device, rt_base_t pin)
{
int i;
if ((pin > __ARRAY_LEN(lpc_pin_map)) || (pin == 0))
{
return -RT_ERROR;
}
for(i = 0; i < IRQ_MAX_VAL; i++)
{
if(pin_irq_hdr_tab[i].pin == pin)
{
pin_irq_hdr_tab[i].pin = -1;
pin_irq_hdr_tab[i].hdr = RT_NULL;
pin_irq_hdr_tab[i].mode = 0;
pin_irq_hdr_tab[i].args = RT_NULL;
break;
}
}
return RT_EOK;
}
static rt_err_t lpc_pin_irq_enable(struct rt_device *device, rt_base_t pin, rt_uint8_t enabled)
{
int irqn_type, i;
if ((pin > __ARRAY_LEN(lpc_pin_map)) || (pin == 0))
{
return -RT_ERROR;
}
for(i = 0; i < IRQ_MAX_VAL; i++)
{
if(pin_irq_hdr_tab[i].pin == pin)
{
switch(i)
{
case 0: irqn_type = PIN_INT0_IRQn; break;
case 1: irqn_type = PIN_INT1_IRQn; break;
case 2: irqn_type = PIN_INT2_IRQn; break;
case 3: irqn_type = PIN_INT3_IRQn; break;
case 4: irqn_type = PIN_INT4_IRQn; break;
case 5: irqn_type = PIN_INT5_IRQn; break;
case 6: irqn_type = PIN_INT6_IRQn; break;
case 7: irqn_type = PIN_INT7_IRQn; break;
default:break;
}
if(enabled)
{
/* PINT_EnableCallback */
PINT_PinInterruptClrStatusAll(PINT);
NVIC_ClearPendingIRQ((IRQn_Type)irqn_type);
PINT_PinInterruptClrStatus(PINT, (pint_pin_int_t)(kPINT_PinInt0 + i));
EnableIRQ((IRQn_Type)irqn_type);
}
else
{
/* PINT_DisableCallback */
DisableIRQ((IRQn_Type)irqn_type);
PINT_PinInterruptClrStatus(PINT, (pint_pin_int_t)(kPINT_PinInt0 + i));
NVIC_ClearPendingIRQ((IRQn_Type)irqn_type);
}
break;
}
}
if(i >= IRQ_MAX_VAL)
return -RT_ERROR;
return RT_EOK;
}
int rt_hw_pin_init(void)
{
int ret = RT_EOK;
lpc_pin_ops.pin_mode = lpc_pin_mode;
lpc_pin_ops.pin_read = lpc_pin_read;
lpc_pin_ops.pin_write = lpc_pin_write;
lpc_pin_ops.pin_attach_irq = lpc_pin_attach_irq;
lpc_pin_ops.pin_detach_irq = lpc_pin_detach_irq;
lpc_pin_ops.pin_irq_enable = lpc_pin_irq_enable;
lpc_pin_ops.pin_get = RT_NULL,
ret = rt_device_pin_register("pin", &lpc_pin_ops, RT_NULL);
return ret;
}
INIT_BOARD_EXPORT(rt_hw_pin_init);
#endif /*RT_USING_PIN */
// end file
View Git Blame Copy Permalink