Data Structures
struct	GPTConfig
	Driver configuration structure. More...

struct	GPTDriver
	Structure representing a GPT driver. More...

Functions
static void	gpt_lld_serve_interrupt (GPTDriver *gptp)
	Shared IRQ handler. More...

	OSAL_IRQ_HANDLER (KINETIS_PIT0_IRQ_VECTOR)
	PIT1 interrupt handler. More...

	OSAL_IRQ_HANDLER (KINETIS_PIT1_IRQ_VECTOR)
	PIT1 interrupt handler. More...

	OSAL_IRQ_HANDLER (KINETIS_PIT2_IRQ_VECTOR)
	PIT2 interrupt handler. More...

	OSAL_IRQ_HANDLER (KINETIS_PIT3_IRQ_VECTOR)
	PIT3 interrupt handler. More...

	OSAL_IRQ_HANDLER (KINETIS_PIT_IRQ_VECTOR)
	Common PIT interrupt handler. More...

Variables
GPTDriver	GPTD1
	GPTD1 driver identifier. More...

GPTDriver	GPTD2
	GPTD2 driver identifier. More...

GPTDriver	GPTD3
	GPTD3 driver identifier. More...

GPTDriver	GPTD4
	GPTD4 driver identifier. More...

static uint8_t	active_channels = 0

static const uint32_t	tif_flags [] = { LPIT_MSR_TIF0(1), LPIT_MSR_TIF1(1), LPIT_MSR_TIF2(1), LPIT_MSR_TIF3(1) }

static const uint32_t	mier_flags [] = { LPIT_MIER_TIE0(1), LPIT_MIER_TIE1(1), LPIT_MIER_TIE2(1), LPIT_MIER_TIE3(1) }

gptfreq_t	GPTConfig::frequency
	Timer clock in Hz. More...

gptcallback_t	GPTConfig::callback
	Timer callback pointer. More...

uint32_t	GPTConfig::cr2
	TIM CR2 register initialization data. More...

uint32_t	GPTConfig::dier
	TIM DIER register initialization data. More...

gptstate_t	GPTDriver::state
	Driver state. More...

const GPTConfig *	GPTDriver::config
	Current configuration data. More...

GPT_DRIVER_EXT_FIELDS uint32_t	GPTDriver::clock
	Timer base clock. More...

int32_t	GPTDriver::channelIndex
	Channel index. More...

struct PIT_CHANNEL *	GPTDriver::channel
	Channel structure in PIT registers block. More...

Configuration options
typedef uint32_t	gptfreq_t
	GPT frequency type. More...

typedef uint32_t	gptcnt_t
	GPT counter type. More...

GPTDriver	GPTD1
	GPTD1 driver identifier. More...

GPTDriver	GPTD2
	GPTD2 driver identifier. More...

GPTDriver	GPTD3
	GPTD3 driver identifier. More...

GPTDriver	GPTD4
	GPTD4 driver identifier. More...

void	gpt_lld_init (void)
	Low level GPT driver initialization. More...

void	gpt_lld_start (GPTDriver *gptp)
	Configures and activates the GPT peripheral. More...

void	gpt_lld_stop (GPTDriver *gptp)
	Deactivates the GPT peripheral. More...

void	gpt_lld_start_timer (GPTDriver *gptp, gptcnt_t interval)
	Starts the timer in continuous mode. More...

void	gpt_lld_stop_timer (GPTDriver *gptp)
	Stops the timer. More...

void	gpt_lld_polled_delay (GPTDriver *gptp, gptcnt_t interval)
	Starts the timer in one shot mode and waits for completion. More...

Detailed Description

Typedef Documentation

◆ gptcnt_t

typedef uint32_t gptcnt_t

GPT counter type.

Definition at line 201 of file hal_gpt_lld.h.

◆ gptfreq_t

typedef uint32_t gptfreq_t

GPT frequency type.

Definition at line 196 of file hal_gpt_lld.h.

Function Documentation

◆ gpt_lld_init()

void gpt_lld_init ( void )

Low level GPT driver initialization.

@notapi

Definition at line 220 of file hal_gpt_lld.c.

                         {
  
 #if KINETIS_GPT_USE_PIT0
   /* Driver initialization.*/
 #ifdef KE1xF
   GPTD1.channelIndex = 0;
 #else
   GPTD1.channel = &PIT->CHANNEL[0];
 #endif
   gptObjectInit(&GPTD1);
 #endif
  
 #if KINETIS_GPT_USE_PIT1
   /* Driver initialization.*/
 #ifdef KE1xF
   GPTD2.channelIndex = 1;
 #else
   GPTD2.channel = &PIT->CHANNEL[1];
 #endif
   gptObjectInit(&GPTD2);
 #endif
  
 #if KINETIS_GPT_USE_PIT2
   /* Driver initialization.*/
 #ifdef KE1xF
   GPTD3.channelIndex = 2;
 #else
   GPTD3.channel =  &PIT->CHANNEL[2];
 #endif
   gptObjectInit(&GPTD3);
 #endif
  
 #if KINETIS_GPT_USE_PIT3
   /* Driver initialization.*/
 #ifdef KE1xF
   GPTD4.channelIndex = 3;
 #else
   GPTD4.channel =  &PIT->CHANNEL[3];
 #endif
   gptObjectInit(&GPTD4);
 #endif
 }

