pio.c

Go to the documentation of this file.

/*
 * Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
 */

#include "pio.h"

#ifndef PIO_WPMR_WPKEY_PASSWD
#  define PIO_WPMR_WPKEY_PASSWD PIO_WPMR_WPKEY(0x50494Fu)
#endif

#ifndef FREQ_SLOW_CLOCK_EXT
/* External slow clock frequency (hz) */
#define FREQ_SLOW_CLOCK_EXT 32768
#endif

void pio_pull_up(Pio *p_pio, const uint32_t ul_mask,
                const uint32_t ul_pull_up_enable)
{
        /* Enable the pull-up(s) if necessary */
        if (ul_pull_up_enable) {
                p_pio->PIO_PUER = ul_mask;
        } else {
                p_pio->PIO_PUDR = ul_mask;
        }
}

void pio_set_debounce_filter(Pio *p_pio, const uint32_t ul_mask,
                const uint32_t ul_cut_off)
{
#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAMG || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)
        /* Set Debouncing, 0 bit field no effect */
        p_pio->PIO_IFSCER = ul_mask;
#elif (SAM3XA || SAM3U)
        /* Set Debouncing, 0 bit field no effect */
        p_pio->PIO_DIFSR = ul_mask;
#else
#error "Unsupported device"
#endif

        /*
         * The debouncing filter can filter a pulse of less than 1/2 Period of a
         * programmable Divided Slow Clock:
         * Tdiv_slclk = ((DIV+1)*2).Tslow_clock
         */
        p_pio->PIO_SCDR = PIO_SCDR_DIV((FREQ_SLOW_CLOCK_EXT /
                        (2 * (ul_cut_off))) - 1);
}

void pio_set(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_SODR = ul_mask;
}

void pio_clear(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_CODR = ul_mask;
}

uint32_t pio_get(Pio *p_pio, const pio_type_t ul_type,
                const uint32_t ul_mask)
{
        uint32_t ul_reg;

        if ((ul_type == PIO_OUTPUT_0) || (ul_type == PIO_OUTPUT_1)) {
                ul_reg = p_pio->PIO_ODSR;
        } else {
                ul_reg = p_pio->PIO_PDSR;
        }

        if ((ul_reg & ul_mask) == 0) {
                return 0;
        } else {
                return 1;
        }
}

void pio_set_peripheral(Pio *p_pio, const pio_type_t ul_type,
                const uint32_t ul_mask)
{
        uint32_t ul_sr;

        /* Disable interrupts on the pin(s) */
        p_pio->PIO_IDR = ul_mask;

#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAMG || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)
        switch (ul_type) {
        case PIO_PERIPH_A:
                ul_sr = p_pio->PIO_ABCDSR[0];
                p_pio->PIO_ABCDSR[0] &= (~ul_mask & ul_sr);

                ul_sr = p_pio->PIO_ABCDSR[1];
                p_pio->PIO_ABCDSR[1] &= (~ul_mask & ul_sr);
                break;
        case PIO_PERIPH_B:
                ul_sr = p_pio->PIO_ABCDSR[0];
                p_pio->PIO_ABCDSR[0] = (ul_mask | ul_sr);

                ul_sr = p_pio->PIO_ABCDSR[1];
                p_pio->PIO_ABCDSR[1] &= (~ul_mask & ul_sr);
                break;
#if (!SAMG)
        case PIO_PERIPH_C:
                ul_sr = p_pio->PIO_ABCDSR[0];
                p_pio->PIO_ABCDSR[0] &= (~ul_mask & ul_sr);

                ul_sr = p_pio->PIO_ABCDSR[1];
                p_pio->PIO_ABCDSR[1] = (ul_mask | ul_sr);
                break;
        case PIO_PERIPH_D:
                ul_sr = p_pio->PIO_ABCDSR[0];
                p_pio->PIO_ABCDSR[0] = (ul_mask | ul_sr);

                ul_sr = p_pio->PIO_ABCDSR[1];
                p_pio->PIO_ABCDSR[1] = (ul_mask | ul_sr);
                break;
#endif
                /* Other types are invalid in this function */
        case PIO_INPUT:
        case PIO_OUTPUT_0:
        case PIO_OUTPUT_1:
        case PIO_NOT_A_PIN:
                return;
        }
#elif (SAM3XA|| SAM3U)
        switch (ul_type) {
        case PIO_PERIPH_A:
                ul_sr = p_pio->PIO_ABSR;
                p_pio->PIO_ABSR &= (~ul_mask & ul_sr);
                break;

        case PIO_PERIPH_B:
                ul_sr = p_pio->PIO_ABSR;
                p_pio->PIO_ABSR = (ul_mask | ul_sr);
                break;

                // other types are invalid in this function
        case PIO_INPUT:
        case PIO_OUTPUT_0:
        case PIO_OUTPUT_1:
        case PIO_NOT_A_PIN:
                return;
        }
#else
#error "Unsupported device"
#endif

        /* Remove the pins from under the control of PIO */
        p_pio->PIO_PDR = ul_mask;
}

