tc.c

Go to the documentation of this file.

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


#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef TC_WPMR_WPKEY_PASSWD
#define TC_WPMR_WPKEY_PASSWD TC_WPMR_WPKEY((uint32_t)0x54494D)
#endif

void tc_init(
        Tc *p_tc,
        uint32_t ul_channel,
        uint32_t ul_mode)
{
    TcChannel *tc_channel;
 
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
    tc_channel = p_tc->TC_CHANNEL + ul_channel;
 
    /*  Disable TC clock. */
    tc_channel->TC_CCR = TC_CCR_CLKDIS;
 
    /*  Disable interrupts. */
    tc_channel->TC_IDR = 0xFFFFFFFF;
 
    /*  Clear status register. */
    tc_channel->TC_SR;
 
    /*  Set mode. */
    tc_channel->TC_CMR = ul_mode;
}

void tc_sync_trigger(
        Tc *p_tc)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    p_tc->TC_BCR = TC_BCR_SYNC;
}

void tc_set_block_mode(
        Tc *p_tc,
        uint32_t ul_blockmode)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    p_tc->TC_BMR = ul_blockmode;
}
 
#if (!SAM3U) || defined(__DOXYGEN__)

uint32_t tc_init_2bit_gray(
        Tc *p_tc,
        uint32_t ul_channel,
        uint32_t ul_steppermode)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    p_tc->TC_CHANNEL[ul_channel].TC_SMMR = ul_steppermode;
    return 0;
}
 
#endif /* (!SAM3U) || defined(__DOXYGEN__) */

void tc_start(
        Tc *p_tc,
        uint32_t ul_channel)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    p_tc->TC_CHANNEL[ul_channel].TC_CCR = TC_CCR_CLKEN | TC_CCR_SWTRG;
}

void tc_stop(
        Tc *p_tc,
        uint32_t ul_channel)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    p_tc->TC_CHANNEL[ul_channel].TC_CCR = TC_CCR_CLKDIS;
}

uint32_t tc_read_cv(
        Tc *p_tc,
        uint32_t ul_channel)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    return p_tc->TC_CHANNEL[ul_channel].TC_CV;
}

uint32_t tc_read_ra(
        Tc *p_tc,
        uint32_t ul_channel)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    return p_tc->TC_CHANNEL[ul_channel].TC_RA;
}

uint32_t tc_read_rb(
        Tc *p_tc,
        uint32_t ul_channel)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    return p_tc->TC_CHANNEL[ul_channel].TC_RB;
}

uint32_t tc_read_rc(
        Tc *p_tc,
        uint32_t ul_channel)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    return p_tc->TC_CHANNEL[ul_channel].TC_RC;
}

void tc_write_ra(
        Tc *p_tc,
        uint32_t ul_channel,
        uint32_t ul_value)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    p_tc->TC_CHANNEL[ul_channel].TC_RA = ul_value;
}

void tc_write_rb(
        Tc *p_tc,
        uint32_t ul_channel,
        uint32_t ul_value)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    p_tc->TC_CHANNEL[ul_channel].TC_RB = ul_value;
}

void tc_write_rc(
        Tc *p_tc,
        uint32_t ul_channel,
        uint32_t ul_value)
{
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
 
    p_tc->TC_CHANNEL[ul_channel].TC_RC = ul_value;
}

void tc_enable_interrupt(
        Tc *p_tc,
        uint32_t ul_channel,
        uint32_t ul_sources)
{
    TcChannel *tc_channel;
 
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
    tc_channel = p_tc->TC_CHANNEL + ul_channel;
    tc_channel->TC_IER = ul_sources;
}

void tc_disable_interrupt(
        Tc *p_tc,
        uint32_t ul_channel,
        uint32_t ul_sources)
{
    TcChannel *tc_channel;
 
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
    tc_channel = p_tc->TC_CHANNEL + ul_channel;
    tc_channel->TC_IDR = ul_sources;
}

uint32_t tc_get_interrupt_mask(
        Tc *p_tc,
        uint32_t ul_channel)
{
    TcChannel *tc_channel;
 
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
    tc_channel = p_tc->TC_CHANNEL + ul_channel;
    return tc_channel->TC_IMR;
}