◆ gpt_lld_polled_delay()

void gpt_lld_polled_delay	(	GPTDriver *	gptp,
		gptcnt_t	interval
	)

Starts the timer in one shot mode and waits for completion.

This function specifically polls the timer waiting for completion in order to not have extra delays caused by interrupt servicing, this function is only recommended for short delays.

Parameters

[in]	gptp	pointer to the `GPTDriver` object
[in]	interval	time interval in ticks

@notapi

Definition at line 449 of file hal_gpt_lld.c.

                                                               {
 #ifdef KE1xF
   /* Disable timer and disable interrupts */
   PIT->CHANNEL[gptp->channelIndex].TCTRL = 0;
  
   PIT->MSR |= tif_flags[gptp->channelIndex];
  
   /* Set the interval */
   PIT->CHANNEL[gptp->channelIndex].TVAL = (gptp->clock / gptp->config->frequency) * interval;
  
   PIT->CHANNEL[gptp->channelIndex].TCTRL = LPIT_TCTRL_T_EN(1);
  
   while (!(PIT->MSR & tif_flags[gptp->channelIndex]))
     ;
   /* Disable timer and disable interrupts */
   PIT->CHANNEL[gptp->channelIndex].TCTRL = 0;
 #else
   struct PIT_CHANNEL *channel = gptp->channel;
  
   /* Disable timer and disable interrupts */
   channel->TCTRL = 0;
  
   /* Clear the interrupt flag */
   channel->TFLG |= PIT_TFLGn_TIF;
  
   /* Set the interval */
   channel->LDVAL = (gptp->clock / gptp->config->frequency) * interval;
  
   /* Enable Timer but keep interrupts disabled */
   channel->TCTRL = PIT_TCTRLn_TEN;
  
   /* Wait for the interrupt flag to be set */
   while (!(channel->TFLG & PIT_TFLGn_TIF))
     ;
   /* Disable timer and disable interrupts */
   channel->TCTRL = 0;
 #endif
 }

◆ gpt_lld_serve_interrupt()

static void gpt_lld_serve_interrupt ( GPTDriver * gptp )

static

Shared IRQ handler.

Parameters

[in] gptp pointer to a GPTDriver object

Definition at line 92 of file hal_gpt_lld.c.

                                                      {
  
   /* Clear the interrupt */
 #ifdef KE1xF
   PIT->MSR |= tif_flags[gptp->channelIndex];
 #else
   gptp->channel->TFLG |= PIT_TFLGn_TIF;
 #endif
  
   if (gptp->state == GPT_ONESHOT) {
     gptp->state = GPT_READY;                /* Back in GPT_READY state.     */
     gpt_lld_stop_timer(gptp);               /* Timer automatically stopped. */
   }
   gptp->config->callback(gptp);
 }

Referenced by OSAL_IRQ_HANDLER().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gpt_lld_start()

void gpt_lld_start ( GPTDriver * gptp )

Configures and activates the GPT peripheral.

Parameters

[in] gptp pointer to the GPTDriver object

@notapi