void pio_set_input(Pio *p_pio, const uint32_t ul_mask,
                const uint32_t ul_attribute)
{
        pio_disable_interrupt(p_pio, ul_mask);
        pio_pull_up(p_pio, ul_mask, ul_attribute & PIO_PULLUP);

        /* Enable Input Filter if necessary */
        if (ul_attribute & (PIO_DEGLITCH | PIO_DEBOUNCE)) {
                p_pio->PIO_IFER = ul_mask;
        } else {
                p_pio->PIO_IFDR = ul_mask;
        }

#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAMG || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)
        /* Enable de-glitch or de-bounce if necessary */
        if (ul_attribute & PIO_DEGLITCH) {
                p_pio->PIO_IFSCDR = ul_mask;
        } else {
                if (ul_attribute & PIO_DEBOUNCE) {
                        p_pio->PIO_IFSCER = ul_mask;
                }
        }
#elif (SAM3XA|| SAM3U)
        /* Enable de-glitch or de-bounce if necessary */
        if (ul_attribute & PIO_DEGLITCH) {
                p_pio->PIO_SCIFSR = ul_mask;
        } else {
                if (ul_attribute & PIO_DEBOUNCE) {
                        p_pio->PIO_DIFSR = ul_mask;
                }
        }
#else
#error "Unsupported device"
#endif

        /* Configure pin as input */
        p_pio->PIO_ODR = ul_mask;
        p_pio->PIO_PER = ul_mask;
}

void pio_set_output(Pio *p_pio, const uint32_t ul_mask,
                const uint32_t ul_default_level,
                const uint32_t ul_multidrive_enable,
                const uint32_t ul_pull_up_enable)
{
        pio_disable_interrupt(p_pio, ul_mask);
        pio_pull_up(p_pio, ul_mask, ul_pull_up_enable);

        /* Enable multi-drive if necessary */
        if (ul_multidrive_enable) {
                p_pio->PIO_MDER = ul_mask;
        } else {
                p_pio->PIO_MDDR = ul_mask;
        }

        /* Set default value */
        if (ul_default_level) {
                p_pio->PIO_SODR = ul_mask;
        } else {
                p_pio->PIO_CODR = ul_mask;
        }

        /* Configure pin(s) as output(s) */
        p_pio->PIO_OER = ul_mask;
        p_pio->PIO_PER = ul_mask;
}

uint32_t pio_configure(Pio *p_pio, const pio_type_t ul_type,
                const uint32_t ul_mask, const uint32_t ul_attribute)
{
        /* Configure pins */
        switch (ul_type) {
        case PIO_PERIPH_A:
        case PIO_PERIPH_B:
#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)
        case PIO_PERIPH_C:
        case PIO_PERIPH_D:
#endif
                pio_set_peripheral(p_pio, ul_type, ul_mask);
                pio_pull_up(p_pio, ul_mask, (ul_attribute & PIO_PULLUP));
                break;

        case PIO_INPUT:
                pio_set_input(p_pio, ul_mask, ul_attribute);
                break;

        case PIO_OUTPUT_0:
        case PIO_OUTPUT_1:
                pio_set_output(p_pio, ul_mask, (ul_type == PIO_OUTPUT_1),
                                (ul_attribute & PIO_OPENDRAIN) ? 1 : 0,
                                (ul_attribute & PIO_PULLUP) ? 1 : 0);
                break;

        default:
                return 0;
        }

        return 1;
}

