uint_32 _mcf54xx_uart_serial_int_init
(
/* [IN] the interrupt I/O initialization information */
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr,
/* [IN] the rest of the name of the device opened */
char _PTR_ open_name_ptr
)
{ /* Body */
MCF54XX_UART_SERIAL_INFO_STRUCT_PTR uart_info_ptr;
MCF54XX_UART_SERIAL_INIT_STRUCT_PTR uart_init_ptr;
uint_32 result;
uart_init_ptr = int_io_dev_ptr->DEV_INIT_DATA_PTR;
result = _mcf54xx_uart_serial_polled_init((pointer)uart_init_ptr,
&int_io_dev_ptr->DEV_INFO_PTR, open_name_ptr);
if (result != MQX_OK) {
return(result);
}/* Endif */
uart_info_ptr = int_io_dev_ptr->DEV_INFO_PTR;
uart_info_ptr->OLD_ISR_DATA = _int_get_isr_data(uart_init_ptr->VECTOR);
uart_info_ptr->OLD_ISR_EXCEPTION_HANDLER =
_int_get_exception_handler(uart_init_ptr->VECTOR);
uart_info_ptr->OLD_ISR =
_int_install_isr(uart_init_ptr->VECTOR, _mcf54xx_uart_serial_int_isr,
int_io_dev_ptr);
return(MQX_OK);
} /* Endbody */
uint_32 _kuart_int_init
(
/* [IN] the interrupt I/O initialization information */
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr,
/* [IN] the rest of the name of the device opened */
char _PTR_ open_name_ptr
)
{ /* Body */
KUART_INFO_STRUCT_PTR sci_info_ptr;
KUART_INIT_STRUCT_PTR sci_init_ptr;
uint_32 result;
sci_init_ptr = int_io_dev_ptr->DEV_INIT_DATA_PTR;
result = _kuart_polled_init((pointer)sci_init_ptr, &int_io_dev_ptr->DEV_INFO_PTR, open_name_ptr);
if (result != MQX_OK) {
return(result);
}/* Endif */
sci_info_ptr = int_io_dev_ptr->DEV_INFO_PTR;
/* wk */
UART_MemMapPtr sci_ptr = sci_info_ptr->SCI_PTR;
sci_ptr->C2 &= 0x77;
/* end */
sci_info_ptr->OLD_ISR_DATA = _int_get_isr_data(sci_init_ptr->RX_TX_VECTOR);
sci_info_ptr->OLD_ISR_EXCEPTION_HANDLER = _int_get_exception_handler(sci_init_ptr->RX_TX_VECTOR);
/* wk */
sci_ptr->C2 &= 0x77;
/* end */
/* Init RX/TX interrupt vector */
sci_info_ptr->OLD_ISR =
// _int_install_isr(sci_init_ptr->RX_TX_VECTOR, _kuart_int_rx_tx_isr, int_io_dev_ptr);
_int_install_isr(sci_init_ptr->RX_TX_VECTOR, uart_isr, int_io_dev_ptr); // wk
/* wk */
sci_ptr->C2 &= 0x77;
/* end */
#if defined (BSP_TWRMCF51FD) || defined (BSP_TWRMCF51JF) || defined (BSP_TWRMCF51QM)
#else
/* Init RX interrupt vector */
sci_info_ptr->OLD_ISR =
_int_install_isr(sci_init_ptr->ERR_VECTOR, _kuart_int_err_isr, int_io_dev_ptr);
_cortex_int_init(sci_init_ptr->RX_TX_VECTOR, sci_init_ptr->RX_TX_PRIORITY, TRUE);
_cortex_int_init(sci_init_ptr->ERR_VECTOR, sci_init_ptr->ERR_PRIORITY, TRUE);
#endif
return(MQX_OK);
} /* Endbody */
uint_32 _vf_rtc_init
(
/* [IN] the initialization information for the device being opened */
IO_RTC_IF_DEVICE_STRUCT_PTR io_dev_ptr,
/* [IN] the rest of the name of the device opened */
char_ptr open_name_ptr
)
{ /* Body */
VF_RTC_IF_INFO_STRUCT _PTR_ io_info_ptr;
VF_RTC_IF_INIT_STRUCT _PTR_ io_init_ptr;
VF_RTC_REGS_T _PTR_ regs_ptr;
uint_32 result;
io_init_ptr = io_dev_ptr->DEV_INIT_DATA_PTR;
io_info_ptr = (VF_RTC_IF_INFO_STRUCT _PTR_)(_mem_alloc_system_zero((uint_32)sizeof(VF_RTC_IF_INFO_STRUCT)));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (io_info_ptr == NULL) {
return(MQX_OUT_OF_MEMORY);
} /* Endif */
#endif
io_dev_ptr->DEV_INFO_PTR = io_info_ptr;
//get init value
io_info_ptr->INIT = *io_init_ptr;
/* reg_ptr will point to the rtc Registers */
regs_ptr = (VF_RTC_REGS_T _PTR_)io_info_ptr->INIT.BASE_ADDRESS;
io_info_ptr->RTC_REGS_PTR = regs_ptr;
//set up rtc interrupt
io_info_ptr->RTC_VECTOR = BSP_RTC_INTERRUPT_VECTOR;
io_info_ptr->OLD_ISR_DATA = _int_get_isr_data(io_info_ptr->RTC_VECTOR);
io_info_ptr->OLD_ISR_EXCEPTION_HANDLER =
_int_get_exception_handler(io_info_ptr->RTC_VECTOR);
io_info_ptr->OLD_ISR =
_int_install_isr(io_info_ptr->RTC_VECTOR,_vf_rtc_int_isr,io_info_ptr);
//now init ssp regs with defult values
// APB_RTC->rtcicr = 0x1;
// APB_RTC->rtcimsc = 0x1;
// APB_RTC->rtclr = 0x2;
// APB_RTC->rtccr = 0x1;
// APB_RTC->rtcmr = 0x50;
SysCtl_EnableRtc();
_vf_enable_int(BSP_RTC_INTERRUPT_VECTOR);
//======================
return (MQX_OK);
} /* Endbody */
uint32_t _kuart_mix_init
(
/* [IN] the interrupt I/O initialization information */
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr,
/* [IN] the rest of the name of the device opened */
char * open_name_ptr
)
{ /* Body */
KUART_INFO_STRUCT_PTR sci_info_ptr;
KUART_INIT_STRUCT_PTR sci_init_ptr;
uint32_t result = MQX_OK;
//Init basic uart setting
sci_init_ptr = int_io_dev_ptr->DEV_INIT_DATA_PTR;
result = _kuart_polled_init((void *)sci_init_ptr, &int_io_dev_ptr->DEV_INFO_PTR, open_name_ptr);
if (result != MQX_OK) {
return(result);
}/* Endif */
sci_info_ptr = int_io_dev_ptr->DEV_INFO_PTR;
sci_info_ptr->RX_KEEP = 1;
/* Add a timer config to check the UART RX state */
sci_info_ptr->LW_TIMER_PTR = (LWTIMER_PERIOD_STRUCT_PTR)_mem_alloc_system_zero(sizeof(LWTIMER_PERIOD_STRUCT) + sizeof(LWTIMER_STRUCT));
if (!sci_info_ptr->LW_TIMER_PTR)
{
result = MQX_OUT_OF_MEMORY;
goto error_free_timer;
}
sci_info_ptr->LW_TIMER = (LWTIMER_STRUCT_PTR)((uint8_t *)sci_info_ptr->LW_TIMER_PTR + sizeof(LWTIMER_PERIOD_STRUCT));
_time_init_ticks(&sci_info_ptr->ticks, 1);
_lwtimer_create_periodic_queue(sci_info_ptr->LW_TIMER_PTR ,*(uint32_t *)(&sci_info_ptr->ticks), 0);
_lwtimer_add_timer_to_queue(
sci_info_ptr->LW_TIMER_PTR,
sci_info_ptr->LW_TIMER,
0,
_kuart_period_isr,
(void *)int_io_dev_ptr);
/* RX DMA setting */
sci_info_ptr->RX_BUF = _mem_alloc_system_zero_uncached(sci_init_ptr->IQUEUE_SIZE);
sci_info_ptr->RX_ACTIVE = sci_info_ptr->RX_BUF;
if (!sci_info_ptr->RX_BUF)
{
result = MQX_OUT_OF_MEMORY;
goto error_free_buf;
}
sci_info_ptr->RX_DMA_CHAN = sci_init_ptr->RX_DMA_CHANNEL;
sci_info_ptr->RX_DMA_HARDWARE_REQUEST = _bsp_get_serial_rx_dma_request(sci_init_ptr->DEVICE);
#if PSP_MQX_CPU_IS_KINETIS
sci_info_ptr->ERR_INT = _bsp_get_serial_error_int_num(sci_init_ptr->DEVICE);
#endif
sci_info_ptr->RX_DMA_SEQ = 0;
result = dma_channel_claim(&sci_info_ptr->RX_DCH, sci_info_ptr->RX_DMA_CHAN);
if (result != MQX_OK)
{
goto error_free_channel;
}
result = dma_callback_reg(sci_info_ptr->RX_DCH, _kuart_dma_rx_isr, int_io_dev_ptr);
dma_channel_setup(sci_info_ptr->RX_DCH, 1, DMA_CHANNEL_FLAG_LOOP_MODE);
dma_request_source(sci_info_ptr->RX_DCH, sci_info_ptr->RX_DMA_HARDWARE_REQUEST);
if (result != MQX_OK)
{
goto error_free_channel;
}
/* Init RX/TX interrupt vector */
sci_info_ptr->OLD_ISR_TXRX_DATA = _int_get_isr_data(sci_init_ptr->RX_TX_VECTOR);
sci_info_ptr->OLD_ISR_EXCEPTION_HANDLER = _int_get_exception_handler(sci_init_ptr->RX_TX_VECTOR);
sci_info_ptr->OLD_ISR_TXRX =
_int_install_isr(sci_init_ptr->RX_TX_VECTOR, _kuart_mix_int_tx_isr, int_io_dev_ptr);
_bsp_int_init(sci_init_ptr->RX_TX_VECTOR, sci_init_ptr->RX_TX_PRIORITY, 0, TRUE);
/* Init mix error vector */
sci_info_ptr->OLD_ISR_ERR =
_int_install_isr(sci_info_ptr->ERR_INT, _kuart_mix_err_isr, int_io_dev_ptr);
_bsp_int_init(sci_info_ptr->ERR_INT, sci_init_ptr->ERR_PRIORITY, 0, TRUE);
/* config the UART RX channel first */
_kuart_prepare_rx_dma(int_io_dev_ptr);
return(MQX_OK);
error_free_timer:
if (!sci_info_ptr->LW_TIMER_PTR)
_mem_free(sci_info_ptr->LW_TIMER_PTR);
error_free_channel:
dma_channel_release(sci_info_ptr->RX_DCH);
error_free_buf:
if (sci_info_ptr->RX_BUF)
_mem_free(sci_info_ptr->RX_BUF);
return result;
} /* Endbody */
/*!
* \brief To provide support for exception handlers, applications can use this ISR
* to replace the default ISR. The ISR is specific to the PSP.
*
* An application calls _int_install_exception_isr() to install _int_exception_isr().
* \n The function _int_exception_isr() does the following:
* \n - If an exception occurs when a task is running and a task exception ISR
* exists, MQX runs the ISR; if a task exception ISR does not exist, MQX aborts
* the task by calling _task_abort().
* \n - If an exception occurs when an ISR is running and an ISR exception ISR
* exists, MQX aborts the running ISR and runs the ISR’s exception ISR.
* \n - The function walks the interrupt stack looking for information about the
* ISR or task that was running before the exception occurred. If the function
* determines that the interrupt stack contains incorrect information, it calls
* _mqx_fatal_error() with error code MQX_CORRUPT_INTERRUPT_STACK.
*
* \param[in] parameter Parameter passed to the default ISR (the vector number).
*
* \warning See description.
*
* \see _int_install_exception_isr
* \see _mqx_fatal_error
* \see _task_abort
*/
void _int_exception_isr
(
pointer parameter
)
{ /* Body */
KERNEL_DATA_STRUCT_PTR kernel_data;
TD_STRUCT_PTR td_ptr;
PSP_INT_CONTEXT_STRUCT_PTR exception_frame_ptr;
PSP_INT_CONTEXT_STRUCT_PTR isr_frame_ptr;
INTERRUPT_TABLE_STRUCT_PTR table_ptr;
INT_EXCEPTION_FPTR exception_handler;
uint_32 isr_vector;
/* uint_32 exception_vector; */
_GET_KERNEL_DATA(kernel_data);
td_ptr = kernel_data->ACTIVE_PTR;
/* Stop all interrupts */
_PSP_SET_DISABLE_SR(kernel_data->DISABLE_SR);
/*_int_disable(); */
if ( kernel_data->IN_ISR > 1 ) {
/* We have entered this function from an exception that happened
* while an isr was running.
*/
/* Get our current exception frame */
exception_frame_ptr = kernel_data->INTERRUPT_CONTEXT_PTR;
/* the current context contains a pointer to the next one */
isr_frame_ptr = (PSP_INT_CONTEXT_STRUCT_PTR)exception_frame_ptr->PREV_CONTEXT;
if (isr_frame_ptr == NULL) {
/* This is not allowable */
_mqx_fatal_error(MQX_CORRUPT_INTERRUPT_STACK);
}
isr_vector = isr_frame_ptr->EXCEPTION_NUMBER;
/* Call the isr exception handler for the ISR that WAS running */
table_ptr = kernel_data->INTERRUPT_TABLE_PTR;
#if MQX_CHECK_ERRORS
if ((table_ptr != NULL) &&
(isr_vector >= kernel_data->FIRST_USER_ISR_VECTOR) &&
(isr_vector <= kernel_data->LAST_USER_ISR_VECTOR))
{
#endif
/* Call the exception handler for the isr on isr_vector,
* passing the isr_vector, the exception_vector, the isr_data and
* the basic frame pointer for the exception
*/
exception_handler = _int_get_exception_handler(isr_vector);
if (exception_handler) {
(*exception_handler)(isr_vector, (_mqx_uint)parameter, _int_get_isr_data(isr_vector)/*table_ptr->APP_ISR_DATA*/, exception_frame_ptr);
}
#if MQX_CHECK_ERRORS
} else {
/* In this case, the exception occured in this handler */
_mqx_fatal_error(MQX_INVALID_VECTORED_INTERRUPT);
}
#endif
/* Indicate we have popped 1 interrupt stack frame (the exception frame) */
--kernel_data->IN_ISR;
/* Reset the stack to point to the interrupt frame */
/* And off we go. Will never return */
_psp_exception_return( (pointer)isr_frame_ptr );
} else {
/* We have entered this function from an exception that happened
* while a task was running.
*/
if (td_ptr->EXCEPTION_HANDLER_PTR != NULL ) {
(*td_ptr->EXCEPTION_HANDLER_PTR)((_mqx_uint)parameter,
td_ptr->STACK_PTR);
} else {
/* Abort the current task */
_task_abort(MQX_NULL_TASK_ID);
}
}
}