Definition at line 270 of file hal_gpt_lld.c.

                                     {
   uint16_t psc;
  
   if (gptp->state == GPT_STOP) {
 #ifdef KE1xF
     /* Clock activation.*/
     PCC->CLKCFG[PCC_LPIT0_INDEX] |= PCC_CLKCFG_CGC(1);
     //SCG->FIRCDIV = SCG_FIRCDIV_FIRCDIV2(1) | SCG_FIRCDIV_FIRCDIV1(1);
     PCC->CLKCFG[PCC_LPIT0_INDEX] = (PCC->CLKCFG[PCC_LPIT0_INDEX] & ~PCC_CLKCFG_PCS_MASK) | PCC_CLKCFG_PCS(6/*SCGPCLK System PLL clock*/);
 #else
     /* Clock activation.*/
     SIM->SCGC6 |= SIM_SCGC6_PIT;
 #endif
     gptp->clock = KINETIS_SPLL_DIV2_FREQENCY/*KINETIS_SYSCLK_FREQUENCY*/;
  
 #if !KINETIS_HAS_PIT_COMMON_IRQ
  
 #if KINETIS_GPT_USE_PIT0
     if (&GPTD1 == gptp) {
       nvicEnableVector(PITChannel0_IRQn, KINETIS_GPT_PIT0_IRQ_PRIORITY);
     }
 #endif
 #if KINETIS_GPT_USE_PIT1
     if (&GPTD2 == gptp) {
       nvicEnableVector(PITChannel1_IRQn, KINETIS_GPT_PIT1_IRQ_PRIORITY);
     }
 #endif
 #if KINETIS_GPT_USE_PIT2
     if (&GPTD3 == gptp) {
       nvicEnableVector(PITChannel2_IRQn, KINETIS_GPT_PIT2_IRQ_PRIORITY);
     }
 #endif
 #if KINETIS_GPT_USE_PIT3
     if (&GPTD4 == gptp) {
       nvicEnableVector(PITChannel3_IRQn, KINETIS_GPT_PIT3_IRQ_PRIORITY);
     }
 #endif
  
 #else /* !KINETIS_HAS_PIT_COMMON_IRQ */
     nvicEnableVector(PIT_IRQn, KINETIS_GPT_PIT_IRQ_PRIORITY);
     active_channels++;
 #endif /* !KINETIS_HAS_PIT_COMMON_IRQ */
   }
  
   /* Prescaler value calculation.*/
   psc = (uint16_t)((gptp->clock / gptp->config->frequency) - 1);
   osalDbgAssert(((uint32_t)(psc + 1) * gptp->config->frequency) == gptp->clock,
                 "invalid frequency");
  
 #ifdef KE1xF
   /* Enable the PIT */
   PIT->MCR |= LPIT_MCR_M_CEN(1);
 #else
   /* Enable the PIT */
   PIT->MCR = 0;
 #endif
 }

◆ gpt_lld_start_timer()

void gpt_lld_start_timer	(	GPTDriver *	gptp,
		gptcnt_t	interval
	)

Starts the timer in continuous mode.

Parameters

[in]	gptp	pointer to the `GPTDriver` object
[in]	interval	period in ticks

@notapi

Definition at line 397 of file hal_gpt_lld.c.

                                                              {
 #ifdef KE1xF
   /* Clear pending interrupts */
   PIT->MSR |= tif_flags[gptp->channelIndex];
  
   /* Set the interval */
   gpt_lld_change_interval(gptp, interval);
   
   /* Enable interrupts */
   PIT->MIER |= mier_flags[gptp->channelIndex];
   /* Start the timer */
   PIT->CHANNEL[gptp->channelIndex].TCTRL |= LPIT_TCTRL_T_EN(1);
 #else
   /* Clear pending interrupts */
   gptp->channel->TFLG |= PIT_TFLGn_TIF;
  
   /* Set the interval */
   gpt_lld_change_interval(gptp, interval);
   
   /* Start the timer */
   gptp->channel->TCTRL |= PIT_TCTRLn_TIE | PIT_TCTRLn_TEN;
 #endif
 }

◆ gpt_lld_stop()

void gpt_lld_stop ( GPTDriver * gptp )

Deactivates the GPT peripheral.

Parameters

[in] gptp pointer to the GPTDriver object

@notapi

Definition at line 335 of file hal_gpt_lld.c.

                                    {
  
   if (gptp->state == GPT_READY) {
 #ifdef KE1xF
     PCC->CLKCFG[PCC_LPIT0_INDEX] &= ~PCC_CLKCFG_CGC(1);
  
     /* Disable the channel */
     PIT->CHANNEL[gptp->channelIndex].TCTRL = 0;
     
     /* Disable interrupts */
     PIT->MIER &= ~mier_flags[gptp->channelIndex];
  
     /* Clear pending interrupts */
     PIT->MSR |= tif_flags[gptp->channelIndex];
 #else
     SIM->SCGC6 &= ~SIM_SCGC6_PIT;
  
     /* Disable the channel */
     gptp->channel->TCTRL = 0;
  
     /* Clear pending interrupts */
     gptp->channel->TFLG |= PIT_TFLGn_TIF;
 #endif
  
 #if !KINETIS_HAS_PIT_COMMON_IRQ
  
 #if KINETIS_GPT_USE_PIT0
     if (&GPTD1 == gptp) {
       nvicDisableVector(PITChannel0_IRQn);
     }
 #endif
 #if KINETIS_GPT_USE_PIT1
     if (&GPTD2 == gptp) {
       nvicDisableVector(PITChannel1_IRQn);
     }
 #endif
 #if KINETIS_GPT_USE_PIT2
     if (&GPTD3 == gptp) {
       nvicDisableVector(PITChannel2_IRQn);
     }
 #endif
 #if KINETIS_GPT_USE_PIT3
     if (&GPTD4 == gptp) {
       nvicDisableVector(PITChannel3_IRQn);
     }
 #endif
  
 #else /* !KINETIS_HAS_PIT_COMMON_IRQ */
     if(--active_channels == 0)
       nvicDisableVector(PIT_IRQn);
 #endif /* !KINETIS_HAS_PIT_COMMON_IRQ */
   }
 }