uint32_t pio_get_output_data_status(const Pio *p_pio,
                const uint32_t ul_mask)
{
        if ((p_pio->PIO_ODSR & ul_mask) == 0) {
                return 0;
        } else {
                return 1;
        }
}

void pio_set_multi_driver(Pio *p_pio, const uint32_t ul_mask,
                const uint32_t ul_multi_driver_enable)
{
        /* Enable the multi-driver if necessary */
        if (ul_multi_driver_enable) {
                p_pio->PIO_MDER = ul_mask;
        } else {
                p_pio->PIO_MDDR = ul_mask;
        }
}

uint32_t pio_get_multi_driver_status(const Pio *p_pio)
{
        return p_pio->PIO_MDSR;
}


#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAMG || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)

void pio_pull_down(Pio *p_pio, const uint32_t ul_mask,
                const uint32_t ul_pull_down_enable)
{
        /* Enable the pull-down if necessary */
        if (ul_pull_down_enable) {
                p_pio->PIO_PPDER = ul_mask;
        } else {
                p_pio->PIO_PPDDR = ul_mask;
        }
}
#endif

void pio_enable_output_write(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_OWER = ul_mask;
}

void pio_disable_output_write(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_OWDR = ul_mask;
}

uint32_t pio_get_output_write_status(const Pio *p_pio)
{
        return p_pio->PIO_OWSR;
}

void pio_sync_output_write(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_ODSR = ul_mask;
}

#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAMG || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)

void pio_set_schmitt_trigger(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_SCHMITT = ul_mask;
}

uint32_t pio_get_schmitt_trigger(const Pio *p_pio)
{
        return p_pio->PIO_SCHMITT;
}
#endif

void pio_configure_interrupt(Pio *p_pio, const uint32_t ul_mask,
                const uint32_t ul_attr)
{
        /* Configure additional interrupt mode registers. */
        if (ul_attr & PIO_IT_AIME) {
                /* Enable additional interrupt mode. */
                p_pio->PIO_AIMER = ul_mask;

                /* If bit field of the selected pin is 1, set as
                   Rising Edge/High level detection event. */
                if (ul_attr & PIO_IT_RE_OR_HL) {
                        /* Rising Edge or High Level */
                        p_pio->PIO_REHLSR = ul_mask;
                } else {
                        /* Falling Edge or Low Level */
                        p_pio->PIO_FELLSR = ul_mask;
                }

                /* If bit field of the selected pin is 1, set as
                   edge detection source. */
                if (ul_attr & PIO_IT_EDGE) {
                        /* Edge select */
                        p_pio->PIO_ESR = ul_mask;
                } else {
                        /* Level select */
                        p_pio->PIO_LSR = ul_mask;
                }
        } else {
                /* Disable additional interrupt mode. */
                p_pio->PIO_AIMDR = ul_mask;
        }
}

void pio_enable_interrupt(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_IER = ul_mask;
}

void pio_disable_interrupt(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_IDR = ul_mask;
}

uint32_t pio_get_interrupt_status(const Pio *p_pio)
{
        return p_pio->PIO_ISR;
}

uint32_t pio_get_interrupt_mask(const Pio *p_pio)
{
        return p_pio->PIO_IMR;
}

void pio_set_additional_interrupt_mode(Pio *p_pio,
                const uint32_t ul_mask, const uint32_t ul_attribute)
{
        /* Enables additional interrupt mode if needed */
        if (ul_attribute & PIO_IT_AIME) {
                /* Enables additional interrupt mode */
                p_pio->PIO_AIMER = ul_mask;

                /* Configures the Polarity of the event detection */
                /* (Rising/Falling Edge or High/Low Level) */
                if (ul_attribute & PIO_IT_RE_OR_HL) {
                        /* Rising Edge or High Level */
                        p_pio->PIO_REHLSR = ul_mask;
                } else {
                        /* Falling Edge or Low Level */
                        p_pio->PIO_FELLSR = ul_mask;
                }

                /* Configures the type of event detection (Edge or Level) */
                if (ul_attribute & PIO_IT_EDGE) {
                        /* Edge select */
                        p_pio->PIO_ESR = ul_mask;
                } else {
                        /* Level select */
                        p_pio->PIO_LSR = ul_mask;
                }
        } else {
                /* Disable additional interrupt mode */
                p_pio->PIO_AIMDR = ul_mask;
        }
}

