/**
* @brief Low level HAL driver initialization.
*
* @notapi
*/
void hal_lld_init(void) {
uint32_t n;
/* The system is switched to the RUN0 mode, the default for normal
operations.*/
if (halSPCSetRunMode(SPC5_RUNMODE_RUN0) == OSAL_FAILED) {
SPC5_CLOCK_FAILURE_HOOK();
}
/* PIT_0 clock initialization.*/
halSPCSetPeripheralClockMode(30, SPC5_ME_PCTL_RUN(2) | SPC5_ME_PCTL_LP(2));
/* TB counter enabled for debug and measurements.*/
asm volatile ("li %%r3, 0x4000 \t\n" /* TBEN bit. */
"mtspr 1008, %%r3" /* HID0 register. */
: : : "r3");
/* PIT channel 0 initialization for Kernel ticks, the PIT is configured
to run in DRUN,RUN0...RUN3 and HALT0 modes, the clock is gated in other
modes.*/
INTC_PSR(226) = SPC5_PIT0_IRQ_PRIORITY;
n = SPC5_AC12_DC4_CLK / OSAL_ST_FREQUENCY - 1;
PIT_0.MCR.R = 1; /* Clock enabled, stop while debugging. */
PIT_0.CH[0].LDVAL.R = n;
PIT_0.CH[0].CVAL.R = n;
PIT_0.CH[0].TFLG.R = 1; /* Interrupt flag cleared. */
PIT_0.CH[0].TCTRL.R = 3; /* Timer active, interrupt enabled. */
/* EDMA initialization.*/
// edmaInit();
}
/**
* @brief Low level HAL driver initialization.
*
* @notapi
*/
void hal_lld_init(void) {
uint32_t n;
/* HSM PIT channel 0 initialization for Kernel ticks.*/
n = 100000000 / OSAL_ST_FREQUENCY - 1;
PIT_HSM.MCR.R = 1;
PIT_HSM.TIMER[0].LDVAL.R = n;
PIT_HSM.TIMER[0].CVAL.R = n;
PIT_HSM.TIMER[0].TFLG.R = 1; /* Interrupt flag cleared. */
PIT_HSM.TIMER[0].TCTRL.R = 3; /* Timer active, interrupt enabled. */
/* HSM PIT interrupt vector enabled.*/
INTC_PSR(8) = SPC5_PIT0_IRQ_PRIORITY;
}
/**
* @brief Low level HAL driver initialization.
*
* @notapi
*/
void hal_lld_init(void) {
uint32_t n;
/* The system is switched to the RUN0 mode, the default for normal
operations.*/
if (halSPCSetRunMode(SPC5_RUNMODE_RUN0) == OSAL_FAILED) {
SPC5_CLOCK_FAILURE_HOOK();
}
#if SPC5_HSM_HANDSHAKE == 1
/* Notifies the HSM full clock initialization.*/
HT2HSMF = 2;
#endif
#if SPC5_HSM_HANDSHAKE == 2
/* Notifies the HSM full clock initialization by clearing WF_CC_DONE bit
* Note that clearing a bit in HSM2HTF mailbox is done by writing 1 in the bit
*
* We also clear the CLK_CHG_RDY bit, no longer used
*/
HSM2HTF = WF_CC_DONE | CLK_CHG_RDY;
#endif
/* PIT_0 clock initialization.*/
halSPCSetPeripheralClockMode(30, SPC5_ME_PCTL_RUN(2) | SPC5_ME_PCTL_LP(2));
/* TB counter enabled for debug and measurements.*/
asm volatile ("li %%r3, 0x4000 \t\n" /* TBEN bit. */
"mtspr 1008, %%r3" /* HID0 register. */
: : : "r3");
/* PIT channel 0 initialization for Kernel ticks, the PIT is configured
to run in DRUN,RUN0...RUN3 and HALT0 modes, the clock is gated in other
modes.*/
INTC_PSR(226) = SPC5_PIT0_IRQ_PRIORITY;
n = SPC5_AC12_DC4_CLK / OSAL_ST_FREQUENCY - 1;
PIT_0.MCR.R = 1; /* Clock enabled, stop while debugging. */
PIT_0.TIMER[0].LDVAL.R = n;
PIT_0.TIMER[0].CVAL.R = n;
PIT_0.TIMER[0].TFLG.R = 1; /* Interrupt flag cleared. */
PIT_0.TIMER[0].TCTRL.R = 3; /* Timer active, interrupt enabled. */
/* EDMA initialization.*/
// edmaInit();
}
/**
* @brief Low level ICU driver initialization.
*
* @notapi
*/
void icu_lld_init(void) {
/* Submodules initially all not in use.*/
icu_active_submodules0 = 0;
icu_active_submodules1 = 0;
icu_active_submodules2 = 0;
icu_active_submodules3 = 0;
/* Reset width and period registers.*/
width = 0;
period = 0;
#if SPC5_ICU_USE_SMOD0
/* Driver initialization.*/
icuObjectInit(&ICUD1);
ICUD1.etimerp = &SPC5_ETIMER_0;
ICUD1.smod_number = 0U;
ICUD1.clock = SPC5_ETIMER0_CLK;
#endif
#if SPC5_ICU_USE_SMOD1
/* Driver initialization.*/
icuObjectInit(&ICUD2);
ICUD2.etimerp = &SPC5_ETIMER_0;
ICUD2.smod_number = 1U;
ICUD2.clock = SPC5_ETIMER0_CLK;
#endif
#if SPC5_ICU_USE_SMOD2
/* Driver initialization.*/
icuObjectInit(&ICUD3);
ICUD3.etimerp = &SPC5_ETIMER_0;
ICUD3.smod_number = 2U;
ICUD3.clock = SPC5_ETIMER0_CLK;
#endif
#if SPC5_ICU_USE_SMOD3
/* Driver initialization.*/
icuObjectInit(&ICUD4);
ICUD4.etimerp = &SPC5_ETIMER_0;
ICUD4.smod_number = 3U;
ICUD4.clock = SPC5_ETIMER0_CLK;
#endif
#if SPC5_ICU_USE_SMOD4
/* Driver initialization.*/
icuObjectInit(&ICUD5);
ICUD5.etimerp = &SPC5_ETIMER_0;
ICUD5.smod_number = 4U;
ICUD5.clock = SPC5_ETIMER0_CLK;
#endif
#if SPC5_ICU_USE_SMOD5
/* Driver initialization.*/
icuObjectInit(&ICUD6);
ICUD6.etimerp = &SPC5_ETIMER_0;
ICUD6.smod_number = 5U;
ICUD6.clock = SPC5_ETIMER0_CLK;
#endif
#if SPC5_ICU_USE_SMOD6
/* Driver initialization.*/
icuObjectInit(&ICUD7);
ICUD7.etimerp = &SPC5_ETIMER_1;
ICUD7.smod_number = 0U;
ICUD7.clock = SPC5_ETIMER1_CLK;
#endif
#if SPC5_ICU_USE_SMOD7
/* Driver initialization.*/
icuObjectInit(&ICUD8);
ICUD8.etimerp = &SPC5_ETIMER_1;
ICUD8.smod_number = 1U;
ICUD8.clock = SPC5_ETIMER1_CLK;
#endif
#if SPC5_ICU_USE_SMOD8
/* Driver initialization.*/
icuObjectInit(&ICUD9);
ICUD9.etimerp = &SPC5_ETIMER_1;
ICUD9.smod_number = 2U;
ICUD9.clock = SPC5_ETIMER1_CLK;
#endif
#if SPC5_ICU_USE_SMOD9
/* Driver initialization.*/
icuObjectInit(&ICUD10);
ICUD10.etimerp = &SPC5_ETIMER_1;
ICUD10.smod_number = 3U;
ICUD10.clock = SPC5_ETIMER1_CLK;
#endif
#if SPC5_ICU_USE_SMOD10
/* Driver initialization.*/
icuObjectInit(&ICUD11);
ICUD11.etimerp = &SPC5_ETIMER_1;
ICUD11.smod_number = 4U;
ICUD11.clock = SPC5_ETIMER1_CLK;
#endif
#if SPC5_ICU_USE_SMOD11
/* Driver initialization.*/
icuObjectInit(&ICUD12);
ICUD12.etimerp = &SPC5_ETIMER_1;
ICUD12.smod_number = 5U;
ICUD12.clock = SPC5_ETIMER1_CLK;
#endif
#if SPC5_ICU_USE_SMOD12
/* Driver initialization.*/
icuObjectInit(&ICUD13);
ICUD13.etimerp = &SPC5_ETIMER_2;
ICUD13.smod_number = 0U;
ICUD13.clock = SPC5_ETIMER2_CLK;
#endif
#if SPC5_ICU_USE_SMOD13
/* Driver initialization.*/
icuObjectInit(&ICUD14);
ICUD14.etimerp = &SPC5_ETIMER_2;
ICUD14.smod_number = 1U;
ICUD14.clock = SPC5_ETIMER2_CLK;
#endif
#if SPC5_ICU_USE_SMOD14
/* Driver initialization.*/
icuObjectInit(&ICUD15);
ICUD15.etimerp = &SPC5_ETIMER_2;
ICUD15.smod_number = 2U;
ICUD15.clock = SPC5_ETIMER2_CLK;
#endif
#if SPC5_ICU_USE_SMOD15
/* Driver initialization.*/
icuObjectInit(&ICUD16);
ICUD16.etimerp = &SPC5_ETIMER_2;
ICUD16.smod_number = 3U;
ICUD16.clock = SPC5_ETIMER2_CLK;
#endif
#if SPC5_ICU_USE_SMOD16
/* Driver initialization.*/
icuObjectInit(&ICUD17);
ICUD17.etimerp = &SPC5_ETIMER_2;
ICUD17.smod_number = 4U;
ICUD17.clock = SPC5_ETIMER2_CLK;
#endif
#if SPC5_ICU_USE_SMOD17
/* Driver initialization.*/
icuObjectInit(&ICUD18);
ICUD18.etimerp = &SPC5_ETIMER_2;
ICUD18.smod_number = 5U;
ICUD18.clock = SPC5_ETIMER2_CLK;
#endif
#if SPC5_ICU_USE_SMOD18
/* Driver initialization.*/
icuObjectInit(&ICUD19);
ICUD13.etimerp = &SPC5_ETIMER_3;
ICUD13.smod_number = 0U;
ICUD13.clock = SPC5_ETIMER3_CLK;
#endif
#if SPC5_ICU_USE_SMOD19
/* Driver initialization.*/
icuObjectInit(&ICUD20);
ICUD14.etimerp = &SPC5_ETIMER_3;
ICUD14.smod_number = 1U;
ICUD14.clock = SPC5_ETIMER3_CLK;
#endif
#if SPC5_ICU_USE_SMOD20
/* Driver initialization.*/
icuObjectInit(&ICUD21);
ICUD15.etimerp = &SPC5_ETIMER_3;
ICUD15.smod_number = 2U;
ICUD15.clock = SPC5_ETIMER3_CLK;
#endif
#if SPC5_ICU_USE_SMOD21
/* Driver initialization.*/
icuObjectInit(&ICUD22);
ICUD16.etimerp = &SPC5_ETIMER_3;
ICUD16.smod_number = 3U;
ICUD16.clock = SPC5_ETIMER3_CLK;
#endif
#if SPC5_ICU_USE_SMOD22
/* Driver initialization.*/
icuObjectInit(&ICUD23);
ICUD17.etimerp = &SPC5_ETIMER_3;
ICUD17.smod_number = 4U;
ICUD17.clock = SPC5_ETIMER3_CLK;
#endif
#if SPC5_ICU_USE_SMOD23
/* Driver initialization.*/
icuObjectInit(&ICUD24);
ICUD18.etimerp = &SPC5_ETIMER_3;
ICUD18.smod_number = 5U;
ICUD18.clock = SPC5_ETIMER3_CLK;
#endif
#if SPC5_ICU_USE_ETIMER0
INTC_PSR(SPC5_ETIMER0_TC0IR_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
INTC_PSR(SPC5_ETIMER0_TC1IR_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
INTC_PSR(SPC5_ETIMER0_TC2IR_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
INTC_PSR(SPC5_ETIMER0_TC3IR_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
INTC_PSR(SPC5_ETIMER0_TC4IR_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
INTC_PSR(SPC5_ETIMER0_TC5IR_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
INTC_PSR(SPC5_ETIMER0_WTIF_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
INTC_PSR(SPC5_ETIMER0_RCF_NUMBER) = SPC5_ICU_ETIMER0_PRIORITY;
#endif
#if SPC5_ICU_USE_ETIMER1
INTC_PSR(SPC5_ETIMER1_TC0IR_NUMBER) = SPC5_ICU_ETIMER1_PRIORITY;
INTC_PSR(SPC5_ETIMER1_TC1IR_NUMBER) = SPC5_ICU_ETIMER1_PRIORITY;
INTC_PSR(SPC5_ETIMER1_TC2IR_NUMBER) = SPC5_ICU_ETIMER1_PRIORITY;
INTC_PSR(SPC5_ETIMER1_TC3IR_NUMBER) = SPC5_ICU_ETIMER1_PRIORITY;
INTC_PSR(SPC5_ETIMER1_TC4IR_NUMBER) = SPC5_ICU_ETIMER1_PRIORITY;
INTC_PSR(SPC5_ETIMER1_TC5IR_NUMBER) = SPC5_ICU_ETIMER1_PRIORITY;
INTC_PSR(SPC5_ETIMER1_RCF_NUMBER) = SPC5_ICU_ETIMER1_PRIORITY;
#endif
#if SPC5_ICU_USE_ETIMER2
INTC_PSR(SPC5_ETIMER2_TC0IR_NUMBER) = SPC5_ICU_ETIMER2_PRIORITY;
INTC_PSR(SPC5_ETIMER2_TC1IR_NUMBER) = SPC5_ICU_ETIMER2_PRIORITY;
INTC_PSR(SPC5_ETIMER2_TC2IR_NUMBER) = SPC5_ICU_ETIMER2_PRIORITY;
INTC_PSR(SPC5_ETIMER2_TC3IR_NUMBER) = SPC5_ICU_ETIMER2_PRIORITY;
INTC_PSR(SPC5_ETIMER2_TC4IR_NUMBER) = SPC5_ICU_ETIMER2_PRIORITY;
INTC_PSR(SPC5_ETIMER2_TC5IR_NUMBER) = SPC5_ICU_ETIMER2_PRIORITY;
INTC_PSR(SPC5_ETIMER2_RCF_NUMBER) = SPC5_ICU_ETIMER2_PRIORITY;
#endif
#if SPC5_ICU_USE_ETIMER3
INTC_PSR(SPC5_ETIMER3_TC0IR_NUMBER) = SPC5_ICU_ETIMER3_PRIORITY;
INTC_PSR(SPC5_ETIMER3_TC1IR_NUMBER) = SPC5_ICU_ETIMER3_PRIORITY;
INTC_PSR(SPC5_ETIMER3_TC2IR_NUMBER) = SPC5_ICU_ETIMER3_PRIORITY;
INTC_PSR(SPC5_ETIMER3_TC3IR_NUMBER) = SPC5_ICU_ETIMER3_PRIORITY;
INTC_PSR(SPC5_ETIMER3_TC4IR_NUMBER) = SPC5_ICU_ETIMER3_PRIORITY;
INTC_PSR(SPC5_ETIMER3_TC5IR_NUMBER) = SPC5_ICU_ETIMER3_PRIORITY;
INTC_PSR(SPC5_ETIMER3_RCF_NUMBER) = SPC5_ICU_ETIMER3_PRIORITY;
#endif
}
/**
* @brief Low level serial driver initialization.
*
* @notapi
*/
void sd_lld_init(void) {
#if SPC5_SERIAL_USE_LINFLEX0
sdObjectInit(&SD1, NULL, notify1);
SD1.linflexp = &SPC5_LINFLEX0;
INTC_PSR(SPC5_LINFLEX0_RXI_NUMBER) = SPC5_SERIAL_LINFLEX0_PRIORITY;
INTC_PSR(SPC5_LINFLEX0_TXI_NUMBER) = SPC5_SERIAL_LINFLEX0_PRIORITY;
INTC_PSR(SPC5_LINFLEX0_ERR_NUMBER) = SPC5_SERIAL_LINFLEX0_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX1
sdObjectInit(&SD2, NULL, notify2);
SD2.linflexp = &SPC5_LINFLEX1;
INTC_PSR(SPC5_LINFLEX1_RXI_NUMBER) = SPC5_SERIAL_LINFLEX1_PRIORITY;
INTC_PSR(SPC5_LINFLEX1_TXI_NUMBER) = SPC5_SERIAL_LINFLEX1_PRIORITY;
INTC_PSR(SPC5_LINFLEX1_ERR_NUMBER) = SPC5_SERIAL_LINFLEX1_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX2
sdObjectInit(&SD3, NULL, notify3);
SD3.linflexp = &SPC5_LINFLEX2;
INTC_PSR(SPC5_LINFLEX2_RXI_NUMBER) = SPC5_SERIAL_LINFLEX2_PRIORITY;
INTC_PSR(SPC5_LINFLEX2_TXI_NUMBER) = SPC5_SERIAL_LINFLEX2_PRIORITY;
INTC_PSR(SPC5_LINFLEX2_ERR_NUMBER) = SPC5_SERIAL_LINFLEX2_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX3
sdObjectInit(&SD4, NULL, notify4);
SD4.linflexp = &SPC5_LINFLEX3;
INTC_PSR(SPC5_LINFLEX3_RXI_NUMBER) = SPC5_SERIAL_LINFLEX3_PRIORITY;
INTC_PSR(SPC5_LINFLEX3_TXI_NUMBER) = SPC5_SERIAL_LINFLEX3_PRIORITY;
INTC_PSR(SPC5_LINFLEX3_ERR_NUMBER) = SPC5_SERIAL_LINFLEX3_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX4
sdObjectInit(&SD5, NULL, notify5);
SD5.linflexp = &SPC5_LINFLEX4;
INTC_PSR(SPC5_LINFLEX4_RXI_NUMBER) = SPC5_SERIAL_LINFLEX4_PRIORITY;
INTC_PSR(SPC5_LINFLEX4_TXI_NUMBER) = SPC5_SERIAL_LINFLEX4_PRIORITY;
INTC_PSR(SPC5_LINFLEX4_ERR_NUMBER) = SPC5_SERIAL_LINFLEX4_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX5
sdObjectInit(&SD6, NULL, notify6);
SD6.linflexp = &SPC5_LINFLEX5;
INTC_PSR(SPC5_LINFLEX5_RXI_NUMBER) = SPC5_SERIAL_LINFLEX5_PRIORITY;
INTC_PSR(SPC5_LINFLEX5_TXI_NUMBER) = SPC5_SERIAL_LINFLEX5_PRIORITY;
INTC_PSR(SPC5_LINFLEX5_ERR_NUMBER) = SPC5_SERIAL_LINFLEX5_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX6
sdObjectInit(&SD7, NULL, notify7);
SD7.linflexp = &SPC5_LINFLEX6;
INTC_PSR(SPC5_LINFLEX6_RXI_NUMBER) = SPC5_SERIAL_LINFLEX6_PRIORITY;
INTC_PSR(SPC5_LINFLEX6_TXI_NUMBER) = SPC5_SERIAL_LINFLEX6_PRIORITY;
INTC_PSR(SPC5_LINFLEX6_ERR_NUMBER) = SPC5_SERIAL_LINFLEX6_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX7
sdObjectInit(&SD8, NULL, notify8);
SD8.linflexp = &SPC5_LINFLEX7;
INTC_PSR(SPC5_LINFLEX7_RXI_NUMBER) = SPC5_SERIAL_LINFLEX7_PRIORITY;
INTC_PSR(SPC5_LINFLEX7_TXI_NUMBER) = SPC5_SERIAL_LINFLEX7_PRIORITY;
INTC_PSR(SPC5_LINFLEX7_ERR_NUMBER) = SPC5_SERIAL_LINFLEX7_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX8
sdObjectInit(&SD9, NULL, notify9);
SD9.linflexp = &SPC5_LINFLEX8;
INTC_PSR(SPC5_LINFLEX8_RXI_NUMBER) = SPC5_SERIAL_LINFLEX8_PRIORITY;
INTC_PSR(SPC5_LINFLEX8_TXI_NUMBER) = SPC5_SERIAL_LINFLEX8_PRIORITY;
INTC_PSR(SPC5_LINFLEX8_ERR_NUMBER) = SPC5_SERIAL_LINFLEX8_PRIORITY;
#endif
#if SPC5_SERIAL_USE_LINFLEX9
sdObjectInit(&SD10, NULL, notify10);
SD10.linflexp = &SPC5_LINFLEX9;
INTC_PSR(SPC5_LINFLEX9_RXI_NUMBER) = SPC5_SERIAL_LINFLEX9_PRIORITY;
INTC_PSR(SPC5_LINFLEX9_TXI_NUMBER) = SPC5_SERIAL_LINFLEX9_PRIORITY;
INTC_PSR(SPC5_LINFLEX9_ERR_NUMBER) = SPC5_SERIAL_LINFLEX9_PRIORITY;
#endif
}
