2094 lines
82 KiB
C
2094 lines
82 KiB
C
/*
|
|
* Copyright 2018-2023 NXP
|
|
* All rights reserved.
|
|
*
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include "fsl_component_serial_manager.h"
|
|
#include "fsl_component_serial_port_internal.h"
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
#include "fsl_component_generic_list.h"
|
|
|
|
/*
|
|
* The OSA_USED macro can only be defined when the OSA component is used.
|
|
* If the source code of the OSA component does not exist, the OSA_USED cannot be defined.
|
|
* OR, If OSA component is not added into project event the OSA source code exists, the OSA_USED
|
|
* also cannot be defined.
|
|
* The source code path of the OSA component is <MCUXpresso_SDK>/components/osa.
|
|
*
|
|
*/
|
|
#if defined(OSA_USED)
|
|
#include "fsl_os_abstraction.h"
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#include "fsl_component_common_task.h"
|
|
#else
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* Definitions
|
|
******************************************************************************/
|
|
|
|
#ifndef NDEBUG
|
|
#if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
|
|
#undef assert
|
|
#define assert(n)
|
|
#else
|
|
/* MISRA C-2012 Rule 17.2 */
|
|
#undef assert
|
|
#define assert(n) \
|
|
while (!(n)) \
|
|
{ \
|
|
; \
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
/* Weak function. */
|
|
#if defined(__GNUC__)
|
|
#define __WEAK_FUNC __attribute__((weak))
|
|
#elif defined(__ICCARM__)
|
|
#define __WEAK_FUNC __weak
|
|
#elif defined(__CC_ARM) || defined(__ARMCC_VERSION)
|
|
#define __WEAK_FUNC __attribute__((weak))
|
|
#elif defined(__DSC__) || defined(__CW__)
|
|
#define __WEAK_FUNC __attribute__((weak))
|
|
#endif
|
|
|
|
#define SERIAL_EVENT_DATA_RECEIVED (0U)
|
|
#define SERIAL_EVENT_DATA_SENT (1U)
|
|
#define SERIAL_EVENT_DATA_START_SEND (2U)
|
|
#define SERIAL_EVENT_DATA_RX_NOTIFY (3U)
|
|
#define SERIAL_EVENT_DATA_NUMBER (4U)
|
|
|
|
#define SERIAL_MANAGER_WRITE_TAG 0xAABB5754U
|
|
#define SERIAL_MANAGER_READ_TAG 0xBBAA5244U
|
|
|
|
#ifndef RINGBUFFER_WATERMARK_THRESHOLD
|
|
#define RINGBUFFER_WATERMARK_THRESHOLD 95U / 100U
|
|
#endif
|
|
|
|
#ifndef gSerialManagerLpConstraint_c
|
|
#define gSerialManagerLpConstraint_c 0
|
|
#endif
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
typedef enum _serial_manager_transmission_mode
|
|
{
|
|
kSerialManager_TransmissionBlocking = 0x0U, /*!< Blocking transmission*/
|
|
kSerialManager_TransmissionNonBlocking = 0x1U, /*!< None blocking transmission*/
|
|
} serial_manager_transmission_mode_t;
|
|
|
|
/* TX transfer structure */
|
|
typedef struct _serial_manager_transfer
|
|
{
|
|
uint8_t *buffer;
|
|
volatile uint32_t length;
|
|
volatile uint32_t soFar;
|
|
serial_manager_transmission_mode_t mode;
|
|
serial_manager_status_t status;
|
|
} serial_manager_transfer_t;
|
|
#endif
|
|
|
|
/* write handle structure */
|
|
typedef struct _serial_manager_send_handle
|
|
{
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
list_element_t link; /*!< list element of the link */
|
|
serial_manager_transfer_t transfer;
|
|
#endif
|
|
struct _serial_manager_handle *serialManagerHandle;
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
serial_manager_callback_t callback;
|
|
void *callbackParam;
|
|
uint32_t tag;
|
|
#endif
|
|
} serial_manager_write_handle_t;
|
|
typedef struct _serial_manager_send_block_handle
|
|
{
|
|
struct _serial_manager_handle *serialManagerHandle;
|
|
|
|
} serial_manager_write_block_handle_t;
|
|
|
|
typedef serial_manager_write_handle_t serial_manager_read_handle_t;
|
|
typedef serial_manager_write_block_handle_t serial_manager_read_block_handle_t;
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
/* receive state structure */
|
|
typedef struct _serial_manager_read_ring_buffer
|
|
{
|
|
uint8_t *ringBuffer;
|
|
uint32_t ringBufferSize;
|
|
volatile uint32_t ringHead;
|
|
volatile uint32_t ringTail;
|
|
} serial_manager_read_ring_buffer_t;
|
|
|
|
#if defined(__CC_ARM)
|
|
#pragma anon_unions
|
|
#endif
|
|
typedef struct _serial_manager_block_handle
|
|
{
|
|
serial_manager_type_t handleType;
|
|
serial_port_type_t type;
|
|
serial_manager_read_handle_t *volatile openedReadHandleHead;
|
|
volatile uint32_t openedWriteHandleCount;
|
|
union
|
|
{
|
|
uint32_t lowLevelhandleBuffer[1];
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
uint8_t uartHandleBuffer[SERIAL_PORT_UART_BLOCK_HANDLE_SIZE];
|
|
#endif
|
|
};
|
|
|
|
} serial_manager_block_handle_t;
|
|
#endif
|
|
|
|
/* The serial manager handle structure */
|
|
typedef struct _serial_manager_handle
|
|
{
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
serial_manager_type_t handleType;
|
|
#endif
|
|
serial_port_type_t serialPortType;
|
|
serial_manager_read_handle_t *volatile openedReadHandleHead;
|
|
volatile uint32_t openedWriteHandleCount;
|
|
union
|
|
{
|
|
uint32_t lowLevelhandleBuffer[1];
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
uint8_t uartHandleBuffer[SERIAL_PORT_UART_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
|
|
uint8_t uartDmaHandleBuffer[SERIAL_PORT_UART_DMA_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
uint8_t usbcdcHandleBuffer[SERIAL_PORT_USB_CDC_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
uint8_t swoHandleBuffer[SERIAL_PORT_SWO_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
uint8_t usbcdcVirtualHandleBuffer[SERIAL_PORT_VIRTUAL_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
|
|
uint8_t rpmsgHandleBuffer[SERIAL_PORT_RPMSG_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
uint8_t spiMasterHandleBuffer[SERIAL_PORT_SPI_MASTER_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
uint8_t spiSlaveHandleBuffer[SERIAL_PORT_SPI_SLAVE_HANDLE_SIZE];
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
uint8_t bleWuHandleBuffer[SERIAL_PORT_BLE_WU_HANDLE_SIZE];
|
|
#endif
|
|
};
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
serial_manager_read_ring_buffer_t ringBuffer;
|
|
#endif
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
common_task_message_t commontaskMsg;
|
|
#else
|
|
OSA_SEMAPHORE_HANDLE_DEFINE(serSemaphore); /*!< Semaphore instance */
|
|
OSA_TASK_HANDLE_DEFINE(taskId); /*!< Task handle */
|
|
#endif
|
|
uint8_t serialManagerState[SERIAL_EVENT_DATA_NUMBER]; /*!< Used to indicate the serial mnager state */
|
|
|
|
#endif
|
|
|
|
#endif
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
list_label_t runningWriteHandleHead; /*!< The queue of running write handle */
|
|
list_label_t completedWriteHandleHead; /*!< The queue of completed write handle */
|
|
#endif
|
|
|
|
} serial_manager_handle_t;
|
|
|
|
/*******************************************************************************
|
|
* Prototypes
|
|
******************************************************************************/
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
static void SerialManager_Task(void *param);
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* Variables
|
|
******************************************************************************/
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
|
|
#else
|
|
/*
|
|
* \brief Defines the serial manager task's stack
|
|
*/
|
|
static OSA_TASK_DEFINE(SerialManager_Task, SERIAL_MANAGER_TASK_PRIORITY, 1, SERIAL_MANAGER_TASK_STACK_SIZE, false);
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
|
static const serial_manager_lowpower_critical_CBs_t *s_pfserialLowpowerCriticalCallbacks = NULL;
|
|
/*******************************************************************************
|
|
* Code
|
|
******************************************************************************/
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
static void SerialManager_AddTail(list_label_t *queue, serial_manager_write_handle_t *node)
|
|
{
|
|
(void)LIST_AddTail(queue, &node->link);
|
|
}
|
|
|
|
static void SerialManager_RemoveHead(list_label_t *queue)
|
|
{
|
|
(void)LIST_RemoveHead(queue);
|
|
}
|
|
|
|
static int32_t SerialManager_SetLpConstraint(int32_t power_mode)
|
|
{
|
|
int32_t status = -1;
|
|
if ((s_pfserialLowpowerCriticalCallbacks != NULL) &&
|
|
(s_pfserialLowpowerCriticalCallbacks->serialEnterLowpowerCriticalFunc != NULL))
|
|
{
|
|
status = s_pfserialLowpowerCriticalCallbacks->serialEnterLowpowerCriticalFunc(power_mode);
|
|
}
|
|
return status;
|
|
}
|
|
static int32_t SerialManager_ReleaseLpConstraint(int32_t power_mode)
|
|
{
|
|
int32_t status = -1;
|
|
if ((s_pfserialLowpowerCriticalCallbacks != NULL) &&
|
|
(s_pfserialLowpowerCriticalCallbacks->serialExitLowpowerCriticalFunc != NULL))
|
|
{
|
|
status = s_pfserialLowpowerCriticalCallbacks->serialExitLowpowerCriticalFunc(power_mode);
|
|
}
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *serHandle)
|
|
{
|
|
serial_manager_status_t status = kStatus_SerialManager_Error;
|
|
serial_manager_write_handle_t *writeHandle =
|
|
(serial_manager_write_handle_t *)(void *)LIST_GetHead(&serHandle->runningWriteHandleHead);
|
|
|
|
if (writeHandle != NULL)
|
|
{
|
|
(void)SerialManager_SetLpConstraint(gSerialManagerLpConstraint_c);
|
|
switch (serHandle->serialPortType)
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
case kSerialPort_Uart:
|
|
status = Serial_UartWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
|
|
case kSerialPort_UartDma:
|
|
status = Serial_UartDmaWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
case kSerialPort_UsbCdc:
|
|
status = Serial_UsbCdcWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
case kSerialPort_Swo:
|
|
status = Serial_SwoWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Virtual:
|
|
status = Serial_PortVirtualWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
|
|
case kSerialPort_Rpmsg:
|
|
status = Serial_RpmsgWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
case kSerialPort_SpiMaster:
|
|
status = Serial_SpiMasterWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
case kSerialPort_SpiSlave:
|
|
status = Serial_SpiSlaveWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
case kSerialPort_BleWu:
|
|
status = Serial_PortBleWuWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
writeHandle->transfer.buffer, writeHandle->transfer.length);
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
status = kStatus_SerialManager_Error;
|
|
break;
|
|
}
|
|
if (kStatus_SerialManager_Success != status)
|
|
{
|
|
(void)SerialManager_ReleaseLpConstraint(gSerialManagerLpConstraint_c);
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *serHandle,
|
|
serial_manager_read_handle_t *readHandle,
|
|
uint8_t *buffer,
|
|
uint32_t length)
|
|
{
|
|
serial_manager_status_t status = kStatus_SerialManager_Error;
|
|
|
|
if (NULL != readHandle)
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
if (kSerialPort_Uart == serHandle->serialPortType) /* Serial port UART */
|
|
{
|
|
status = Serial_UartRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
if (serHandle->serialPortType == kSerialPort_UsbCdc)
|
|
{
|
|
status = Serial_UsbCdcRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
if (serHandle->serialPortType == kSerialPort_Virtual)
|
|
{
|
|
status = Serial_PortVirtualRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
if (serHandle->serialPortType == kSerialPort_SpiMaster)
|
|
{
|
|
status = Serial_SpiMasterRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
if (serHandle->serialPortType == kSerialPort_SpiSlave)
|
|
{
|
|
status = Serial_SpiSlaveRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
|
|
if (serHandle->serialPortType == kSerialPort_Rpmsg)
|
|
{
|
|
status = Serial_RpmsgRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
#endif
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
if (serHandle->serialPortType == kSerialPort_BleWu)
|
|
{
|
|
status = Serial_PortBleWuRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
#endif
|
|
}
|
|
return status;
|
|
}
|
|
|
|
#else /*SERIAL_MANAGER_NON_BLOCKING_MODE > 0U*/
|
|
|
|
static serial_manager_status_t SerialManager_StartWriting(serial_manager_handle_t *serHandle,
|
|
serial_manager_write_handle_t *writeHandle,
|
|
uint8_t *buffer,
|
|
uint32_t length)
|
|
{
|
|
serial_manager_status_t status = kStatus_SerialManager_Error;
|
|
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
if (kSerialPort_Uart == serHandle->serialPortType) /* Serial port UART */
|
|
{
|
|
status = Serial_UartWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
if (kSerialPort_UsbCdc == serHandle->serialPortType) /* Serial port UsbCdc */
|
|
{
|
|
status = Serial_UsbCdcWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
if (kSerialPort_Swo == serHandle->serialPortType) /* Serial port SWO */
|
|
{
|
|
status = Serial_SwoWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
if (kSerialPort_Virtual == serHandle->serialPortType) /* Serial port UsbCdcVirtual */
|
|
{
|
|
status = Serial_PortVirtualWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
|
|
if (kSerialPort_Rpmsg == serHandle->serialPortType) /* Serial port Rpmsg */
|
|
{
|
|
status = Serial_RpmsgWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
if (kSerialPort_SpiMaster == serHandle->serialPortType) /* Serial port Spi Master */
|
|
{
|
|
status = Serial_SpiMasterWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
if (kSerialPort_BleWu == serHandle->serialPortType) /* Serial port BLE WU */
|
|
{
|
|
status = Serial_PortBleWuWrite(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
/*MISRA rule*/
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static serial_manager_status_t SerialManager_StartReading(serial_manager_handle_t *serHandle,
|
|
serial_manager_read_handle_t *readHandle,
|
|
uint8_t *buffer,
|
|
uint32_t length)
|
|
{
|
|
serial_manager_status_t status = kStatus_SerialManager_Error;
|
|
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
if (kSerialPort_Uart == serHandle->serialPortType) /* Serial port UART */
|
|
{
|
|
status = Serial_UartRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
if (kSerialPort_UsbCdc == serHandle->serialPortType) /* Serial port UsbCdc */
|
|
{
|
|
status = Serial_UsbCdcRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
if (kSerialPort_Swo == serHandle->serialPortType) /* Serial port SWO */
|
|
{
|
|
status = Serial_SwoRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
if (kSerialPort_Virtual == serHandle->serialPortType) /* Serial port UsbCdcVirtual */
|
|
{
|
|
status = Serial_PortVirtualRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
|
|
if (kSerialPort_Rpmsg == serHandle->serialPortType) /* Serial port UsbCdcVirtual */
|
|
{
|
|
status = Serial_RpmsgRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
if (kSerialPort_SpiMaster == serHandle->serialPortType) /* Serial port Spi Master */
|
|
{
|
|
status = Serial_SpiMasterRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
if (kSerialPort_BleWu == serHandle->serialPortType) /* Serial port BLE WU */
|
|
{
|
|
status = Serial_PortBleWuRead(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), buffer, length);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
/*MISRA rule*/
|
|
}
|
|
return status;
|
|
}
|
|
#endif /*SERIAL_MANAGER_NON_BLOCKING_MODE > 0U*/
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
static void SerialManager_IsrFunction(serial_manager_handle_t *serHandle)
|
|
{
|
|
uint32_t regPrimask = DisableGlobalIRQ();
|
|
switch (serHandle->serialPortType)
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
case kSerialPort_Uart:
|
|
Serial_UartIsrFunction(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
|
|
case kSerialPort_UartDma:
|
|
Serial_UartIsrFunction(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
case kSerialPort_UsbCdc:
|
|
Serial_UsbCdcIsrFunction(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
case kSerialPort_Swo:
|
|
Serial_SwoIsrFunction(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Virtual:
|
|
Serial_PortVirtualIsrFunction(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
case kSerialPort_BleWu:
|
|
Serial_PortBleWuIsrFunction(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
default:
|
|
/*MISRA rule 16.4*/
|
|
break;
|
|
}
|
|
EnableGlobalIRQ(regPrimask);
|
|
}
|
|
|
|
static void SerialManager_Task(void *param)
|
|
{
|
|
serial_manager_handle_t *serHandle = (serial_manager_handle_t *)param;
|
|
serial_manager_write_handle_t *serialWriteHandle;
|
|
serial_manager_read_handle_t *serialReadHandle;
|
|
uint32_t primask;
|
|
serial_manager_callback_message_t serialMsg;
|
|
#if (defined(SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY) && (SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY > 0U))
|
|
uint32_t ringBufferLength;
|
|
#endif /* SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
|
|
|
|
if (NULL != serHandle)
|
|
{
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
|
|
do
|
|
{
|
|
if (KOSA_StatusSuccess ==
|
|
OSA_SemaphoreWait((osa_semaphore_handle_t)serHandle->serSemaphore, osaWaitForever_c))
|
|
{
|
|
#endif
|
|
#endif
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
primask = DisableGlobalIRQ();
|
|
uint8_t *ev = serHandle->serialManagerState;
|
|
EnableGlobalIRQ(primask);
|
|
if (0U != (ev[SERIAL_EVENT_DATA_START_SEND]))
|
|
#endif
|
|
#endif
|
|
{
|
|
(void)SerialManager_StartWriting(serHandle);
|
|
#if defined(OSA_USED)
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]--;
|
|
EnableGlobalIRQ(primask);
|
|
#endif
|
|
#endif
|
|
}
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
if (0U != (ev[SERIAL_EVENT_DATA_SENT]))
|
|
#endif
|
|
|
|
#endif
|
|
{
|
|
serialWriteHandle =
|
|
(serial_manager_write_handle_t *)(void *)LIST_GetHead(&serHandle->completedWriteHandleHead);
|
|
while (NULL != serialWriteHandle)
|
|
{
|
|
SerialManager_RemoveHead(&serHandle->completedWriteHandleHead);
|
|
serialMsg.buffer = serialWriteHandle->transfer.buffer;
|
|
serialMsg.length = serialWriteHandle->transfer.soFar;
|
|
serialWriteHandle->transfer.buffer = NULL;
|
|
if (NULL != serialWriteHandle->callback)
|
|
{
|
|
serialWriteHandle->callback(serialWriteHandle->callbackParam, &serialMsg,
|
|
serialWriteHandle->transfer.status);
|
|
}
|
|
serialWriteHandle =
|
|
(serial_manager_write_handle_t *)(void *)LIST_GetHead(&serHandle->completedWriteHandleHead);
|
|
(void)SerialManager_ReleaseLpConstraint(gSerialManagerLpConstraint_c);
|
|
}
|
|
#if defined(OSA_USED)
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_SENT]--;
|
|
EnableGlobalIRQ(primask);
|
|
#endif
|
|
#endif
|
|
}
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
if (0U != (ev[SERIAL_EVENT_DATA_RECEIVED]))
|
|
#endif
|
|
|
|
#endif
|
|
{
|
|
primask = DisableGlobalIRQ();
|
|
serialReadHandle = serHandle->openedReadHandleHead;
|
|
EnableGlobalIRQ(primask);
|
|
|
|
if (NULL != serialReadHandle)
|
|
{
|
|
if (NULL != serialReadHandle->transfer.buffer)
|
|
{
|
|
if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
|
|
{
|
|
serialMsg.buffer = serialReadHandle->transfer.buffer;
|
|
serialMsg.length = serialReadHandle->transfer.soFar;
|
|
serialReadHandle->transfer.buffer = NULL;
|
|
if (NULL != serialReadHandle->callback)
|
|
{
|
|
serialReadHandle->callback(serialReadHandle->callbackParam, &serialMsg,
|
|
serialReadHandle->transfer.status);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#if defined(OSA_USED)
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_RECEIVED]--;
|
|
EnableGlobalIRQ(primask);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
#if (defined(SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY) && (SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY > 0U))
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
if (0U != (ev[SERIAL_EVENT_DATA_RX_NOTIFY]))
|
|
#endif
|
|
{
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_RX_NOTIFY] = 0;
|
|
ringBufferLength =
|
|
serHandle->ringBuffer.ringHead + serHandle->ringBuffer.ringBufferSize - serHandle->ringBuffer.ringTail;
|
|
ringBufferLength = ringBufferLength % serHandle->ringBuffer.ringBufferSize;
|
|
EnableGlobalIRQ(primask);
|
|
/* Notify there are data in ringbuffer */
|
|
if (0U != ringBufferLength)
|
|
{
|
|
serialMsg.buffer = NULL;
|
|
serialMsg.length = ringBufferLength;
|
|
if ((NULL != serHandle->openedReadHandleHead) && (NULL != serHandle->openedReadHandleHead->callback))
|
|
{
|
|
serHandle->openedReadHandleHead->callback(serHandle->openedReadHandleHead->callbackParam, &serialMsg,
|
|
kStatus_SerialManager_Notify);
|
|
}
|
|
}
|
|
}
|
|
#endif /* SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
|
|
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
}
|
|
} while (0U != gUseRtos_c);
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
static void SerialManager_TxCallback(void *callbackParam,
|
|
serial_manager_callback_message_t *message,
|
|
serial_manager_status_t status)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
serial_manager_write_handle_t *writeHandle;
|
|
#if (defined(OSA_USED))
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
/* Need to support common_task. */
|
|
#else /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
uint32_t primask;
|
|
#endif
|
|
#endif
|
|
assert(NULL != callbackParam);
|
|
assert(NULL != message);
|
|
|
|
serHandle = (serial_manager_handle_t *)callbackParam;
|
|
|
|
writeHandle = (serial_manager_write_handle_t *)(void *)LIST_GetHead(&serHandle->runningWriteHandleHead);
|
|
|
|
if (NULL != writeHandle)
|
|
{
|
|
SerialManager_RemoveHead(&serHandle->runningWriteHandleHead);
|
|
|
|
#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
/* Need to support common_task. */
|
|
#else /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]++;
|
|
EnableGlobalIRQ(primask);
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serHandle->serSemaphore);
|
|
|
|
#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
if (kSerialManager_TransmissionBlocking == writeHandle->transfer.mode)
|
|
{
|
|
(void)SerialManager_StartWriting(serHandle);
|
|
}
|
|
#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
|
|
writeHandle->transfer.soFar = message->length;
|
|
writeHandle->transfer.status = status;
|
|
if (kSerialManager_TransmissionNonBlocking == writeHandle->transfer.mode)
|
|
{
|
|
SerialManager_AddTail(&serHandle->completedWriteHandleHead, writeHandle);
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
serHandle->commontaskMsg.callback = SerialManager_Task;
|
|
serHandle->commontaskMsg.callbackParam = serHandle;
|
|
COMMON_TASK_post_message(&serHandle->commontaskMsg);
|
|
#else
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_SENT]++;
|
|
EnableGlobalIRQ(primask);
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serHandle->serSemaphore);
|
|
#endif
|
|
|
|
#else
|
|
SerialManager_Task(serHandle);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
writeHandle->transfer.buffer = NULL;
|
|
(void)SerialManager_ReleaseLpConstraint(gSerialManagerLpConstraint_c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SerialManager_RxCallback(void *callbackParam,
|
|
serial_manager_callback_message_t *message,
|
|
serial_manager_status_t status);
|
|
void SerialManager_RxCallback(void *callbackParam,
|
|
serial_manager_callback_message_t *message,
|
|
serial_manager_status_t status)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
#if (!((defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))) && \
|
|
!((defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))))
|
|
uint32_t ringBufferLength = 0;
|
|
uint32_t primask;
|
|
#endif
|
|
assert(NULL != callbackParam);
|
|
assert(NULL != message);
|
|
|
|
serHandle = (serial_manager_handle_t *)callbackParam;
|
|
#if ((defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U)) || \
|
|
(defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U)))
|
|
serHandle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;
|
|
serHandle->openedReadHandleHead->transfer.soFar = message->length;
|
|
serHandle->openedReadHandleHead->transfer.length = message->length;
|
|
serHandle->openedReadHandleHead->transfer.buffer = message->buffer;
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
serHandle->commontaskMsg.callback = SerialManager_Task;
|
|
serHandle->commontaskMsg.callbackParam = serHandle;
|
|
COMMON_TASK_post_message(&serHandle->commontaskMsg);
|
|
#else
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_RECEIVED]++;
|
|
EnableGlobalIRQ(primask);
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serHandle->serSemaphore);
|
|
#endif
|
|
|
|
#else
|
|
SerialManager_Task(serHandle);
|
|
#endif
|
|
#else
|
|
status = kStatus_SerialManager_Notify;
|
|
|
|
primask = DisableGlobalIRQ();
|
|
|
|
/* If wrap around is expected copy byte one after the other. Note that this could also be done with 2 memcopy for
|
|
* better efficiency. */
|
|
if (serHandle->ringBuffer.ringHead + message->length >= serHandle->ringBuffer.ringBufferSize)
|
|
{
|
|
for (uint32_t i = 0; i < message->length; i++)
|
|
{
|
|
serHandle->ringBuffer.ringBuffer[serHandle->ringBuffer.ringHead++] = message->buffer[i];
|
|
|
|
if (serHandle->ringBuffer.ringHead >= serHandle->ringBuffer.ringBufferSize)
|
|
{
|
|
serHandle->ringBuffer.ringHead = 0U;
|
|
}
|
|
if (serHandle->ringBuffer.ringHead == serHandle->ringBuffer.ringTail)
|
|
{
|
|
status = kStatus_SerialManager_RingBufferOverflow;
|
|
serHandle->ringBuffer.ringTail++;
|
|
if (serHandle->ringBuffer.ringTail >= serHandle->ringBuffer.ringBufferSize)
|
|
{
|
|
serHandle->ringBuffer.ringTail = 0U;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else /*No wrap is expected so do a memcpy*/
|
|
{
|
|
(void)memcpy(&serHandle->ringBuffer.ringBuffer[serHandle->ringBuffer.ringHead], message->buffer,
|
|
message->length);
|
|
serHandle->ringBuffer.ringHead += message->length;
|
|
}
|
|
|
|
ringBufferLength =
|
|
serHandle->ringBuffer.ringHead + serHandle->ringBuffer.ringBufferSize - serHandle->ringBuffer.ringTail;
|
|
ringBufferLength = ringBufferLength % serHandle->ringBuffer.ringBufferSize;
|
|
|
|
if ((NULL != serHandle->openedReadHandleHead) && (NULL != serHandle->openedReadHandleHead->transfer.buffer))
|
|
{
|
|
if (serHandle->openedReadHandleHead->transfer.length > serHandle->openedReadHandleHead->transfer.soFar)
|
|
{
|
|
uint32_t remainLength =
|
|
serHandle->openedReadHandleHead->transfer.length - serHandle->openedReadHandleHead->transfer.soFar;
|
|
for (uint32_t i = 0; i < MIN(ringBufferLength, remainLength); i++)
|
|
{
|
|
serHandle->openedReadHandleHead->transfer.buffer[serHandle->openedReadHandleHead->transfer.soFar] =
|
|
serHandle->ringBuffer.ringBuffer[serHandle->ringBuffer.ringTail];
|
|
serHandle->ringBuffer.ringTail++;
|
|
serHandle->openedReadHandleHead->transfer.soFar++;
|
|
if (serHandle->ringBuffer.ringTail >= serHandle->ringBuffer.ringBufferSize)
|
|
{
|
|
serHandle->ringBuffer.ringTail = 0U;
|
|
}
|
|
}
|
|
ringBufferLength = ringBufferLength - MIN(ringBufferLength, remainLength);
|
|
}
|
|
|
|
if (serHandle->openedReadHandleHead->transfer.length > serHandle->openedReadHandleHead->transfer.soFar)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if (kSerialManager_TransmissionBlocking == serHandle->openedReadHandleHead->transfer.mode)
|
|
{
|
|
serHandle->openedReadHandleHead->transfer.buffer = NULL;
|
|
}
|
|
else
|
|
{
|
|
serHandle->openedReadHandleHead->transfer.status = kStatus_SerialManager_Success;
|
|
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
serHandle->commontaskMsg.callback = SerialManager_Task;
|
|
serHandle->commontaskMsg.callbackParam = serHandle;
|
|
COMMON_TASK_post_message(&serHandle->commontaskMsg);
|
|
#else
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_RECEIVED]++;
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serHandle->serSemaphore);
|
|
#endif
|
|
|
|
#else
|
|
SerialManager_Task(serHandle);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
#if (defined(SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL) && (SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL > 0U))
|
|
uint32_t ringBufferWaterMark =
|
|
serHandle->ringBuffer.ringHead + serHandle->ringBuffer.ringBufferSize - serHandle->ringBuffer.ringTail;
|
|
ringBufferWaterMark = ringBufferWaterMark % serHandle->ringBuffer.ringBufferSize;
|
|
if (ringBufferWaterMark < (uint32_t)(serHandle->ringBuffer.ringBufferSize * RINGBUFFER_WATERMARK_THRESHOLD))
|
|
{
|
|
(void)SerialManager_StartReading(serHandle, serHandle->openedReadHandleHead, NULL, ringBufferLength);
|
|
}
|
|
#else
|
|
(void)SerialManager_StartReading(serHandle, serHandle->openedReadHandleHead, NULL, ringBufferLength);
|
|
#endif
|
|
if (0U != ringBufferLength)
|
|
{
|
|
#if (defined(SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY) && (SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY > 0U))
|
|
if (serHandle->serialManagerState[SERIAL_EVENT_DATA_RX_NOTIFY] == 0)
|
|
{
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_RX_NOTIFY]++;
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serHandle->serSemaphore);
|
|
}
|
|
|
|
(void)status; /* Fix "set but never used" warning. */
|
|
#else /* !SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
|
|
message->buffer = NULL;
|
|
message->length = ringBufferLength;
|
|
if ((NULL != serHandle->openedReadHandleHead) && (NULL != serHandle->openedReadHandleHead->callback))
|
|
{
|
|
serHandle->openedReadHandleHead->callback(serHandle->openedReadHandleHead->callbackParam, message, status);
|
|
}
|
|
#endif /* SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY */
|
|
}
|
|
|
|
#if (!((defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))) && \
|
|
!((defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))))
|
|
if (kSerialManager_Blocking ==
|
|
serHandle->handleType) /* No need to check for (NULL != serHandle->openedReadHandleHead) condition as it is
|
|
already done in SerialManager_StartReading() */
|
|
#else
|
|
if (NULL != serHandle->openedReadHandleHead)
|
|
#endif
|
|
{
|
|
ringBufferLength = serHandle->ringBuffer.ringBufferSize - 1U - ringBufferLength;
|
|
(void)SerialManager_StartReading(serHandle, serHandle->openedReadHandleHead, NULL, ringBufferLength);
|
|
}
|
|
EnableGlobalIRQ(primask);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* This function is used for perdiodic check if the transfer is complete, and will be called in blocking transfer at
|
|
* non-blocking mode. The perdiodic unit is ms and default value is define by
|
|
* SERIAL_MANAGER_WRITE_TIME_DELAY_DEFAULT_VALUE/SERIAL_MANAGER_READ_TIME_DELAY_DEFAULT_VALUE. The function
|
|
* SerialManager_WriteTimeDelay()/SerialManager_ReadTimeDelay() is a weak function, so it could be re-implemented by
|
|
* upper layer.
|
|
*/
|
|
__WEAK_FUNC void SerialManager_WriteTimeDelay(uint32_t ms);
|
|
__WEAK_FUNC void SerialManager_WriteTimeDelay(uint32_t ms)
|
|
{
|
|
#if defined(OSA_USED)
|
|
OSA_TimeDelay(ms);
|
|
#endif
|
|
}
|
|
|
|
__WEAK_FUNC void SerialManager_ReadTimeDelay(uint32_t ms);
|
|
__WEAK_FUNC void SerialManager_ReadTimeDelay(uint32_t ms)
|
|
{
|
|
#if defined(OSA_USED)
|
|
OSA_TimeDelay(ms);
|
|
#endif
|
|
}
|
|
|
|
static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle,
|
|
uint8_t *buffer,
|
|
uint32_t length,
|
|
serial_manager_transmission_mode_t mode)
|
|
{
|
|
serial_manager_write_handle_t *serialWriteHandle;
|
|
serial_manager_handle_t *serHandle;
|
|
|
|
#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
/* Need to support common_task. */
|
|
#else /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
/* Do nothing. */
|
|
#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
serial_manager_status_t status = kStatus_SerialManager_Success;
|
|
#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
|
|
uint32_t primask;
|
|
uint8_t isEmpty = 0U;
|
|
|
|
assert(NULL != writeHandle);
|
|
assert(NULL != buffer);
|
|
assert(length > 0U);
|
|
|
|
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
|
|
serHandle = serialWriteHandle->serialManagerHandle;
|
|
assert(NULL != serHandle);
|
|
|
|
assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
|
|
assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialWriteHandle->callback)));
|
|
|
|
primask = DisableGlobalIRQ();
|
|
if (NULL != serialWriteHandle->transfer.buffer)
|
|
{
|
|
EnableGlobalIRQ(primask);
|
|
return kStatus_SerialManager_Busy;
|
|
}
|
|
serialWriteHandle->transfer.buffer = buffer;
|
|
serialWriteHandle->transfer.length = length;
|
|
serialWriteHandle->transfer.soFar = 0U;
|
|
serialWriteHandle->transfer.mode = mode;
|
|
|
|
if (NULL == LIST_GetHead(&serHandle->runningWriteHandleHead))
|
|
{
|
|
isEmpty = 1U;
|
|
}
|
|
SerialManager_AddTail(&serHandle->runningWriteHandleHead, serialWriteHandle);
|
|
EnableGlobalIRQ(primask);
|
|
|
|
if (0U != isEmpty)
|
|
{
|
|
#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
/* Need to support common_task. */
|
|
#else /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]++;
|
|
EnableGlobalIRQ(primask);
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serHandle->serSemaphore);
|
|
|
|
#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
status = SerialManager_StartWriting(serHandle);
|
|
if ((serial_manager_status_t)kStatus_SerialManager_Success != status)
|
|
{
|
|
#if (defined(USB_CDC_SERIAL_MANAGER_RUN_NO_HOST) && (USB_CDC_SERIAL_MANAGER_RUN_NO_HOST == 1))
|
|
if (status == kStatus_SerialManager_NotConnected)
|
|
{
|
|
SerialManager_RemoveHead(&serHandle->runningWriteHandleHead);
|
|
serialWriteHandle->transfer.buffer = 0U;
|
|
serialWriteHandle->transfer.length = 0U;
|
|
}
|
|
#endif /* USB_CDC_SERIAL_MANAGER_RUN_NO_HOST == 1 */
|
|
return status;
|
|
}
|
|
#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
}
|
|
|
|
if (kSerialManager_TransmissionBlocking == mode)
|
|
{
|
|
while (serialWriteHandle->transfer.length > serialWriteHandle->transfer.soFar)
|
|
{
|
|
if (SerialManager_needPollingIsr())
|
|
{
|
|
SerialManager_IsrFunction(serHandle);
|
|
}
|
|
else
|
|
{
|
|
SerialManager_WriteTimeDelay(SERIAL_MANAGER_WRITE_TIME_DELAY_DEFAULT_VALUE);
|
|
}
|
|
}
|
|
}
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle,
|
|
uint8_t *buffer,
|
|
uint32_t length,
|
|
serial_manager_transmission_mode_t mode,
|
|
uint32_t *receivedLength)
|
|
{
|
|
serial_manager_read_handle_t *serialReadHandle;
|
|
serial_manager_handle_t *serHandle;
|
|
uint32_t dataLength;
|
|
uint32_t primask;
|
|
|
|
assert(NULL != readHandle);
|
|
assert(NULL != buffer);
|
|
assert(length > 0U);
|
|
|
|
serialReadHandle = (serial_manager_read_handle_t *)readHandle;
|
|
|
|
serHandle = serialReadHandle->serialManagerHandle;
|
|
assert(NULL != serHandle);
|
|
|
|
assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
|
|
assert(!((kSerialManager_TransmissionNonBlocking == mode) && (NULL == serialReadHandle->callback)));
|
|
|
|
primask = DisableGlobalIRQ();
|
|
if (NULL != serialReadHandle->transfer.buffer)
|
|
{
|
|
EnableGlobalIRQ(primask);
|
|
return kStatus_SerialManager_Busy;
|
|
}
|
|
serialReadHandle->transfer.buffer = buffer;
|
|
serialReadHandle->transfer.length = length;
|
|
serialReadHandle->transfer.soFar = 0U;
|
|
serialReadHandle->transfer.mode = mode;
|
|
|
|
/* This code is reached if (serHandle->handleType != kSerialManager_Blocking)*/
|
|
#if (!((defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))) && \
|
|
!((defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))))
|
|
if (length == 1U)
|
|
{
|
|
if (serHandle->ringBuffer.ringHead != serHandle->ringBuffer.ringTail)
|
|
{
|
|
buffer[serialReadHandle->transfer.soFar++] =
|
|
serHandle->ringBuffer.ringBuffer[serHandle->ringBuffer.ringTail];
|
|
serHandle->ringBuffer.ringTail++;
|
|
if (serHandle->ringBuffer.ringTail >= serHandle->ringBuffer.ringBufferSize)
|
|
{
|
|
serHandle->ringBuffer.ringTail = 0U;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
#endif /*(!defined(SERIAL_PORT_TYPE_USBCDC) && !defined(SERIAL_PORT_TYPE_VIRTUAL))*/
|
|
{
|
|
dataLength =
|
|
serHandle->ringBuffer.ringHead + serHandle->ringBuffer.ringBufferSize - serHandle->ringBuffer.ringTail;
|
|
dataLength = dataLength % serHandle->ringBuffer.ringBufferSize;
|
|
|
|
for (serialReadHandle->transfer.soFar = 0U; serialReadHandle->transfer.soFar < MIN(dataLength, length);
|
|
serialReadHandle->transfer.soFar++)
|
|
{
|
|
buffer[serialReadHandle->transfer.soFar] = serHandle->ringBuffer.ringBuffer[serHandle->ringBuffer.ringTail];
|
|
serHandle->ringBuffer.ringTail++;
|
|
if (serHandle->ringBuffer.ringTail >= serHandle->ringBuffer.ringBufferSize)
|
|
{
|
|
serHandle->ringBuffer.ringTail = 0U;
|
|
}
|
|
}
|
|
|
|
dataLength =
|
|
serHandle->ringBuffer.ringHead + serHandle->ringBuffer.ringBufferSize - serHandle->ringBuffer.ringTail;
|
|
dataLength = dataLength % serHandle->ringBuffer.ringBufferSize;
|
|
dataLength = serHandle->ringBuffer.ringBufferSize - 1U - dataLength;
|
|
|
|
(void)SerialManager_StartReading(serHandle, readHandle, NULL, dataLength);
|
|
}
|
|
|
|
if (NULL != receivedLength)
|
|
{
|
|
*receivedLength = serialReadHandle->transfer.soFar;
|
|
serialReadHandle->transfer.buffer = NULL;
|
|
EnableGlobalIRQ(primask);
|
|
}
|
|
else
|
|
{
|
|
if (serialReadHandle->transfer.soFar >= serialReadHandle->transfer.length)
|
|
{
|
|
serialReadHandle->transfer.buffer = NULL;
|
|
EnableGlobalIRQ(primask);
|
|
if (kSerialManager_TransmissionNonBlocking == mode)
|
|
{
|
|
if (NULL != serialReadHandle->callback)
|
|
{
|
|
serial_manager_callback_message_t serialMsg;
|
|
serialMsg.buffer = buffer;
|
|
serialMsg.length = serialReadHandle->transfer.soFar;
|
|
serialReadHandle->callback(serialReadHandle->callbackParam, &serialMsg,
|
|
kStatus_SerialManager_Success);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EnableGlobalIRQ(primask);
|
|
}
|
|
|
|
if (kSerialManager_TransmissionBlocking == mode)
|
|
{
|
|
while (serialReadHandle->transfer.length > serialReadHandle->transfer.soFar)
|
|
{
|
|
SerialManager_ReadTimeDelay(SERIAL_MANAGER_READ_TIME_DELAY_DEFAULT_VALUE);
|
|
}
|
|
}
|
|
}
|
|
#if (defined(SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL) && (SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL > 0U))
|
|
uint32_t ringBufferWaterMark =
|
|
serHandle->ringBuffer.ringHead + serHandle->ringBuffer.ringBufferSize - serHandle->ringBuffer.ringTail;
|
|
ringBufferWaterMark = ringBufferWaterMark % serHandle->ringBuffer.ringBufferSize;
|
|
if (ringBufferWaterMark < (uint32_t)(serHandle->ringBuffer.ringBufferSize * RINGBUFFER_WATERMARK_THRESHOLD))
|
|
{
|
|
(void)SerialManager_StartReading(serHandle, serHandle->openedReadHandleHead, NULL,
|
|
serialReadHandle->transfer.length);
|
|
}
|
|
#endif
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
#else
|
|
|
|
static serial_manager_status_t SerialManager_Write(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
|
|
{
|
|
serial_manager_write_handle_t *serialWriteHandle;
|
|
serial_manager_handle_t *serHandle;
|
|
|
|
assert(writeHandle);
|
|
assert(buffer);
|
|
assert(length);
|
|
|
|
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
|
|
serHandle = serialWriteHandle->serialManagerHandle;
|
|
|
|
assert(serHandle);
|
|
|
|
return SerialManager_StartWriting(serHandle, serialWriteHandle, buffer, length);
|
|
}
|
|
|
|
static serial_manager_status_t SerialManager_Read(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
|
|
{
|
|
serial_manager_read_handle_t *serialReadHandle;
|
|
serial_manager_handle_t *serHandle;
|
|
|
|
assert(readHandle);
|
|
assert(buffer);
|
|
assert(length);
|
|
|
|
serialReadHandle = (serial_manager_read_handle_t *)readHandle;
|
|
serHandle = serialReadHandle->serialManagerHandle;
|
|
|
|
assert(serHandle);
|
|
|
|
return SerialManager_StartReading(serHandle, serialReadHandle, buffer, length);
|
|
}
|
|
#endif
|
|
|
|
serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, const serial_manager_config_t *serialConfig)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
serial_manager_status_t status = kStatus_SerialManager_Error;
|
|
|
|
assert(NULL != serialConfig);
|
|
|
|
assert(NULL != serialHandle);
|
|
assert(SERIAL_MANAGER_HANDLE_SIZE >= sizeof(serial_manager_handle_t));
|
|
|
|
serHandle = (serial_manager_handle_t *)serialHandle;
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
assert(NULL != serialConfig->ringBuffer);
|
|
assert(serialConfig->ringBufferSize > 0U);
|
|
(void)memset(serHandle, 0, SERIAL_MANAGER_HANDLE_SIZE);
|
|
serHandle->handleType = serialConfig->blockType;
|
|
#else
|
|
(void)memset(serHandle, 0, SERIAL_MANAGER_HANDLE_SIZE);
|
|
#endif
|
|
serHandle->serialPortType = serialConfig->type;
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
serHandle->ringBuffer.ringBuffer = serialConfig->ringBuffer;
|
|
serHandle->ringBuffer.ringBufferSize = serialConfig->ringBufferSize;
|
|
#endif
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
|
|
COMMON_TASK_init();
|
|
|
|
#else
|
|
if (KOSA_StatusSuccess != OSA_SemaphoreCreate((osa_semaphore_handle_t)serHandle->serSemaphore, 1U))
|
|
{
|
|
return kStatus_SerialManager_Error;
|
|
}
|
|
|
|
if (KOSA_StatusSuccess != OSA_TaskCreate((osa_task_handle_t)serHandle->taskId, OSA_TASK(SerialManager_Task), serHandle))
|
|
{
|
|
return kStatus_SerialManager_Error;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
switch (serialConfig->type)
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
case kSerialPort_Uart:
|
|
status = Serial_UartInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
|
|
{
|
|
(void)Serial_UartInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
|
|
(void)Serial_UartInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
|
|
case kSerialPort_UartDma:
|
|
status = Serial_UartDmaInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if ((serial_manager_status_t)kStatus_SerialManager_Success == status)
|
|
{
|
|
(void)Serial_UartDmaInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
|
|
(void)Serial_UartDmaInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
case kSerialPort_UsbCdc:
|
|
status = Serial_UsbCdcInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_UsbCdcInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_UsbCdcInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
case kSerialPort_Swo:
|
|
status = Serial_SwoInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_SwoInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Virtual:
|
|
status =
|
|
Serial_PortVirtualInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_PortVirtualInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_PortVirtualInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
|
|
case kSerialPort_Rpmsg:
|
|
status = Serial_RpmsgInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), (void *)serialConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_RpmsgInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_RpmsgInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
case kSerialPort_SpiMaster:
|
|
status =
|
|
Serial_SpiMasterInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_SpiMasterInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_SpiMasterInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
case kSerialPort_SpiSlave:
|
|
status = Serial_SpiSlaveInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_SpiSlaveInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_SpiSlaveInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
case kSerialPort_BleWu:
|
|
status =
|
|
Serial_PortBleWuInit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]), serialConfig->portConfig);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_PortBleWuInstallTxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_TxCallback, serHandle);
|
|
if (kStatus_SerialManager_Success == status)
|
|
{
|
|
status = Serial_PortBleWuInstallRxCallback(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]),
|
|
SerialManager_RxCallback, serHandle);
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
#endif
|
|
default:
|
|
/*MISRA rule 16.4*/
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
|
|
serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
|
|
|
|
assert(NULL != serialHandle);
|
|
|
|
serHandle = (serial_manager_handle_t *)serialHandle;
|
|
|
|
if ((NULL != serHandle->openedReadHandleHead) || (0U != serHandle->openedWriteHandleCount))
|
|
{
|
|
serialManagerStatus = kStatus_SerialManager_Busy; /*Serial Manager Busy*/
|
|
}
|
|
else
|
|
{
|
|
switch (serHandle->serialPortType) /*serial port type*/
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
case kSerialPort_Uart:
|
|
(void)Serial_UartDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
case kSerialPort_UsbCdc:
|
|
(void)Serial_UsbCdcDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
case kSerialPort_Swo:
|
|
(void)Serial_SwoDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Virtual:
|
|
(void)Serial_PortVirtualDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
|
|
case kSerialPort_Rpmsg:
|
|
(void)Serial_RpmsgDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
case kSerialPort_SpiSlave:
|
|
(void)Serial_SpiSlaveDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
case kSerialPort_SpiMaster:
|
|
(void)Serial_SpiMasterDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
case kSerialPort_BleWu:
|
|
(void)Serial_PortBleWuDeinit(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
default:
|
|
/*MISRA rule 16.4*/
|
|
break;
|
|
}
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
#else
|
|
(void)OSA_SemaphoreDestroy((osa_event_handle_t)serHandle->serSemaphore);
|
|
(void)OSA_TaskDestroy((osa_task_handle_t)serHandle->taskId);
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
return serialManagerStatus;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
serial_manager_write_handle_t *serialWriteHandle;
|
|
uint32_t primask;
|
|
|
|
assert(NULL != serialHandle);
|
|
assert(NULL != writeHandle);
|
|
assert(SERIAL_MANAGER_WRITE_HANDLE_SIZE >= sizeof(serial_manager_write_handle_t));
|
|
|
|
serHandle = (serial_manager_handle_t *)serialHandle;
|
|
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
|
|
|
|
primask = DisableGlobalIRQ();
|
|
serHandle->openedWriteHandleCount++;
|
|
EnableGlobalIRQ(primask);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (serHandle->handleType == kSerialManager_Blocking)
|
|
{
|
|
serialWriteHandle->serialManagerHandle = serHandle;
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
(void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
|
|
}
|
|
|
|
serialWriteHandle->serialManagerHandle = serHandle;
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
serialWriteHandle->tag = SERIAL_MANAGER_WRITE_TAG;
|
|
#endif
|
|
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle)
|
|
{
|
|
serial_manager_handle_t *serialHandle;
|
|
serial_manager_write_handle_t *serialWriteHandle;
|
|
uint32_t primask;
|
|
|
|
assert(NULL != writeHandle);
|
|
|
|
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
|
|
serialHandle = (serial_manager_handle_t *)(void *)serialWriteHandle->serialManagerHandle;
|
|
|
|
assert(NULL != serialHandle);
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
|
|
#endif
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
(void)SerialManager_CancelWriting(writeHandle);
|
|
#endif
|
|
primask = DisableGlobalIRQ();
|
|
if (serialHandle->openedWriteHandleCount > 0U)
|
|
{
|
|
serialHandle->openedWriteHandleCount--;
|
|
}
|
|
EnableGlobalIRQ(primask);
|
|
#if (defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && (DEBUG_CONSOLE_TRANSFER_NON_BLOCKING > 0U))
|
|
(void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_HANDLE_SIZE);
|
|
#else
|
|
(void)memset(writeHandle, 0, SERIAL_MANAGER_WRITE_BLOCK_HANDLE_SIZE);
|
|
#endif
|
|
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
serial_manager_read_handle_t *serialReadHandle; /* read handle structure */
|
|
serial_manager_status_t serialManagerStatus = kStatus_SerialManager_Success;
|
|
uint32_t primask;
|
|
|
|
assert(NULL != serialHandle);
|
|
assert(NULL != readHandle);
|
|
assert(SERIAL_MANAGER_READ_HANDLE_SIZE >= sizeof(serial_manager_read_handle_t));
|
|
|
|
serHandle = (serial_manager_handle_t *)serialHandle;
|
|
serialReadHandle = (serial_manager_read_handle_t *)readHandle;
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
if (serHandle->handleType == kSerialManager_Blocking)
|
|
{
|
|
serialReadHandle->serialManagerHandle = serHandle;
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
#endif
|
|
primask = DisableGlobalIRQ();
|
|
if (serHandle->openedReadHandleHead != NULL)
|
|
{
|
|
serialManagerStatus = kStatus_SerialManager_Busy;
|
|
}
|
|
else
|
|
{
|
|
serHandle->openedReadHandleHead = serialReadHandle;
|
|
|
|
(void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
|
|
|
|
serialReadHandle->serialManagerHandle = serHandle;
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
serialReadHandle->tag = SERIAL_MANAGER_READ_TAG;
|
|
#endif
|
|
}
|
|
EnableGlobalIRQ(primask);
|
|
return serialManagerStatus;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle)
|
|
{
|
|
serial_manager_handle_t *serialHandle;
|
|
serial_manager_read_handle_t *serialReadHandle;
|
|
uint32_t primask;
|
|
|
|
assert(NULL != readHandle);
|
|
|
|
serialReadHandle = (serial_manager_read_handle_t *)readHandle;
|
|
serialHandle = (serial_manager_handle_t *)(void *)serialReadHandle->serialManagerHandle;
|
|
|
|
assert((NULL != serialHandle) && (serialHandle->openedReadHandleHead == serialReadHandle));
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
|
|
#endif
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
(void)SerialManager_CancelReading(readHandle);
|
|
#endif
|
|
|
|
primask = DisableGlobalIRQ();
|
|
serialHandle->openedReadHandleHead = NULL;
|
|
EnableGlobalIRQ(primask);
|
|
#if (defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && (DEBUG_CONSOLE_TRANSFER_NON_BLOCKING > 0U))
|
|
(void)memset(readHandle, 0, SERIAL_MANAGER_READ_HANDLE_SIZE);
|
|
#else
|
|
(void)memset(readHandle, 0, SERIAL_MANAGER_READ_BLOCK_HANDLE_SIZE);
|
|
#endif
|
|
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle, uint8_t *buffer, uint32_t length)
|
|
{
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionBlocking);
|
|
#else
|
|
return SerialManager_Write(writeHandle, buffer, length);
|
|
#endif
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
|
|
{
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, NULL);
|
|
#else
|
|
return SerialManager_Read(readHandle, buffer, length);
|
|
#endif
|
|
}
|
|
|
|
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
|
|
serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,
|
|
uint8_t *buffer,
|
|
uint32_t length)
|
|
{
|
|
return SerialManager_Write(writeHandle, buffer, length, kSerialManager_TransmissionNonBlocking);
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length)
|
|
{
|
|
#if ((defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U)) || \
|
|
(defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U)))
|
|
|
|
serial_manager_read_handle_t *serialReadHandle;
|
|
serialReadHandle = (serial_manager_read_handle_t *)readHandle;
|
|
|
|
return (serial_manager_status_t)SerialManager_StartReading(serialReadHandle->serialManagerHandle, readHandle,
|
|
buffer, length);
|
|
#else
|
|
return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionNonBlocking, NULL);
|
|
#endif
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle)
|
|
{
|
|
serial_manager_write_handle_t *serialWriteHandle;
|
|
uint32_t primask;
|
|
uint8_t isNotUsed = 0U;
|
|
uint8_t isNotNeed2Cancel = 0U;
|
|
|
|
assert(NULL != writeHandle);
|
|
|
|
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
|
|
|
|
assert(NULL != serialWriteHandle->serialManagerHandle);
|
|
assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
|
|
|
|
if ((NULL != serialWriteHandle->transfer.buffer) &&
|
|
(kSerialManager_TransmissionBlocking == serialWriteHandle->transfer.mode))
|
|
{
|
|
return kStatus_SerialManager_Error;
|
|
}
|
|
|
|
primask = DisableGlobalIRQ();
|
|
if (serialWriteHandle != (serial_manager_write_handle_t *)(void *)LIST_GetHead(
|
|
&serialWriteHandle->serialManagerHandle->runningWriteHandleHead))
|
|
{
|
|
if (kLIST_Ok == LIST_RemoveElement(&serialWriteHandle->link))
|
|
{
|
|
isNotUsed = 1U;
|
|
}
|
|
else
|
|
{
|
|
isNotNeed2Cancel = 1U;
|
|
}
|
|
}
|
|
EnableGlobalIRQ(primask);
|
|
|
|
if (0U == isNotNeed2Cancel)
|
|
{
|
|
if (0U != isNotUsed)
|
|
{
|
|
serialWriteHandle->transfer.soFar = 0;
|
|
serialWriteHandle->transfer.status = kStatus_SerialManager_Canceled;
|
|
|
|
SerialManager_AddTail(&serialWriteHandle->serialManagerHandle->completedWriteHandleHead, serialWriteHandle);
|
|
#if defined(OSA_USED)
|
|
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
serialWriteHandle->serialManagerHandle->commontaskMsg.callback = SerialManager_Task;
|
|
serialWriteHandle->serialManagerHandle->commontaskMsg.callbackParam =
|
|
serialWriteHandle->serialManagerHandle;
|
|
COMMON_TASK_post_message(&serialWriteHandle->serialManagerHandle->commontaskMsg);
|
|
#else
|
|
primask = DisableGlobalIRQ();
|
|
serialWriteHandle->serialManagerHandle->serialManagerState[SERIAL_EVENT_DATA_SENT]++;
|
|
EnableGlobalIRQ(primask);
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serialWriteHandle->serialManagerHandle->serSemaphore);
|
|
#endif
|
|
|
|
#else
|
|
SerialManager_Task(serialWriteHandle->serialManagerHandle);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
switch (serialWriteHandle->serialManagerHandle->serialPortType)
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
case kSerialPort_Uart:
|
|
(void)Serial_UartCancelWrite(
|
|
((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
case kSerialPort_UsbCdc:
|
|
(void)Serial_UsbCdcCancelWrite(
|
|
((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
case kSerialPort_Swo:
|
|
(void)Serial_SwoCancelWrite(
|
|
((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Virtual:
|
|
(void)Serial_PortVirtualCancelWrite(
|
|
((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
case kSerialPort_SpiMaster:
|
|
(void)Serial_SpiMasterCancelWrite(
|
|
((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
case kSerialPort_SpiSlave:
|
|
(void)Serial_SpiSlaveCancelWrite(
|
|
((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
case kSerialPort_BleWu:
|
|
(void)Serial_PortBleWuCancelWrite(
|
|
((serial_handle_t)&serialWriteHandle->serialManagerHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
default:
|
|
/*MISRA rule 16.4*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if (defined(OSA_USED) && defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX == 1))
|
|
#if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
|
|
/* Need to support common_task. */
|
|
#else /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
primask = DisableGlobalIRQ();
|
|
serialWriteHandle->serialManagerHandle->serialManagerState[SERIAL_EVENT_DATA_START_SEND]++;
|
|
EnableGlobalIRQ(primask);
|
|
(void)OSA_SemaphorePost((osa_semaphore_handle_t)serialWriteHandle->serialManagerHandle->serSemaphore);
|
|
|
|
#endif /* SERIAL_MANAGER_USE_COMMON_TASK */
|
|
#else /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
(void)SerialManager_StartWriting(serialWriteHandle->serialManagerHandle);
|
|
#endif /* OSA_USED && SERIAL_MANAGER_TASK_HANDLE_TX */
|
|
}
|
|
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle)
|
|
{
|
|
serial_manager_read_handle_t *serialReadHandle;
|
|
serial_manager_callback_message_t serialMsg;
|
|
uint8_t *buffer;
|
|
uint32_t primask;
|
|
|
|
assert(NULL != readHandle);
|
|
|
|
serialReadHandle = (serial_manager_read_handle_t *)readHandle;
|
|
|
|
assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
|
|
|
|
if ((NULL != serialReadHandle->transfer.buffer) &&
|
|
(kSerialManager_TransmissionBlocking == serialReadHandle->transfer.mode))
|
|
{
|
|
return kStatus_SerialManager_Error;
|
|
}
|
|
|
|
primask = DisableGlobalIRQ();
|
|
buffer = serialReadHandle->transfer.buffer;
|
|
serialReadHandle->transfer.buffer = NULL;
|
|
serialReadHandle->transfer.length = 0;
|
|
serialMsg.buffer = buffer;
|
|
serialMsg.length = serialReadHandle->transfer.soFar;
|
|
EnableGlobalIRQ(primask);
|
|
|
|
if (NULL != buffer)
|
|
{
|
|
if (NULL != serialReadHandle->callback)
|
|
{
|
|
serialReadHandle->callback(serialReadHandle->callbackParam, &serialMsg, kStatus_SerialManager_Canceled);
|
|
}
|
|
}
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,
|
|
uint8_t *buffer,
|
|
uint32_t length,
|
|
uint32_t *receivedLength)
|
|
{
|
|
assert(NULL != receivedLength);
|
|
|
|
return SerialManager_Read(readHandle, buffer, length, kSerialManager_TransmissionBlocking, receivedLength);
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,
|
|
serial_manager_callback_t callback,
|
|
void *callbackParam)
|
|
{
|
|
serial_manager_write_handle_t *serialWriteHandle;
|
|
|
|
assert(NULL != writeHandle);
|
|
|
|
serialWriteHandle = (serial_manager_write_handle_t *)writeHandle;
|
|
|
|
assert(SERIAL_MANAGER_WRITE_TAG == serialWriteHandle->tag);
|
|
|
|
serialWriteHandle->callbackParam = callbackParam;
|
|
serialWriteHandle->callback = callback;
|
|
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,
|
|
serial_manager_callback_t callback,
|
|
void *callbackParam)
|
|
{
|
|
serial_manager_read_handle_t *serialReadHandle;
|
|
|
|
assert(NULL != readHandle);
|
|
|
|
serialReadHandle = (serial_manager_read_handle_t *)readHandle;
|
|
|
|
assert(SERIAL_MANAGER_READ_TAG == serialReadHandle->tag);
|
|
|
|
serialReadHandle->callbackParam = callbackParam;
|
|
serialReadHandle->callback = callback;
|
|
|
|
return kStatus_SerialManager_Success;
|
|
}
|
|
#endif
|
|
|
|
serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
serial_manager_status_t status = kStatus_SerialManager_Error;
|
|
|
|
assert(NULL != serialHandle);
|
|
|
|
serHandle = (serial_manager_handle_t *)serialHandle;
|
|
|
|
switch (serHandle->serialPortType)
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
case kSerialPort_Uart:
|
|
status = Serial_UartEnterLowpower(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
|
|
case kSerialPort_UartDma:
|
|
status = Serial_UartDmaEnterLowpower(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
case kSerialPort_UsbCdc:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
case kSerialPort_Swo:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Virtual:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Rpmsg:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
case kSerialPort_SpiMaster:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
case kSerialPort_SpiSlave:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
case kSerialPort_BleWu:
|
|
break;
|
|
#endif
|
|
default:
|
|
/*MISRA rule 16.4*/
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle)
|
|
{
|
|
serial_manager_handle_t *serHandle;
|
|
serial_manager_status_t status = kStatus_SerialManager_Error;
|
|
|
|
assert(NULL != serialHandle);
|
|
|
|
serHandle = (serial_manager_handle_t *)serialHandle;
|
|
|
|
switch (serHandle->serialPortType)
|
|
{
|
|
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
|
|
case kSerialPort_Uart:
|
|
status = Serial_UartExitLowpower(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
|
|
#if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
|
|
case kSerialPort_UartDma:
|
|
status = Serial_UartDmaExitLowpower(((serial_handle_t)&serHandle->lowLevelhandleBuffer[0]));
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
|
|
case kSerialPort_UsbCdc:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
|
|
case kSerialPort_Swo:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Virtual:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
|
|
case kSerialPort_Rpmsg:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
|
|
case kSerialPort_SpiMaster:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
|
|
case kSerialPort_SpiSlave:
|
|
break;
|
|
#endif
|
|
#if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
|
|
case kSerialPort_BleWu:
|
|
break;
|
|
#endif
|
|
default:
|
|
/*MISRA rule 16.4*/
|
|
break;
|
|
}
|
|
return status;
|
|
}
|
|
/*!
|
|
* @brief This function performs initialization of the callbacks structure used to disable lowpower
|
|
* when serial manager is active.
|
|
*
|
|
*
|
|
* @param pfCallback Pointer to the function structure used to allow/disable lowpower.
|
|
*
|
|
*/
|
|
void SerialManager_SetLowpowerCriticalCb(const serial_manager_lowpower_critical_CBs_t *pfCallback)
|
|
{
|
|
s_pfserialLowpowerCriticalCallbacks = pfCallback;
|
|
(void)s_pfserialLowpowerCriticalCallbacks;
|
|
}
|