#ifndef PIO_WPMR_WPKEY_PASSWD
#define PIO_WPMR_WPKEY_PASSWD    PIO_WPMR_WPKEY(0x50494FU)
#endif

void pio_set_writeprotect(Pio *p_pio, const uint32_t ul_enable)
{
        p_pio->PIO_WPMR = PIO_WPMR_WPKEY_PASSWD | (ul_enable & PIO_WPMR_WPEN);
}

uint32_t pio_get_writeprotect_status(const Pio *p_pio)
{
        return p_pio->PIO_WPSR;
}

uint32_t pio_get_pin_value(uint32_t ul_pin)
{
        Pio *p_pio = pio_get_pin_group(ul_pin);

        return (p_pio->PIO_PDSR >> (ul_pin & 0x1F)) & 1;
}

void pio_set_pin_high(uint32_t ul_pin)
{
        Pio *p_pio = pio_get_pin_group(ul_pin);

        /* Value to be driven on the I/O line: 1. */
        p_pio->PIO_SODR = 1 << (ul_pin & 0x1F);
}

void pio_set_pin_low(uint32_t ul_pin)
{
        Pio *p_pio = pio_get_pin_group(ul_pin);

        /* Value to be driven on the I/O line: 0. */
        p_pio->PIO_CODR = 1 << (ul_pin & 0x1F);
}

void pio_toggle_pin(uint32_t ul_pin)
{
        Pio *p_pio = pio_get_pin_group(ul_pin);

        if (p_pio->PIO_ODSR & (1 << (ul_pin & 0x1F))) {
                /* Value to be driven on the I/O line: 0. */
                p_pio->PIO_CODR = 1 << (ul_pin & 0x1F);
        } else {
                /* Value to be driven on the I/O line: 1. */
                p_pio->PIO_SODR = 1 << (ul_pin & 0x1F);
        }
}

uint32_t pio_configure_pin(uint32_t ul_pin, const uint32_t ul_flags)
{
        Pio *p_pio = pio_get_pin_group(ul_pin);

        /* Configure pins */
        switch (ul_flags & PIO_TYPE_Msk) {
        case PIO_TYPE_PIO_PERIPH_A:
                pio_set_peripheral(p_pio, PIO_PERIPH_A, (1 << (ul_pin & 0x1F)));
                pio_pull_up(p_pio, (1 << (ul_pin & 0x1F)),
                                (ul_flags & PIO_PULLUP));
                break;
        case PIO_TYPE_PIO_PERIPH_B:
                pio_set_peripheral(p_pio, PIO_PERIPH_B, (1 << (ul_pin & 0x1F)));
                pio_pull_up(p_pio, (1 << (ul_pin & 0x1F)),
                                (ul_flags & PIO_PULLUP));
                break;
#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)
        case PIO_TYPE_PIO_PERIPH_C:
                pio_set_peripheral(p_pio, PIO_PERIPH_C, (1 << (ul_pin & 0x1F)));
                pio_pull_up(p_pio, (1 << (ul_pin & 0x1F)),
                                (ul_flags & PIO_PULLUP));
                break;
        case PIO_TYPE_PIO_PERIPH_D:
                pio_set_peripheral(p_pio, PIO_PERIPH_D, (1 << (ul_pin & 0x1F)));
                pio_pull_up(p_pio, (1 << (ul_pin & 0x1F)),
                                (ul_flags & PIO_PULLUP));
                break;
#endif

        case PIO_TYPE_PIO_INPUT:
                pio_set_input(p_pio, (1 << (ul_pin & 0x1F)), ul_flags);
                break;

        case PIO_TYPE_PIO_OUTPUT_0:
        case PIO_TYPE_PIO_OUTPUT_1:
                pio_set_output(p_pio, (1 << (ul_pin & 0x1F)),
                                ((ul_flags & PIO_TYPE_PIO_OUTPUT_1)
                                == PIO_TYPE_PIO_OUTPUT_1) ? 1 : 0,
                                (ul_flags & PIO_OPENDRAIN) ? 1 : 0,
                                (ul_flags & PIO_PULLUP) ? 1 : 0);
                break;

        default:
                return 0;
        }

        return 1;
}

