static bool _io_serial_mix_putc_internal
(
/* [IN] the interrupt io device information */
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr,
/* [IN] the character to print out */
char c,
_mqx_uint flags
)
{ /* Body */
volatile CHARQ_STRUCT *out_queue;
/* Start CR 388 */
#if (PSP_MEMORY_ADDRESSING_CAPABILITY > 8 )
c &= 0xFF;
#endif
/* End CR 388 */
out_queue = int_io_dev_ptr->OUT_QUEUE;
_int_disable();
if(flags & IO_SERIAL_NON_BLOCKING) {
if (_CHARQ_FULL(out_queue)) {
_int_enable();
return FALSE;
} /* Endif */
} else {
if(int_io_dev_ptr->HAVE_STOPPED_OUTPUT) {
_taskq_suspend(int_io_dev_ptr->OUT_WAITING_TASKS);
} /* Endif */
while (_CHARQ_FULL(out_queue)) {
/* Lets wait */
_taskq_suspend(int_io_dev_ptr->OUT_WAITING_TASKS);
} /* Endif */
} /* Endif */
if (int_io_dev_ptr->HAVE_STOPPED_OUTPUT ||
(int_io_dev_ptr->OUTPUT_ENABLED && !(int_io_dev_ptr->TX_DEV_PUTC)))
{
_CHARQ_ENQUEUE(out_queue,c);
} else {
int_io_dev_ptr->OUTPUT_ENABLED = TRUE;
(*int_io_dev_ptr->DEV_PUTC)(int_io_dev_ptr, c);
} /* Endif */
_int_enable();
return TRUE;
} /* Endbody */
/*!
* \brief Lock the core mutex.
*
* This function attempts to lock a mutex. If the mutex is already locked
* by another task the function blocks and waits until it is possible to lock
* the mutex for the calling task.
*
* \param[in] core_mutex_ptr Pointer to core_mutex structure.
*
* \return MQX_INVALID_POINTER (Wrong pointer to the core_mutex structure provided.)
* \return COREMUTEX_OK (Core mutex successfully locked.)
*
* \see _core_mutex_unlock
* \see _core_mutex_trylock
*/
uint32_t _core_mutex_lock( CORE_MUTEX_PTR core_mutex_ptr )
{
unsigned char lock = _psp_core_num()+1;
#if MQX_CHECK_ERRORS
if (core_mutex_ptr == NULL) {
return MQX_INVALID_POINTER;
}
if (core_mutex_ptr->VALID != CORE_MUTEX_VALID) {
return MQX_INVALID_POINTER;
}
#endif
_sema4_int_disable();
#if BSPCFG_CORE_MUTEX_STATS
core_mutex_ptr->LOCKS++;
#endif
/* Check to see if this core already own it */
if (*core_mutex_ptr->GATE_PTR == lock) {
/* Yes, then we have to wait for owning task to release it */
#if BSPCFG_CORE_MUTEX_STATS
core_mutex_ptr->WAITS++;
#endif
_taskq_suspend(core_mutex_ptr->WAIT_Q);
} else {
/* can only try to lock the mutex if another task is not waiting otherwise we need to get in line */
if (_taskq_get_value(core_mutex_ptr->WAIT_Q)==0) {
*core_mutex_ptr->GATE_PTR = lock;
}
if (*core_mutex_ptr->GATE_PTR != lock) {
#if BSPCFG_CORE_MUTEX_STATS
core_mutex_ptr->WAITS++;
#endif
_taskq_suspend(core_mutex_ptr->WAIT_Q);
/* Our turn now */
}
}
_sema4_int_enable();
return COREMUTEX_OK;
}
static _mqx_int _io_serial_mix_ioctl
(
/* [IN] the handle returned from _fopen */
FILE_DEVICE_STRUCT_PTR fd_ptr,
/* [IN] the ioctl command */
_mqx_uint cmd,
/* [IN] the ioctl parameters */
void *param_ptr
)
{ /* Body */
IO_DEVICE_STRUCT_PTR io_dev_ptr;
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr;
_mqx_uint result = MQX_OK;
_mqx_uint_ptr uparam_ptr = (_mqx_uint_ptr)param_ptr;
io_dev_ptr = fd_ptr->DEV_PTR;
int_io_dev_ptr = (void *)io_dev_ptr->DRIVER_INIT_PTR;
switch (cmd) {
case IO_IOCTL_FLUSH_OUTPUT:
/* Disable interrupts to avoid situation that last TX interrupt comes after successfull !_CHARQ_EMPTY() */
_int_disable();
while(!_CHARQ_EMPTY(int_io_dev_ptr->OUT_QUEUE)) {
/* wait untill all chars are sent from output queue */
_taskq_suspend(int_io_dev_ptr->OUT_WAITING_TASKS);
};
_int_enable();
break;
default:
if (int_io_dev_ptr->DEV_IOCTL != NULL) {
result = (*int_io_dev_ptr->DEV_IOCTL)(int_io_dev_ptr->DEV_INFO_PTR,
cmd, param_ptr);
} /* Endif */
break;
} /* Endswitch */
return result;
} /* Endbody */
_mqx_int _io_serial_mix_read
(
/* [IN] the handle returned from _fopen */
FILE_DEVICE_STRUCT_PTR fd_ptr,
/* [IN] where the characters are to be stored */
char *data_ptr,
/* [IN] the number of characters to input */
_mqx_int num
)
{ /* Body */
IO_DEVICE_STRUCT_PTR io_dev_ptr;
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr;
KUART_INFO_STRUCT_PTR sci_info_ptr;
uint32_t dmaUC = 0, dmaC = 0;
uint32_t queueSize = 0;
uint8_t *dmaBuffer = NULL;
uint32_t dmaOff = 0, readOff = 0;
io_dev_ptr = fd_ptr->DEV_PTR;
int_io_dev_ptr = (void *)io_dev_ptr->DRIVER_INIT_PTR;
sci_info_ptr = int_io_dev_ptr->DEV_INFO_PTR;
queueSize = int_io_dev_ptr->IQUEUE_SIZE;
dmaBuffer = (uint8_t *)sci_info_ptr->RX_BUF;
_int_disable();
dma_channel_status(sci_info_ptr->RX_DCH, &sci_info_ptr->RX_DMA_SEQ, &dmaUC);
dmaC = queueSize - dmaUC;
#if 1
if((int64_t)(dmaC + sci_info_ptr->dmaC - sci_info_ptr->readC) < num){
sci_info_ptr->rxwakeupnum = num;
_int_enable();
_taskq_suspend(int_io_dev_ptr->IN_WAITING_TASKS);
_int_disable();
dma_channel_status(sci_info_ptr->RX_DCH, &sci_info_ptr->RX_DMA_SEQ, &dmaUC);
dmaC = queueSize - dmaUC;
}
#endif
#if 0
while((int64_t)(dmaC + sci_info_ptr->dmaC - sci_info_ptr->readC) < num){
sci_info_ptr->rxwakeupnum = num;
_int_enable();
_taskq_suspend(int_io_dev_ptr->IN_WAITING_TASKS);
//_sched_yield();
_int_disable();
dma_channel_status(sci_info_ptr->RX_DCH, &sci_info_ptr->RX_DMA_SEQ, &dmaUC);
dmaC = queueSize - dmaUC;
}
#endif
if((int64_t)(dmaC + sci_info_ptr->dmaC - sci_info_ptr->readC) > queueSize){
printf("UART dma buffer full! Reset read header. \n");
sci_info_ptr->readC = dmaC + sci_info_ptr->dmaC - num;
}
dmaOff = (dmaC + sci_info_ptr->dmaC) % queueSize;
readOff = sci_info_ptr->readC % queueSize;
if(readOff + num > queueSize){
memcpy(data_ptr, dmaBuffer + readOff, queueSize - readOff);
memcpy(data_ptr + queueSize - readOff, dmaBuffer, readOff + num - queueSize);
}else{
memcpy(data_ptr, dmaBuffer + readOff, num);
}
sci_info_ptr->readC += num;
_int_enable();
//printf("mix read %d bytes, dmaC %d \n", num, dmaC);
return num;
} /* Endbody */
_mqx_int _io_serial_int_ioctl
(
/* [IN] the handle returned from _fopen */
FILE_DEVICE_STRUCT_PTR fd_ptr,
/* [IN] the ioctl command */
_mqx_uint cmd,
/* [IN] the ioctl parameters */
pointer param_ptr
)
{ /* Body */
IO_DEVICE_STRUCT_PTR io_dev_ptr;
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr;
_mqx_uint result = MQX_OK;
_mqx_uint_ptr uparam_ptr = (_mqx_uint_ptr)param_ptr;
io_dev_ptr = fd_ptr->DEV_PTR;
int_io_dev_ptr = (pointer)io_dev_ptr->DRIVER_INIT_PTR;
switch (cmd) {
case IO_IOCTL_CHAR_AVAIL:
if ( _CHARQ_SIZE(int_io_dev_ptr->IN_QUEUE) ) {
*((boolean _PTR_)param_ptr) = TRUE;
} else {
*((boolean _PTR_)param_ptr) = FALSE;
} /* Endif */
break;
case IO_IOCTL_SERIAL_GET_FLAGS:
*((_mqx_uint_ptr)param_ptr) = int_io_dev_ptr->FLAGS;
break;
case IO_IOCTL_SERIAL_SET_FLAGS:
int_io_dev_ptr->FLAGS = *((_mqx_uint_ptr)param_ptr);
fd_ptr->FLAGS = *((_mqx_uint_ptr)param_ptr);
if (int_io_dev_ptr->DEV_IOCTL != NULL) {
result = (*int_io_dev_ptr->DEV_IOCTL)(int_io_dev_ptr->DEV_INFO_PTR,
cmd, param_ptr);
} /* Endif */
break;
case IO_IOCTL_SERIAL_TRANSMIT_DONE:
*((boolean _PTR_)param_ptr) = !(int_io_dev_ptr->OUTPUT_ENABLED);
break;
case IO_IOCTL_FLUSH_OUTPUT:
/* Disable interrupts to avoid situation that last TX interrupt comes after successfull !_CHARQ_EMPTY() */
_int_disable();
while(!_CHARQ_EMPTY(int_io_dev_ptr->OUT_QUEUE)) {
/* wait untill all chars are sent from output queue */
_taskq_suspend(int_io_dev_ptr->OUT_WAITING_TASKS);
};
_int_enable();
break;
case IO_IOCTL_DEVICE_IDENTIFY:
/* return the device identify */
uparam_ptr[0] = IO_DEV_TYPE_PHYS_SERIAL_INTERRUPT;
uparam_ptr[1] = 0;
uparam_ptr[2] = IO_DEV_ATTR_INTERRUPT | IO_DEV_ATTR_READ | IO_DEV_ATTR_WRITE;
result = MQX_OK;
break;
case IO_IOCTL_SERIAL_CAN_TRANSMIT:
*uparam_ptr = (int_io_dev_ptr->OUT_QUEUE->MAX_SIZE - int_io_dev_ptr->OUT_QUEUE->CURRENT_SIZE);
result = MQX_OK;
break;
case IO_IOCTL_SERIAL_CAN_RECEIVE:
*uparam_ptr = (int_io_dev_ptr->IN_QUEUE->MAX_SIZE - int_io_dev_ptr->IN_QUEUE->CURRENT_SIZE);
result = MQX_OK;
break;
default:
if (int_io_dev_ptr->DEV_IOCTL != NULL) {
result = (*int_io_dev_ptr->DEV_IOCTL)(int_io_dev_ptr->DEV_INFO_PTR,
cmd, param_ptr);
} /* Endif */
break;
} /* Endswitch */
return result;
} /* Endbody */
_mqx_int _io_serial_int_read
(
/* [IN] the handle returned from _fopen */
FILE_DEVICE_STRUCT_PTR fd_ptr,
/* [IN] where the characters are to be stored */
char _PTR_ data_ptr,
/* [IN] the number of characters to input */
_mqx_int num
)
{ /* Body */
IO_DEVICE_STRUCT_PTR io_dev_ptr;
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr;
_mqx_int ioctl_val;
uchar c = 0;
_mqx_uint flags;
_mqx_int i = num;
volatile CHARQ_STRUCT _PTR_ in_queue;
io_dev_ptr = fd_ptr->DEV_PTR;
int_io_dev_ptr = (pointer)io_dev_ptr->DRIVER_INIT_PTR;
flags = fd_ptr->FLAGS;
while ( i ) {
in_queue = int_io_dev_ptr->IN_QUEUE;
_int_disable();
if(flags & IO_SERIAL_NON_BLOCKING) {
if (_CHARQ_SIZE(in_queue) == 0) {
num -= i;
_int_enable();
break;
} /* Endif */
} else {
while (_CHARQ_SIZE(in_queue) == 0) {
_taskq_suspend(int_io_dev_ptr->IN_WAITING_TASKS);
} /* Endwhile */
} /* Endif */
_CHARQ_DEQUEUE(in_queue,c);
if (int_io_dev_ptr->HAVE_STOPPED_INPUT) {
if (_CHARQ_SIZE(in_queue) < int_io_dev_ptr->INPUT_LOW_WATER_MARK) {
if (flags & IO_SERIAL_HW_FLOW_CONTROL) {
if (int_io_dev_ptr->DEV_IOCTL != NULL) {
ioctl_val = IO_SERIAL_RTS;
(*int_io_dev_ptr->DEV_IOCTL)(int_io_dev_ptr->DEV_INFO_PTR, IO_IOCTL_SERIAL_SET_HW_SIGNAL, &ioctl_val);
}
int_io_dev_ptr->HAVE_STOPPED_INPUT = FALSE;
} else {
if (int_io_dev_ptr->OUTPUT_ENABLED && !int_io_dev_ptr->HAVE_STOPPED_OUTPUT) {
int_io_dev_ptr->MUST_START_INPUT = TRUE;
} else {
int_io_dev_ptr->HAVE_STOPPED_INPUT = FALSE;
int_io_dev_ptr->OUTPUT_ENABLED = TRUE;
(*int_io_dev_ptr->DEV_PUTC)(int_io_dev_ptr, CNTL_Q);
} /* Endif */
} /* Endif */
} /* Endif */
} /* Endif */
_int_enable();
if (flags & IO_SERIAL_TRANSLATION) {
if (c == '\r') {
/* Start CR 387 */
if (flags & IO_SERIAL_ECHO) {
_io_serial_int_putc_internal(int_io_dev_ptr, (char)c, 0);
} /* Endif */
/* End CR 387 */
c = '\n';
} else if ((c == '\b') && (flags & IO_SERIAL_ECHO)) {
_io_serial_int_putc_internal(int_io_dev_ptr, (char)'\b', 0);
_io_serial_int_putc_internal(int_io_dev_ptr, (char)' ', 0);
} /* Endif */
} /* Endif */
if (flags & IO_SERIAL_ECHO) {
_io_serial_int_putc_internal(int_io_dev_ptr, (char)c, 0);
} /* Endif */
*data_ptr++ = c;
--i;
} /* Endwhile */
return num;
} /* Endbody */