stm32_gpio_irq.c

Go to the documentation of this file.

/**
 * \file    heivs/stm32_gpio_irq.c
 * \brief   GPIO interrupts
 * \author  marc dot pignat at hevs dot ch
 */

#include "heivs/stm32_gpio_irq.h"
#include <stdint.h>
#include <stddef.h>
#include "stm32/stm32f4xx_rcc.h"
#include "stm32/stm32f4xx_misc.h"
#include "stm32/stm32f4xx_syscfg.h"
#include "stm32/stm32f4xx_exti.h"
#include "heivs/bsp.h"

struct gpio_irq_handler_t
{
    uint32_t (*handler)(const struct gpio_t *gpio);
    enum gpio_irq_mode_e mode;
    struct gpio_t gpio;
};

static struct gpio_irq_handler_t handlers[16];

static uint32_t exti_line(const struct gpio_t *gpio)
{
    return gpio->mask;
}

static status_e _disable_irq(const struct gpio_t *gpio)
{
    EXTI_InitTypeDef EXTI_InitStructure;
    EXTI_StructInit(&EXTI_InitStructure);
    EXTI_InitStructure.EXTI_Line = exti_line(gpio);
    EXTI_InitStructure.EXTI_LineCmd = DISABLE;

    EXTI_Init(&EXTI_InitStructure);

    return NO_ERROR;
}

static const struct gpio_t NC = GPIO_NC;

status_e gpio_irq_disable(const struct gpio_t *gpio)
{
    return gpio_irq_setup(gpio, NULL, GPIO_IRQ_MODE_DISABLED, 0);
}

static void exti_handler(uint32_t nr)
{
    const struct gpio_t *gpio = &handlers[nr].gpio;
    EXTI->PR = exti_line(gpio);

    switch (handlers[nr].mode)
    {
    case GPIO_IRQ_MODE_DISABLED:
    break;

    case GPIO_IRQ_MODE_EDGE_RISING:
    case GPIO_IRQ_MODE_EDGE_FALLING:
    case GPIO_IRQ_MODE_EDGE_BOTH:
        handlers[nr].handler(gpio);
    break;

    case GPIO_IRQ_MODE_LEVEL_LOW:
        while (!gpio_get(gpio))
        {
            if (handlers[nr].handler(gpio))
            {
                /* The gpio hasn't moved, but the handler says it's ok*/
                break;
            }
        }
    break;

    case GPIO_IRQ_MODE_LEVEL_HIGH:
        while (gpio_get(gpio))
        {
            if (handlers[nr].handler(gpio))
            {
                /* The gpio hasn't moved, but the handler says it's ok*/
                break;
            }
        }
    break;

    default:
        // ERROR_BAD_SWITCH !?!
        bsp_fatal(ERROR_BAD_SWITCH);
    break;
    }
}

static void exti0_irq_handler(void)
{
    exti_handler(0);
}

static void exti1_irq_handler(void)
{
    exti_handler(1);
}

static void exti2_irq_handler(void)
{
    exti_handler(2);
}

static void exti3_irq_handler(void)
{
    exti_handler(3);
}

static void exit4_irq_handler(void)
{
    exti_handler(4);
}

static void exti9_5_irq_handler(void)
{
    uint32_t i;
    for (i = 5 ; i <= 9 ; i++)
    {
        const struct gpio_t *gpio = &handlers[i].gpio;

        if (!exti_line(gpio))
        {
            continue;
        }

        if (EXTI_GetITStatus(exti_line(gpio)))
        {
            exti_handler(i);
        }
    }
}

static void exti15_10_irq_handler(void)
{
    uint32_t i;
    for (i = 10 ; i <= 15 ; i++)
    {
        const struct gpio_t *gpio = &handlers[i].gpio;

        if (!exti_line(gpio))
        {
            continue;
        }

        if (EXTI_GetITStatus(exti_line(gpio)))
        {
            exti_handler(i);
        }
    }
}

struct gpio_exti_map_t
{
    uint32_t irq_nr;
    void (*handler)(void);
};

static const struct gpio_exti_map_t map[] =
{
    {.irq_nr = EXTI0_IRQn,      .handler = exti0_irq_handler, },
    {.irq_nr = EXTI1_IRQn,      .handler = exti1_irq_handler, },
    {.irq_nr = EXTI2_IRQn,      .handler = exti2_irq_handler, },
    {.irq_nr = EXTI3_IRQn,      .handler = exti3_irq_handler, },
    {.irq_nr = EXTI4_IRQn,      .handler = exit4_irq_handler, },
    {.irq_nr = EXTI9_5_IRQn,    .handler = exti9_5_irq_handler, },
    {.irq_nr = EXTI9_5_IRQn,    .handler = exti9_5_irq_handler, },
    {.irq_nr = EXTI9_5_IRQn,    .handler = exti9_5_irq_handler, },
    {.irq_nr = EXTI9_5_IRQn,    .handler = exti9_5_irq_handler, },
    {.irq_nr = EXTI9_5_IRQn,    .handler = exti9_5_irq_handler, },
    {.irq_nr = EXTI15_10_IRQn,  .handler = exti15_10_irq_handler, },
    {.irq_nr = EXTI15_10_IRQn,  .handler = exti15_10_irq_handler, },
    {.irq_nr = EXTI15_10_IRQn,  .handler = exti15_10_irq_handler, },
    {.irq_nr = EXTI15_10_IRQn,  .handler = exti15_10_irq_handler, },
    {.irq_nr = EXTI15_10_IRQn,  .handler = exti15_10_irq_handler, },
    {.irq_nr = EXTI15_10_IRQn,  .handler = exti15_10_irq_handler, },
};