void pio_set_pin_group_high(Pio *p_pio, uint32_t ul_mask)
{
        /* Value to be driven on the I/O line: 1. */
        p_pio->PIO_SODR = ul_mask;
}

void pio_set_pin_group_low(Pio *p_pio, uint32_t ul_mask)
{
        /* Value to be driven on the I/O line: 0. */
        p_pio->PIO_CODR = ul_mask;
}

void pio_toggle_pin_group(Pio *p_pio, uint32_t ul_mask)
{
        if (p_pio->PIO_ODSR & ul_mask) {
                /* Value to be driven on the I/O line: 0. */
                p_pio->PIO_CODR = ul_mask;
        } else {
                /* Value to be driven on the I/O line: 1. */
                p_pio->PIO_SODR = ul_mask;
        }
}

uint32_t pio_configure_pin_group(Pio *p_pio,
                uint32_t ul_mask, const uint32_t ul_flags)
{
        /* Configure pins */
        switch (ul_flags & PIO_TYPE_Msk) {
        case PIO_TYPE_PIO_PERIPH_A:
                pio_set_peripheral(p_pio, PIO_PERIPH_A, ul_mask);
                pio_pull_up(p_pio, ul_mask, (ul_flags & PIO_PULLUP));
                break;
        case PIO_TYPE_PIO_PERIPH_B:
                pio_set_peripheral(p_pio, PIO_PERIPH_B, ul_mask);
                pio_pull_up(p_pio, ul_mask, (ul_flags & PIO_PULLUP));
                break;
#if (SAM3S || SAM3N || SAM4S || SAM4E || SAM4N || SAM4C || SAM4CP || SAM4CM || SAMV71 || SAMV70 || SAME70 || SAMS70)
        case PIO_TYPE_PIO_PERIPH_C:
                pio_set_peripheral(p_pio, PIO_PERIPH_C, ul_mask);
                pio_pull_up(p_pio, ul_mask, (ul_flags & PIO_PULLUP));
                break;
        case PIO_TYPE_PIO_PERIPH_D:
                pio_set_peripheral(p_pio, PIO_PERIPH_D, ul_mask);
                pio_pull_up(p_pio, ul_mask, (ul_flags & PIO_PULLUP));
                break;
#endif

        case PIO_TYPE_PIO_INPUT:
                pio_set_input(p_pio, ul_mask, ul_flags);
                break;

        case PIO_TYPE_PIO_OUTPUT_0:
        case PIO_TYPE_PIO_OUTPUT_1:
                pio_set_output(p_pio, ul_mask,
                                ((ul_flags & PIO_TYPE_PIO_OUTPUT_1)
                                == PIO_TYPE_PIO_OUTPUT_1) ? 1 : 0,
                                (ul_flags & PIO_OPENDRAIN) ? 1 : 0,
                                (ul_flags & PIO_PULLUP) ? 1 : 0);
                break;

        default:
                return 0;
        }

        return 1;
}

void pio_enable_pin_interrupt(uint32_t ul_pin)
{
        Pio *p_pio = pio_get_pin_group(ul_pin);

        p_pio->PIO_IER = 1 << (ul_pin & 0x1F);
}


void pio_disable_pin_interrupt(uint32_t ul_pin)
{
        Pio *p_pio = pio_get_pin_group(ul_pin);

        p_pio->PIO_IDR = 1 << (ul_pin & 0x1F);
}


