void gpio_ir_recv_handler(uint32_t id, uint32_t event) {
uint32_t current_timestamp;
IRSendRev *pIR;
pIR = (IRSendRev *)id;
gpio_irq_disable((gpio_irq_t *)(pIR->pGpioIrqRecv));
current_timestamp = micros();
switch(pIR->rcvstate) {
case STATE_IDLE:
if ((pIR->recv_wait_int) == IRQ_LOW) {
pIR->rcvstate = STATE_MARK;
pIR->prev_timestamp = current_timestamp;
}
break;
case STATE_MARK:
if ((pIR->recv_wait_int) == IRQ_HIGH) {
// mark transition to space
pIR->recv_buf[(pIR->recv_len)++] = current_timestamp - (pIR->prev_timestamp);
pIR->prev_timestamp = current_timestamp;
pIR->rcvstate = STATE_SPACE;
gtimer_reload((gtimer_t *)(pIR->pTimerRecv), GAP);
gtimer_start((gtimer_t *)(pIR->pTimerRecv));
}
break;
case STATE_SPACE:
if ((pIR->recv_wait_int) == IRQ_LOW) {
// space transition to mark
gtimer_stop((gtimer_t *)(pIR->pTimerRecv));
pIR->recv_buf[(pIR->recv_len)++] = current_timestamp - (pIR->prev_timestamp);
pIR->prev_timestamp = current_timestamp;
pIR->rcvstate = STATE_MARK;
}
break;
case STATE_STOP:
break;
}
if ((pIR->recv_wait_int) == IRQ_LOW )
{
// Change to listen to high level event
(pIR->recv_wait_int) = IRQ_HIGH;
gpio_irq_set((gpio_irq_t *)(pIR->pGpioIrqRecv), (gpio_irq_event)IRQ_HIGH, 1);
gpio_irq_enable((gpio_irq_t *)(pIR->pGpioIrqRecv));
}
else if ((pIR->recv_wait_int) == IRQ_HIGH)
{
// Change to listen to low level event
(pIR->recv_wait_int) = IRQ_LOW;
gpio_irq_set((gpio_irq_t *)(pIR->pGpioIrqRecv), (gpio_irq_event)IRQ_LOW, 1);
gpio_irq_enable((gpio_irq_t *)(pIR->pGpioIrqRecv));
}
}
int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, uint32_t id) {
ASF_assert(pin != NC);
Chip_INMUX_PinIntSel(id, DECODE_PORT(pin), DECODE_PIN(pin));
gpio_irq_enable(obj);
return 0;
}
static void rk28_ts_resume(android_early_suspend_t *h)
{
#if 0
printk("XPT2046 driver resume!!\n");
gpio_irq_enable(PT2046_PENIRQ);
#endif
}
static void ak4183_resume(android_early_suspend_t *h)
{
D("enter!\n");
/* disable ak4183 irq */
gpio_irq_enable(GPIOPortE_Pin3);
}
int gpio_init_int(gpio_t pin, gpio_pp_t pullup, gpio_flank_t flank,
gpio_cb_t cb, void *arg)
{
msp_port_isr_t *port = _isr_port(pin);
/* check if port, pull resistor and flank configuration are valid */
if ((port == NULL) || (pullup != GPIO_NOPULL) || (flank == GPIO_BOTH)) {
return -1;
}
/* disable any activated interrupt */
port->IE &= ~(_pin(pin));
/* configure as input */
gpio_init(pin, GPIO_DIR_IN, GPIO_NOPULL);
/* save ISR context */
isr_ctx[_ctx(pin)].cb = cb;
isr_ctx[_ctx(pin)].arg = arg;
/* configure flank */
port->IES &= ~(_pin(pin));
port->IES |= (flank & _pin(pin));
/* clear pending interrupts and enable the IRQ */
port->IFG &= ~(_pin(pin));
gpio_irq_enable(pin);
return 0;
}
void DispatcherPrivate::set_receive_input(SYNCHRONIZATION_CHANNEL* channel, PinName pin, PinMode pull, ReceiveChannelMode rcmode)
{
if (channel->data->state->recv.mode != ReceiveChannelModeNone)
gpio_irq_free(&channel->data->state->recv.gpio_irq);
channel->data->state->recv.mode = rcmode;
gpio_init_in(&channel->data->state->recv.gpio, pin);
gpio_irq_init(&channel->data->state->recv.gpio_irq, pin, (&DispatcherPrivate::channel_irq_handler), (uint32_t)channel);
gpio_mode(&channel->data->state->recv.gpio, pull);
gpio_irq_event evt = IRQ_NONE;
switch (rcmode)
{
case ReceiveChannelInterruptRise:
evt = IRQ_RISE;
break;
case ReceiveChannelInterruptFall:
evt = IRQ_FALL;
break;
case ReceiveChannelModeNone:
break;
}
if (evt != IRQ_NONE)
{
gpio_irq_set(&channel->data->state->recv.gpio_irq, evt, 1);
gpio_irq_enable(&channel->data->state->recv.gpio_irq);
}
}
void config_loguart()
{
/* Log uart RX pin doesn't support gpio interrupt.
* To make log uart wake system, we can parallel log uart RX with another gpio interrupt pin.
*/
gpio_irq_t gpio_rx_wake;
gpio_irq_init(&gpio_rx_wake, LOGUART_RX_WAKE, gpio_loguart_rx_irq_callback, NULL);
gpio_irq_set(&gpio_rx_wake, IRQ_FALL, 1); // Falling Edge Trigger
gpio_irq_enable(&gpio_rx_wake);
}
static unsigned int
gpio_irq_startup(unsigned int irq)
{
gpio_irq_enable(irq);
irq -= gpio_irq_base;
*VR4181_GPINTEN |= (u16)(1 << irq );
return 0;
}
void uartadapter_gpio_init()
{
gpio_init(&gpio_led, UA_GPIO_IRQ_PIN);
gpio_dir(&gpio_led, PIN_INPUT); // Direction: Output
gpio_mode(&gpio_led, PullNone); // No pull
gpio_irq_init(&gpio_btn, UA_GPIO_IRQ_PIN, uartadapter_gpio_irq, (uint32_t)(&gpio_led));
gpio_irq_set(&gpio_btn, IRQ_FALL, 1); // Falling Edge Trigger
gpio_irq_enable(&gpio_btn);
}
static void uart_wakeup_thread(void *arg)
{
while(1){
if(mico_rtos_get_semaphore(&wakeup, 1000)!=MXCHIP_SUCCESS){
gpio_irq_enable(USARTx_RX_GPIO_PORT, USARTx_IRQ_PIN, IRQ_TRIGGER_FALLING_EDGE, Rx_irq_handler, 0);
#ifdef MCULowPowerMode
mico_mcu_powersave_config(mxEnable);
#endif
}
}
}
static void thread_wakeup(void *arg)
{
mico_uart_t uart = *(mico_uart_t *)arg;
while(1){
if(mico_rtos_get_semaphore(&uart_interfaces[ uart ].sem_wakeup, 1000) != kNoErr){
gpio_irq_enable(uart_mapping[uart].pin_rx->bank, uart_mapping[uart].pin_rx->number, IRQ_TRIGGER_FALLING_EDGE, RX_PIN_WAKEUP_handler, &uart);
MicoMcuPowerSaveConfig(true);
}
}
}
void Button_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
Button1_CLK_INIT(Button1_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = Button1_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(Button1_PORT, &GPIO_InitStructure);
gpio_irq_enable(Button1_PORT, Button1_IRQ_PIN, IRQ_TRIGGER_FALLING_EDGE, _Button_irq_handler, 0);
gpio_irq_enable(Button1_PORT, Button1_IRQ_PIN, IRQ_TRIGGER_FALLING_EDGE, _Button_irq_handler, 0);
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 8;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 8;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
void IRSendRev::Init(int revPin) {
gpio_irq_init((gpio_irq_t *)pGpioIrqRecv, (PinName)(g_APinDescription[revPin].pinname), (gpio_irq_handler)gpio_ir_recv_handler, (uint32_t)this);
gpio_irq_set((gpio_irq_t *)pGpioIrqRecv, (gpio_irq_event)IRQ_LOW, 1);
gpio_irq_enable((gpio_irq_t *)pGpioIrqRecv);
gtimer_init((gtimer_t *)pTimerRecv, TIMER4);
gtimer_start_one_shout((gtimer_t *)pTimerRecv, GAP, (void *)ir_recv_timer_handler, (uint32_t)this);
gtimer_stop((gtimer_t *)pTimerRecv);
Clear();
}
static void rk28_ps2_sent_start(void)
{
g_host_sent_flag = 1;
gpio_irq_disable(MOUSE_PS2_CLK_PIN);
gpio_direction_output(MOUSE_PS2_CLK_PIN,GPIO_LOW);
GPIOSetPinLevel(MOUSE_PS2_CLK_PIN,GPIO_LOW);
udelay(100);
gpio_direction_output(MOUSE_PS2_DATA_PIN,GPIO_LOW);
GPIOSetPinLevel(MOUSE_PS2_DATA_PIN,GPIO_LOW);
GPIOSetPinLevel(MOUSE_PS2_CLK_PIN,GPIO_HIGH);
gpio_direction_input(MOUSE_PS2_CLK_PIN);
gpio_irq_enable(MOUSE_PS2_CLK_PIN);
}
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))
{
dbg_log(DBG_ERROR, "pin:%d value wrongful\n", 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;
}
void config_uart()
{
// setup uart
serial_init(&mysobj, UART_TX, UART_RX);
serial_baud(&mysobj, 38400);
serial_format(&mysobj, 8, ParityNone, 1);
serial_irq_handler(&mysobj, uart_irq_callback, (uint32_t)&mysobj);
serial_irq_set(&mysobj, RxIrq, 1);
serial_irq_set(&mysobj, TxIrq, 1);
// config uart rx as gpio wakeup pin
gpio_irq_t gpio_rx_wake;
gpio_irq_init(&gpio_rx_wake, UART_RX, gpio_uart_rx_irq_callback, NULL);
gpio_irq_set(&gpio_rx_wake, IRQ_FALL, 1); // Falling Edge Trigger
gpio_irq_enable(&gpio_rx_wake);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
void main(void)
{
gpio_irq_t gpio_btn;
// Init LED control pin
gpio_init(&gpio_led, GPIO_LED_PIN);
gpio_dir(&gpio_led, PIN_OUTPUT); // Direction: Output
gpio_mode(&gpio_led, PullNone); // No pull
// Initial Push Button pin as interrupt source
gpio_irq_init(&gpio_btn, GPIO_IRQ_PIN, gpio_demo_irq_handler, (uint32_t)(&gpio_led));
gpio_irq_set(&gpio_btn, IRQ_FALL, 1); // Falling Edge Trigger
gpio_irq_enable(&gpio_btn);
led_ctrl = 1;
gpio_write(&gpio_led, led_ctrl);
while(1);
}
static void _isr(netdev2_t *netdev)
{
encx24j600_t *dev = (encx24j600_t *) netdev;
uint16_t eir;
lock(dev);
cmd(dev, CLREIE);
eir = reg_get(dev, EIR);
/* check & handle link state change */
if (eir & LINKIF) {
uint16_t estat = reg_get(dev, ESTAT);
netdev2_event_t event = (estat & PHYLNK) ?
NETDEV2_EVENT_LINK_DOWN :
NETDEV2_EVENT_LINK_UP;
netdev->event_callback(netdev, event, NULL);
}
/* check & handle available packets */
if (eir & PKTIF) {
while (_packets_available(dev)) {
unlock(dev);
netdev->event_callback(netdev, NETDEV2_EVENT_RX_COMPLETE,
NULL);
lock(dev);
}
}
/* drop all flags */
reg_clear_bits(dev, EIR, LINKIF);
/* re-enable interrupt */
gpio_irq_enable(dev->int_pin);
cmd(dev, SETEIE);
unlock(dev);
}
int _cc110x_set_state(netdev_t *dev, netdev_state_t state)
{
if (dev != &cc110x_dev) {
return -ENODEV;
}
switch (state) {
case NETDEV_STATE_POWER_OFF:
gpio_irq_disable(CC110X_GDO2);
cc110x_switch_to_pwd();
break;
case NETDEV_STATE_RX_MODE:
gpio_irq_enable(CC110X_GDO2);
cc110x_setup_rx_mode();
break;
default:
return -ENOTSUP;
}
return 0;
}
void Platform_Button_EL_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
Button_EL_CLK_INIT(Button_EL_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = Button_EL_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(Button_EL_PORT, &GPIO_InitStructure);
mico_init_timer(&_button_EL_timer, RestoreDefault_TimeOut, _button_EL_Timeout_handler, NULL);
gpio_irq_enable(Button_EL_PORT, Button_EL_IRQ_PIN, IRQ_TRIGGER_BOTH_EDGES, _button_EL_irq_handler, 0);
NVIC_InitStructure.NVIC_IRQChannel = Button_EL_IRQ;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 5;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 8;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
void main(void)
{
gpio_t gpio_led;
gpio_irq_t gpio_btn;
// Init LED control pin
gpio_init(&gpio_led, GPIO_LED_PIN);
gpio_dir(&gpio_led, PIN_OUTPUT); // Direction: Output
gpio_mode(&gpio_led, PullNone); // No pull
// Initial Push Button pin as interrupt source
gpio_irq_init(&gpio_btn, GPIO_IRQ_PIN, gpio_demo_irq_handler, (uint32_t)(&gpio_led));
gpio_irq_set(&gpio_btn, IRQ_FALL, 1); // Falling Edge Trigger
gpio_irq_enable(&gpio_btn);
// led on means system is in run mode
gpio_write(&gpio_led, 1);
printf("\r\nPush button at PC_4 to enter deep sleep\r\n");
while(1);
}
int gpio_init_int(gpio_t pin, gpio_mode_t mode, gpio_flank_t flank,
gpio_cb_t cb, void *arg)
{
const uint8_t port_num = _port_num(pin);
const uint32_t port_addr = _port_base[port_num];
const uint32_t icr_reg_addr = port_addr + GPIO_ICR_R_OFF;
const uint8_t pin_num = _pin_num(pin);
const uint8_t pin_bit = 1<<pin_num;
const unsigned int int_num = _int_assign[port_num];
const uint32_t sysctl_port_base = _sysctl_port_base[port_num];
ROM_SysCtlPeripheralEnable(sysctl_port_base);
gpio_config[port_num][pin_num].cb = cb;
gpio_config[port_num][pin_num].arg = arg;
DEBUG("init int pin:%d, int num %d, port addr %" PRIx32 "\n",
pin_num, int_num, port_addr);
ROM_GPIODirModeSet(port_addr, 1<<pin_num, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(port_addr, 1<<pin_num,
GPIO_STRENGTH_2MA, TYPE(mode));
ROM_IntMasterDisable();
HWREG(icr_reg_addr) = pin_bit;
ROM_GPIOIntTypeSet(port_addr, pin_bit, flank);
HWREG(port_addr+GPIO_LOCK_R_OFF) = GPIO_LOCK_KEY;
HWREG(port_addr+GPIO_CR_R_OFF) |= pin_bit;
HWREG(port_addr+GPIO_DEN_R_OFF) |= pin_bit;
HWREG(port_addr+GPIO_LOCK_R_OFF) = 0;
gpio_irq_enable(pin);
ROM_IntEnable(int_num);
ROM_IntMasterEnable();
return 0;
}
static enum hrtimer_restart xpt2046_dostimer(struct hrtimer *handle)
{
struct XPT2046_TS_EVENT *ts_dev = container_of(handle, struct XPT2046_TS_EVENT, timer);
struct input_dev *xpt2046_ts_dev;
int ts_io_pin_status;
rk28printk("************>%s.....%s.....\n",__FILE__,__FUNCTION__);
rk28printk("************>%s.....%s.....\n",__FILE__,__FUNCTION__);
spin_lock_irq(&ts_dev->lock);
ts_io_pin_status = GPIOGetPinLevel(PT2046_PENIRQ);
rk28printk("************>%s....PE7status=%d\n",__FUNCTION__,ts_io_pin_status);
rk28printk("--------<%s>--- ts_dev->pendown = %d, PE7status = %d \n", __FUNCTION__, ts_dev->pendown, ts_io_pin_status);
if(unlikely(ts_dev->pendown && ts_io_pin_status))
{
xpt2046_ts_dev = ts_dev->input;
rk28printk("The touchscreen up!!\n");
//printk("-------------------------------------------The touchscreen up!!\n");
input_report_key(xpt2046_ts_dev,BTN_TOUCH,0);
input_sync(xpt2046_ts_dev);
ts_dev->pendown = 0;
gpio_irq_enable(PT2046_PENIRQ);
ClearBuff();
gLastZvalue[0] = 4095;
gLastZvalue[1] = 4095;
}
else {
/*still down ,continue with the measurement*/
xpt2046_read_values(ts_dev);
xpt2046_send_values(ts_dev);
}
spin_unlock_irq(&ts_dev->lock);
#ifdef CONFIG_ANDROID_POWER
if(rk2818_get_suspend_flags() != PM_AWAKE) {
rk28_send_wakeup_key();
printk("touch screen wake up\n");
}
#endif
return HRTIMER_NORESTART;
}
int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, uint32_t id)
{
if (pin == NC) {
return -1;
}
uint32_t pin_index = NU_PINNAME_TO_PIN(pin);
uint32_t port_index = NU_PINNAME_TO_PORT(pin);
if (pin_index >= NU_MAX_PIN_PER_PORT || port_index >= NU_MAX_PORT) {
return -1;
}
obj->pin = pin;
obj->irq_handler = (uint32_t) handler;
obj->irq_id = id;
GPIO_T *gpio_base = NU_PORT_BASE(port_index);
//gpio_set(pin);
#if NUC472_GPIO_IRQ_DEBOUNCE_ENABLE
// Configure de-bounce clock source and sampling cycle time
GPIO_SET_DEBOUNCE_TIME(NUC472_GPIO_IRQ_DEBOUNCE_CLOCK_SOURCE, NUC472_GPIO_IRQ_DEBOUNCE_SAMPLE_RATE);
GPIO_ENABLE_DEBOUNCE(gpio_base, 1 << pin_index);
#else
GPIO_DISABLE_DEBOUNCE(gpio_base, 1 << pin_index);
#endif
struct nu_gpio_irq_var *var = gpio_irq_var_arr + port_index;
var->obj_arr[pin_index] = obj;
// NOTE: InterruptIn requires IRQ enabled by default.
gpio_irq_enable(obj);
return 0;
}
void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable)
{
gpio_cfg_t* cfg = &m_gpio_cfg[obj->ch];
bool irq_enabled_before =
(m_gpio_irq_enabled & ((gpio_mask_t)1 << obj->ch)) &&
(cfg->irq_rise || cfg->irq_fall);
if (event == IRQ_RISE) {
cfg->irq_rise = enable ? true : false;
}
else if (event == IRQ_FALL) {
cfg->irq_fall = enable ? true : false;
}
bool irq_enabled_after = cfg->irq_rise || cfg->irq_fall;
if (irq_enabled_before != irq_enabled_after) {
if (irq_enabled_after) {
gpio_irq_enable(obj);
} else {
gpio_irq_disable(obj);
}
}
}
void at86rf231_enable_interrupts(void)
{
gpio_irq_enable(SPI_0_IRQ0_GPIO);
}
void InterruptIn::enable_irq() {
gpio_irq_enable(&gpio_irq);
}
void InterruptIn::enable_irq() {
core_util_critical_section_enter();
gpio_irq_enable(&gpio_irq);
core_util_critical_section_exit();
}
void pinMode( uint32_t ulPin, uint32_t ulMode)
{
void *pGpio_t;
if ( ulPin < 0 || ulPin > TOTAL_GPIO_PIN_NUM )
{
return;
}
if ( (g_APinDescription[ulPin].ulPinType == PIO_GPIO || g_APinDescription[ulPin].ulPinType == PIO_GPIO_IRQ)
&& g_APinDescription[ulPin].ulPinMode == ulMode)
{
return;
}
if ( g_APinDescription[ulPin].ulPinType == PIO_PWM ) {
pinRemoveMode(ulPin);
}
if ( g_APinDescription[ulPin].ulPinType == PIO_GPIO &&
(ulMode == INPUT_IRQ_FALL || ulMode == INPUT_IRQ_RISE) ) {
// requst type from gpio_t to gpio_irq_t
pinRemoveMode(ulPin);
}
if ( g_APinDescription[ulPin].ulPinType == PIO_GPIO_IRQ &&
(ulMode == INPUT || ulMode == OUTPUT || ulMode == INPUT_PULLUP || ulMode == INPUT_PULLNONE || ulMode == OUTPUT_OPENDRAIN) ) {
// requst type from gpio_irq_t to gpio_t
pinRemoveMode(ulPin);
}
if ( g_APinDescription[ulPin].ulPinType == NOT_INITIAL ) {
if (ulMode == INPUT_IRQ_FALL || ulMode == INPUT_IRQ_RISE) {
gpio_pin_struct[ulPin] = malloc ( sizeof(gpio_irq_t) );
pGpio_t = gpio_pin_struct[ulPin];
gpio_irq_init( pGpio_t, g_APinDescription[ulPin].pinname, gpioIrqHandler, ulPin);
g_APinDescription[ulPin].ulPinType = PIO_GPIO_IRQ;
} else {
gpio_pin_struct[ulPin] = malloc ( sizeof(gpio_t) );
pGpio_t = gpio_pin_struct[ulPin];
gpio_init( pGpio_t, g_APinDescription[ulPin].pinname );
g_APinDescription[ulPin].ulPinType = PIO_GPIO;
}
g_APinDescription[ulPin].ulPinMode = ulMode;
} else {
pGpio_t = gpio_pin_struct[ulPin];
}
switch ( ulMode )
{
case INPUT:
gpio_dir( (gpio_t *)pGpio_t, PIN_INPUT );
gpio_mode( (gpio_t *)pGpio_t, PullDown );
break;
case INPUT_PULLNONE:
gpio_dir( (gpio_t *)pGpio_t, PIN_INPUT );
gpio_mode( (gpio_t *)pGpio_t, PullNone );
break;
case INPUT_PULLUP:
gpio_dir( (gpio_t *)pGpio_t, PIN_INPUT );
gpio_mode( (gpio_t *)pGpio_t, PullUp );
break;
case OUTPUT:
gpio_dir( (gpio_t *)pGpio_t, PIN_OUTPUT );
gpio_mode( (gpio_t *)pGpio_t, PullNone );
break;
case OUTPUT_OPENDRAIN:
gpio_dir( (gpio_t *)pGpio_t, PIN_OUTPUT );
gpio_mode( (gpio_t *)pGpio_t, OpenDrain );
break;
case INPUT_IRQ_FALL:
gpio_irq_set( (gpio_irq_t *)pGpio_t, IRQ_FALL, 1 );
gpio_irq_enable( (gpio_irq_t *)pGpio_t );
break;
case INPUT_IRQ_RISE:
gpio_irq_set( (gpio_irq_t *)pGpio_t, IRQ_RISE, 1 );
gpio_irq_enable( (gpio_irq_t *)pGpio_t );
break;
case INPUT_IRQ_LOW:
gpio_irq_set( (gpio_irq_t *)pGpio_t, IRQ_LOW, 1 );
gpio_irq_enable( (gpio_irq_t *)pGpio_t );
break;
case INPUT_IRQ_HIGH:
gpio_irq_set( (gpio_irq_t *)pGpio_t, IRQ_HIGH, 1 );
gpio_irq_enable( (gpio_irq_t *)pGpio_t );
break;
default:
break ;
}
}
OSStatus mico_gpio_enable_IRQ( mico_gpio_t gpio, mico_gpio_irq_trigger_t trigger, mico_gpio_irq_handler_t handler, void* arg )
{
if(gpio == (mico_gpio_t)MICO_GPIO_UNUSED ) return kUnsupportedErr;
return gpio_irq_enable( gpio_mapping[gpio].bank, gpio_mapping[gpio].number, trigger, handler, arg );
}