uint32_t tc_get_status(
        Tc *p_tc,
        uint32_t ul_channel)
{
    TcChannel *tc_channel;
 
    /* Validate inputs. */
    Assert(p_tc);
    Assert(ul_channel <
            (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
            
    tc_channel = p_tc->TC_CHANNEL + ul_channel;
    return tc_channel->TC_SR;
}
 
/* TC divisor used to find the lowest acceptable timer frequency */
#define TC_DIV_FACTOR 65536
 
#if (!SAM4L) && !defined(__DOXYGEN__)
 
#ifndef FREQ_SLOW_CLOCK_EXT
#define FREQ_SLOW_CLOCK_EXT 32768 /* External slow clock frequency (hz) */
#endif

uint32_t tc_find_mck_divisor(
        uint32_t ul_freq,
        uint32_t ul_mck,
        uint32_t *p_uldiv,
        uint32_t *p_ultcclks,
        uint32_t ul_boardmck)
{
    const uint32_t divisors[5] = { 2, 8, 32, 128,
            ul_boardmck / FREQ_SLOW_CLOCK_EXT };
    uint32_t ul_index;
    uint32_t ul_high, ul_low;
 
    /*  Satisfy frequency bound. */
    for (ul_index = 0;
            ul_index < (sizeof(divisors) / sizeof(divisors[0]));
            ul_index++) {
        ul_high = ul_mck / divisors[ul_index];
        ul_low  = ul_high / TC_DIV_FACTOR;
        if (ul_freq > ul_high) {
            return 0;
        } else if (ul_freq >= ul_low) {
            break;
        }
    }
    if (ul_index >= (sizeof(divisors) / sizeof(divisors[0]))) {
        return 0;
    }
 
    /*  Store results. */
    if (p_uldiv) {
        *p_uldiv = divisors[ul_index];
    }
 
    if (p_ultcclks) {
        *p_ultcclks = ul_index;
    }
 
    return 1;
}
 
#endif /* (!SAM4L) */
 
#if (SAM4L) || defined(__DOXYGEN__)
uint32_t tc_find_mck_divisor(
        uint32_t ul_freq,
        uint32_t ul_mck,
        uint32_t *p_uldiv,
        uint32_t *p_ultcclks,
        uint32_t ul_boardmck)
{
    const uint32_t divisors[5] = { 0, 2, 8, 32, 128};
    uint32_t ul_index;
    uint32_t ul_high, ul_low;
 
    UNUSED(ul_boardmck);
 
    /*  Satisfy frequency bound. */
    for (ul_index = 1;
            ul_index < (sizeof(divisors) / sizeof(divisors[0]));
            ul_index++) {
        ul_high = ul_mck / divisors[ul_index];
        ul_low  = ul_high / TC_DIV_FACTOR;
        if (ul_freq > ul_high) {
            return 0;
        } else if (ul_freq >= ul_low) {
            break;
        }
    }
    if (ul_index >= (sizeof(divisors) / sizeof(divisors[0]))) {
        return 0;
    }
 
    /*  Store results. */
    if (p_uldiv) {
        *p_uldiv = divisors[ul_index];
    }
 
    if (p_ultcclks) {
        *p_ultcclks = ul_index;
    }
 
    return 1;
}
 
#endif /* (SAM4L) || defined(__DOXYGEN__) */
 
#if (!SAM4L && !SAMG) || defined(__DOXYGEN__)

void tc_enable_qdec_interrupt(
        Tc *p_tc,
        uint32_t ul_sources)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    p_tc->TC_QIER = ul_sources;
}

void tc_disable_qdec_interrupt(
        Tc *p_tc,
        uint32_t ul_sources)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    p_tc->TC_QIDR = ul_sources;
}

uint32_t tc_get_qdec_interrupt_mask(
        Tc *p_tc)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    return p_tc->TC_QIMR;
}

uint32_t tc_get_qdec_interrupt_status(
        Tc *p_tc)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    return p_tc->TC_QISR;
}
 
#endif /* (!SAM4L && !SAMG) || defined(__DOXYGEN__) */
 
#if (!SAM3U) || defined(__DOXYGEN__)

void tc_set_writeprotect(
        Tc *p_tc,
        uint32_t ul_enable)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    if (ul_enable) {
        p_tc->TC_WPMR = TC_WPMR_WPKEY_PASSWD | TC_WPMR_WPEN;
    } else {
        p_tc->TC_WPMR = TC_WPMR_WPKEY_PASSWD;
    }
}
 
#endif /* (!SAM3U) || defined(__DOXYGEN__) */
 
#if SAM4L || defined(__DOXYGEN__)

uint32_t tc_get_feature(
        Tc *p_tc)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    return p_tc->TC_FEATURES;
}

uint32_t tc_get_version(
        Tc *p_tc)
{
    /* Validate inputs. */
    Assert(p_tc);
    
    return p_tc->TC_VERSION;
}
 
#endif /* SAM4L || defined(__DOXYGEN__) */


#ifdef __cplusplus
}
#endif