◆ gpt_lld_stop_timer()

void gpt_lld_stop_timer ( GPTDriver * gptp )

Stops the timer.

Parameters

[in] gptp pointer to the GPTDriver object

@notapi

Definition at line 428 of file hal_gpt_lld.c.

                                          {
 #ifdef KE1xF
   /* Stop the timer */
   PIT->CHANNEL[gptp->channelIndex].TCTRL = 0;
 #else
   /* Stop the timer */
   gptp->channel->TCTRL = 0;
 #endif
 }

Referenced by gpt_lld_serve_interrupt().

Here is the caller graph for this function:

◆ OSAL_IRQ_HANDLER() [1/5]

OSAL_IRQ_HANDLER ( KINETIS_PIT0_IRQ_VECTOR )

PIT1 interrupt handler.

@isr

Definition at line 120 of file hal_gpt_lld.c.

                                           {
   OSAL_IRQ_PROLOGUE();
   gpt_lld_serve_interrupt(&GPTD1);
   OSAL_IRQ_EPILOGUE();
 }

Here is the call graph for this function:

◆ OSAL_IRQ_HANDLER() [2/5]

OSAL_IRQ_HANDLER ( KINETIS_PIT1_IRQ_VECTOR )

PIT1 interrupt handler.

@isr

Definition at line 133 of file hal_gpt_lld.c.

                                           {
   OSAL_IRQ_PROLOGUE();
   gpt_lld_serve_interrupt(&GPTD2);
   OSAL_IRQ_EPILOGUE();
 }

Here is the call graph for this function:

◆ OSAL_IRQ_HANDLER() [3/5]

OSAL_IRQ_HANDLER ( KINETIS_PIT2_IRQ_VECTOR )

PIT2 interrupt handler.

@isr

Definition at line 146 of file hal_gpt_lld.c.

                                           {
   OSAL_IRQ_PROLOGUE();
   gpt_lld_serve_interrupt(&GPTD3);
   OSAL_IRQ_EPILOGUE();
 }

Here is the call graph for this function:

◆ OSAL_IRQ_HANDLER() [4/5]

OSAL_IRQ_HANDLER ( KINETIS_PIT3_IRQ_VECTOR )

PIT3 interrupt handler.

@isr

Definition at line 159 of file hal_gpt_lld.c.

                                           {
   OSAL_IRQ_PROLOGUE();
   gpt_lld_serve_interrupt(&GPTD4);
   OSAL_IRQ_EPILOGUE();
 }

Here is the call graph for this function:

◆ OSAL_IRQ_HANDLER() [5/5]

OSAL_IRQ_HANDLER ( KINETIS_PIT_IRQ_VECTOR )

Common PIT interrupt handler.

@isr

Definition at line 172 of file hal_gpt_lld.c.

                                          {
   OSAL_IRQ_PROLOGUE();
 #if KINETIS_GPT_USE_PIT0
 #ifdef KE1xF
   if(PIT->MSR & LPIT_MSR_TIF0(1))
 #else
   if(GPTD1.channel->TFLG & PIT_TFLGn_TIF)
 #endif
     gpt_lld_serve_interrupt(&GPTD1);
 #endif /* KINETIS_GPT_USE_PIT0 */
 #if KINETIS_GPT_USE_PIT1
 #ifdef KE1xF
   if(PIT->MSR & LPIT_MSR_TIF1(1))
 #else
   if(GPTD2.channel->TFLG & PIT_TFLGn_TIF)
 #endif
     gpt_lld_serve_interrupt(&GPTD2);
 #endif /* KINETIS_GPT_USE_PIT1 */
 #if KINETIS_GPT_USE_PIT2
 #ifdef KE1xF
   if(PIT->MSR & LPIT_MSR_TIF2(1))
 #else
   if(GPTD3.channel->TFLG & PIT_TFLGn_TIF)
 #endif
     gpt_lld_serve_interrupt(&GPTD3);
 #endif /* KINETIS_GPT_USE_PIT2 */
 #if KINETIS_GPT_USE_PIT3
 #ifdef KE1xF
   if(PIT->MSR & LPIT_MSR_TIF3(1))
 #else
   if(GPTD4.channel->TFLG & PIT_TFLGn_TIF)
 #endif
     gpt_lld_serve_interrupt(&GPTD4);
 #endif /* KINETIS_GPT_USE_PIT3 */
   OSAL_IRQ_EPILOGUE();
 }