status_e gpio_irq_restore(const struct gpio_t *gpio)
{
    switch (handlers[gpio->nr].mode)
    {
        case GPIO_IRQ_MODE_EDGE_FALLING:
        case GPIO_IRQ_MODE_EDGE_RISING:
        case GPIO_IRQ_MODE_EDGE_BOTH:
            return NO_ERROR;
        break;

        case GPIO_IRQ_MODE_LEVEL_LOW:
            if (!gpio_get(gpio))
            {
                EXTI_GenerateSWInterrupt(exti_line(gpio));
                return NO_ERROR;
            }
        break;

        case GPIO_IRQ_MODE_LEVEL_HIGH:
            if (gpio_get(gpio))
            {
                EXTI_GenerateSWInterrupt(exti_line(gpio));
                return NO_ERROR;
            }
        break;

        default:
            return ERROR_BAD_SWITCH;
        break;
    }

    return ERROR_BAD_SWITCH;
}

status_e gpio_irq_setup(const struct gpio_t *gpio, uint32_t (*handler)(const struct gpio_t *gpio), enum gpio_irq_mode_e mode, uint32_t prio)
{
    EXTI_InitTypeDef EXTI_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    // Parameters validation
    switch (mode)
    {
    case GPIO_IRQ_MODE_DISABLED:
        if (handler != NULL)
        {
            return ERROR_BAD_PARAM;
        }
    break;

    case GPIO_IRQ_MODE_EDGE_FALLING:
    case GPIO_IRQ_MODE_EDGE_RISING:
    case GPIO_IRQ_MODE_EDGE_BOTH:
    case GPIO_IRQ_MODE_LEVEL_LOW:
    case GPIO_IRQ_MODE_LEVEL_HIGH:
    break;

    default:
        return ERROR_BAD_PARAM;
    break;
    }

    if (gpio->nr >= ARRAY_SIZE(handlers))
    {
        return ERROR_BAD_PARAM;
    }

    // Disabling ?
    if (!handler)
    {
        status_e status = _disable_irq(gpio);
        handlers[gpio->nr].mode = GPIO_IRQ_MODE_DISABLED;
        handlers[gpio->nr].handler = handler;
        handlers[gpio->nr].gpio = NC;

        return status;
    }

    handlers[gpio->nr].mode = mode;
    handlers[gpio->nr].handler = handler;
    handlers[gpio->nr].gpio = *gpio;

    gpio_setup(gpio);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    EXTI_StructInit(&EXTI_InitStructure);
    EXTI_InitStructure.EXTI_Line = exti_line(gpio);
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;

    switch (mode)
    {
    case GPIO_IRQ_MODE_DISABLED:
        return ERROR_BAD_SWITCH;
    break;

    case GPIO_IRQ_MODE_EDGE_FALLING:
        EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    break;

    case GPIO_IRQ_MODE_EDGE_RISING:
        EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    break;

    case GPIO_IRQ_MODE_EDGE_BOTH:
        EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
    break;

    case GPIO_IRQ_MODE_LEVEL_LOW:
        EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    break;

    case GPIO_IRQ_MODE_LEVEL_HIGH:
        EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    break;

    default:
        return ERROR_BAD_SWITCH;
    break;

    }

    SYSCFG_EXTILineConfig(gpio->ctrl, gpio->nr);
    EXTI_Init(&EXTI_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = map[gpio->nr].irq_nr;

    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = prio;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = prio;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_Handler = map[gpio->nr].handler;
    NVIC_Init(&NVIC_InitStructure);

    // Force pending level interrupts
    switch (mode)
    {
    case GPIO_IRQ_MODE_LEVEL_LOW:
        if (!gpio_get(gpio))
        {
            EXTI_GenerateSWInterrupt(exti_line(gpio));
        }
    break;

    case GPIO_IRQ_MODE_LEVEL_HIGH:
        if (gpio_get(gpio))
        {
            EXTI_GenerateSWInterrupt(exti_line(gpio));
        }
    break;

    default:
    break;
    }
    return NO_ERROR;
}