Pio *pio_get_pin_group(uint32_t ul_pin)
{
        Pio *p_pio;

#if (SAM4C || SAM4CP)
#  ifdef ID_PIOD
        if (ul_pin > PIO_PC9_IDX) {
                p_pio = PIOD;
        } else if (ul_pin > PIO_PB31_IDX) {
#  else
        if  (ul_pin > PIO_PB31_IDX) {
#  endif
                p_pio = PIOC;
        } else {
                p_pio = (Pio *)((uint32_t)PIOA + (PIO_DELTA * (ul_pin >> 5)));
        }
#elif (SAM4CM)
        if (ul_pin > PIO_PB21_IDX) {
                p_pio = PIOC;
        } else {
                p_pio = (Pio *)((uint32_t)PIOA + (PIO_DELTA * (ul_pin >> 5)));
        }
#else
        p_pio = (Pio *)((uint32_t)PIOA + (PIO_DELTA * (ul_pin >> 5)));
#endif
        return p_pio;
}

uint32_t pio_get_pin_group_id(uint32_t ul_pin)
{
        uint32_t ul_id;

#if (SAM4C || SAM4CP)
#  ifdef ID_PIOD
        if (ul_pin > PIO_PC9_IDX) {
                ul_id = ID_PIOD;
        } else if (ul_pin > PIO_PB31_IDX) {
#  else
        if (ul_pin > PIO_PB31_IDX) {
#  endif
                ul_id = ID_PIOC;
        } else {
                ul_id = ID_PIOA + (ul_pin >> 5);
        }
#elif (SAM4CM)
        if (ul_pin > PIO_PB21_IDX) {
                ul_id = ID_PIOC;
        } else {
                ul_id = ID_PIOA + (ul_pin >> 5);
        }
#elif (SAMV70 || SAMV71 || SAME70 || SAMS70)
        ul_id = ID_PIOA + (ul_pin >> 5);

        #ifdef ID_PIOD 
        if (ul_pin >= PIO_PD0_IDX) ul_id = ID_PIOD; 
        #endif
        
        #ifdef ID_PIOE 
        if (ul_pin >= PIO_PE0_IDX) ul_id = ID_PIOE; 
        #endif 
#else
        ul_id = ID_PIOA + (ul_pin >> 5);
#endif
        return ul_id;
}


uint32_t pio_get_pin_group_mask(uint32_t ul_pin)
{
        uint32_t ul_mask = 1 << (ul_pin & 0x1F);
        return ul_mask;
}

#if (SAM3S || SAM4S || SAM4E || SAMV71 || SAMV70 || SAME70 || SAMS70)
/* Capture mode enable flag */
uint32_t pio_capture_enable_flag;

void pio_capture_set_mode(Pio *p_pio, uint32_t ul_mode)
{
        ul_mode &= (~PIO_PCMR_PCEN); /* Disable PIO capture mode */
        p_pio->PIO_PCMR = ul_mode;
}

void pio_capture_enable(Pio *p_pio)
{
        p_pio->PIO_PCMR |= PIO_PCMR_PCEN;
        pio_capture_enable_flag = true;
}

void pio_capture_disable(Pio *p_pio)
{
        p_pio->PIO_PCMR &= (~PIO_PCMR_PCEN);
        pio_capture_enable_flag = false;
}

uint32_t pio_capture_read(const Pio *p_pio, uint32_t *pul_data)
{
        /* Check if the data is ready */
        if ((p_pio->PIO_PCISR & PIO_PCISR_DRDY) == 0) {
                return 1;
        }

        /* Read data */
        *pul_data = p_pio->PIO_PCRHR;
        return 0;
}

void pio_capture_enable_interrupt(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_PCISR;
        p_pio->PIO_PCIER = ul_mask;
}

void pio_capture_disable_interrupt(Pio *p_pio, const uint32_t ul_mask)
{
        p_pio->PIO_PCIDR = ul_mask;
}

uint32_t pio_capture_get_interrupt_status(const Pio *p_pio)
{
        return p_pio->PIO_PCISR;
}

uint32_t pio_capture_get_interrupt_mask(const Pio *p_pio)
{
        return p_pio->PIO_PCIMR;
}
#if !(SAMV71 || SAMV70 || SAME70 || SAMS70)

Pdc *pio_capture_get_pdc_base(const Pio *p_pio)
{
        UNUSED(p_pio); /* Stop warning */
        return PDC_PIOA;
}
#endif
#endif

#if (SAM4C || SAM4CP || SAM4CM || SAMG55 || SAMV71 || SAMV70 || SAME70 || SAMS70)

void pio_set_io_drive(Pio *p_pio, uint32_t ul_line,
                enum pio_io_drive_mode mode)
{
        p_pio->PIO_DRIVER &= ~(1 << ul_line);
        p_pio->PIO_DRIVER |= mode << ul_line;
}
#endif