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