Gitiles
Code Review Sign In
192.168.1.100 / T800_MD_V1.6 / c33b3079c38f91561c2f84f1ebed20ad8c60532a / . / mcu / driver / tty / src / tty_ut.c
blob: a3f16ee69fc35a19cf21db3265b9b7028134002d [file] [log] [blame]
/*****************************************************************************
* Copyright Statement:
* --------------------
* This software is protected by Copyright and the information contained
* herein is confidential. The software may not be copied and the information
* contained herein may not be used or disclosed except with the written
* permission of MediaTek Inc. (C) 2012
*
* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/
/*******************************************************************************
* Filename:
* ---------
* tty_ut.c
*
* Project:
* --------
* MOLY
*
* Description:
* ------------
* TTY Core unit test file - it needs Host Test Program to run test.
*
* Author:
* -------
* -------
*
* ==========================================================================
* $Log$
*
* 09 23 2019 bo-kai.huang
* [MOLY00357061] 97 Code Merge
* [TerTer]
*
* 10 21 2015 mt.tsai
* [MOLY00146136] Fix TTY Core ut program for SMP and set gpd's next to NULL
* give a UT Task instance on each port to prevent race condition & Set gpd's next as NULL
*
* 03 11 2015 i-wei.tsai
* [MOLY00097392] [UMOLY] [TTY] Timer tick macro modification
* .
*
* 06 26 2013 i-wei.tsai
* [MOLY00027496] [TTYCore] Features check-in
* 1. add new TTY_CMD_MTU_SIZE support
* 2. add plug-in/plug-out indication
* 3. fix issue of flushing rx internal gpd
*
* 05 29 2013 haoren.kao
* [MOLY00024108] Support New USB Core
* Replace with New USB Core.
* We sync with the following codes from HaoRen MOLY CBr w1322:
* 1. USB Core
* 2. USB Class - acm/rndis/mbim
* 3. ipcore
* 4. ttycore
* 5. ethercore
*
* 02 21 2013 i-wei.tsai
* [MOLY00010632] add TTYCore new features
* checkin supporting buffer port features
*
* 11 08 2012 haoren.kao
* [MOLY00005322] TATAKA merge to MOLY
*
* MOLY Migration from TATAKA
****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "kal_debug.h"
//#include "kal_release.h"
#include "syscomp_config.h"
#include "kal_debug.h"
#include "dcl.h"
#include "qmu_bm.h"
#include "qmu_bm_util.h"
#include "devdrv_ls.h"
#include "drv_msgid.h"
#include "md_drv_sap.h"
#include "kal_public_defs.h"
#include "kal_public_api.h"
/*for dhl trace*/
#include "dhl_trace.h"
#define TTY_UT_MISC_TEST (0) /* Set 1 to enable owner test and init/deinit test*/
#define USB_TEST
//#undef USB_TEST
#if defined USB_TEST /* USB COM */
#define TTY_UT_COM_NUM 3
#define TTY_UT_COM1 uart_port_usb3
#define TTY_UT_COM2 uart_port_usb4
#define TTY_UT_COM3 uart_port_usb5
#else /* UART COM */
#define TTY_UT_COM_NUM 1
#define TTY_UT_COM1 uart_port2
#define TTY_UT_COM2 uart_port2
#define TTY_UT_COM3 uart_port2
#endif
#if (TTY_UT_COM_NUM > 3)
#error "COM number more than three does not support."
#endif
#define TTY_UT_TASK_1_PRIORITY 1
#define TTY_UT_TASK_2_PRIORITY 2
#define TTY_UT_TASK_3_PRIORITY 3
#define IO_REQUEST_PUSH(_ori, _new) \
{ \
tty_io_request_t *tmp_ior = _ori; \
while (tmp_ior->next_request != NULL) { \
tmp_ior = tmp_ior->next_request; \
} \
tmp_ior->next_request = _new; \
}
#define BUSY_WAIT(_loopCnt) do{unsigned int i,j;for(i=0;i<_loopCnt;i++){j=i;j++;}}while(0)
typedef enum _tty_ut_mode {
TTY_UT_CONV_TX_ONLY = 0,
TTY_UT_NEW_TX_ONLY,
TTY_UT_CONV_RX_ONLY,
TTY_UT_NEW_RX_ONLY,
TTY_UT_CONV_TX_CONV_RX,
TTY_UT_CONV_TX_NEW_RX,
TTY_UT_NEW_TX_CONV_RX,
TTY_UT_NEW_TX_NEW_RX,
TTY_UT_NEW_INIT_CONV_TX_CONV_RX,
TTY_UT_BYPASS, //This is used to disable test procedure
} tty_ut_mode_e;
static tty_ut_mode_e tty_ut_mode_1 = TTY_UT_NEW_TX_NEW_RX; //TTY_UT_NEW_TX_NEW_RX;
static tty_ut_mode_e tty_ut_mode_2 = /*TTY_UT_NEW_TX_NEW_RX;*/ TTY_UT_CONV_TX_CONV_RX;
static tty_ut_mode_e tty_ut_mode_3 = TTY_UT_NEW_TX_CONV_RX;
// for conventional path
#define TTY_UT_NEW_BUF_SIZE QBM_TTY_XXX_DATA_LEN
#define TTY_UT_CONV_BUF_SIZE QBM_TTY_XXX_DATA_LEN*2
#define TTY_UT_LB_CON_TX_TX_BUF_SIZE QBM_TTY_XXX_DATA_LEN*10
#define TTY_UT_CHUNK_SIZE_DEFAULT (QBM_TTY_XXX_DATA_LEN)
typedef struct _ttyut_instance_t {
DCL_HANDLE handle;
DCL_UINT32 owner;
tty_io_request_t *ttyut_rx_ior;
kal_mutexid ttyut_mutex;
kal_uint8 ttyut_rx_buf[TTY_UT_CONV_BUF_SIZE];
kal_uint8 ttyut_tx_buf[TTY_UT_CONV_BUF_SIZE];
kal_uint32 ttyut_tx_offset;
kal_uint32 ttyut_tx_len;
kal_uint8 conv_tx_rx_buf[TTY_UT_LB_CON_TX_TX_BUF_SIZE];
kal_uint32 conv_tx_rx_rd_idx;
kal_uint32 conv_tx_rx_wt_idx;
kal_uint32 conv_tx_rx_wrap;
} ttyut_instance_t;
static ttyut_instance_t ttyut_inst_g[uart_max_port];
#if defined(__MTK_TARGET__)
extern void dbg_print(char *fmt,...);
#define ttyut_print dbg_print
#else
#define ttyut_print(...) dhl_print(TRACE_INFO, DHL_USER_FLAG_NONE, MOD_TTY, ##__VA_ARGS__)
#endif
#define DCL_UART_MAGIC_NUM 0x40000000
#define DCL_UART_GET_DEV(handle_) ((DCL_DEV)((handle_) & (~DCL_UART_MAGIC_NUM)))
// ==========================================================
// Private Function
// ==========================================================
static kal_bool ttyut_create_instance(DCL_HANDLE handle, DCL_UINT32 owner)
{
char mutex_name_str[64];
DCL_DEV uart_port = DCL_UART_GET_DEV(handle);
if (ttyut_inst_g[uart_port].handle == (DCL_HANDLE) 0x0) {
sprintf(mutex_name_str, "TTY_UT_%d", (int)handle);
ttyut_inst_g[uart_port].handle = handle;
ttyut_inst_g[uart_port].owner = owner;
ttyut_inst_g[uart_port].ttyut_rx_ior = NULL;
ttyut_inst_g[uart_port].ttyut_mutex = kal_create_mutex(mutex_name_str);
return KAL_TRUE;
}
// Can't create TTY_UT instance, ASSERT.
ASSERT(0);
return KAL_FALSE;
}
static ttyut_instance_t* ttyut_get_instance(DCL_HANDLE handle)
{
DCL_DEV uart_port = DCL_UART_GET_DEV(handle);
if (ttyut_inst_g[uart_port].handle == handle) {
return &ttyut_inst_g[uart_port];
}
return NULL;
}
// ==========================================================
// Private Function
// ==========================================================
DCL_STATUS _ttyut_rx_cb(DCL_HANDLE handle, module_type source_id, tty_io_request_t *rx_ior)
{
ttyut_instance_t *ttyut_inst_p;
ttyut_inst_p = ttyut_get_instance(handle);
kal_take_mutex(ttyut_inst_p->ttyut_mutex);
if (ttyut_inst_p->ttyut_rx_ior) {
IO_REQUEST_PUSH(ttyut_inst_p->ttyut_rx_ior, rx_ior);
} else {
ttyut_inst_p->ttyut_rx_ior = rx_ior;
}
kal_give_mutex(ttyut_inst_p->ttyut_mutex);
ttyut_print("=========>_ttyut_rx_cb\r\n");
return STATUS_OK;
}
DCL_STATUS _ttyut_tx_done_cb(DCL_HANDLE handle, module_type source_id, tty_io_request_t *tx_ior)
{
if (tx_ior) {
/* free all GPDs of all IOR */
do {
qbmt_dest_q(tx_ior->first_gpd, tx_ior->last_gpd);
} while ((tx_ior = tx_ior->next_request) != NULL);
} else {
ttyut_print("[TTY UT] [ERROR] =========>_ttyut_tx_done_cb : tx_ior is NULL!!!!!\r\n");
}
ttyut_print("=========>_ttyut_tx_done_cb\r\n");
return STATUS_OK;
}
DCL_STATUS _ttyut_drv_state_cb(DCL_HANDLE handle, tty_drv_state_e state)
{
ttyut_print("=========>_ttyut_drv_state_cb: state - %s\r\n", (state==DRV_ST_ATTACHED)?"attached":"detached");
return STATUS_OK;
}
DCL_STATUS _ttyut_hdr_main(DCL_DEV dev, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data)
{
return STATUS_OK;
}
kal_bool _ttyut_upmod_init_deinit_test(kal_uint8 uart_port)
{
#define TEST_ROUND 100
#define UART_INVALID_PORT 0xFFFF
DCL_STATUS status;
DCL_HANDLE handle;
int idx;
UART_CTRL_OPEN_T ur_ctrl_open;
UART_CTRL_CLOSE_T ur_ctrl_close;
Seriport_HANDLER_T tty_ut_uart_handler = {DCL_UART_USB_TYPE, _ttyut_hdr_main};
/*Test 1*/
/* Init non-existed port -> should init failed */
/* test invalid port 0xFFFF*/
handle = DclSerialPort_Open(UART_INVALID_PORT, 0);
if(handle != STATUS_INVALID_DEVICE)
{
ttyut_print("[ERROR][TTY UT] DCL upper module open non-existed port successfully");
return KAL_FALSE;
}
/* test non-exist port by invalid handle with NEW API*/
handle = 0xFFFF;
status = DclSerialPort_UpModuleInit(handle, MOD_TTY_UT, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init non-existed port with NEW API successfully");
return KAL_FALSE;
}
/* test non-exist port by invalid handle with Conventional API*/
handle = 0xFFFF;
status = DclSerialPort_Control(handle, SIO_CMD_OPEN, (DCL_CTRL_DATA_T*) &ur_ctrl_open);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init non-existed port with Conv API successfully");
return KAL_FALSE;
}
/*Test 2 : Driver reg/de-reg API test*/
/* First register callback -> should not return failed */
handle = DclSerialPort_Open(uart_max_port, 0);
for (idx = 0; idx < TEST_ROUND; idx ++)
{
status = DclSerialPort_DrvRegisterCb(handle, &tty_ut_uart_handler);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] Driver first register callback function failed");
return KAL_FALSE;
}
/* Duplicated register -> should return failed */
status = DclSerialPort_DrvRegisterCb(handle, &tty_ut_uart_handler);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] Driver first register callback function twice successfully");
return KAL_FALSE;
}
/* First De-register callback -> should not return failed */
status = DclSerialPort_DrvDeRegisterCb(handle);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] Driver first De-register callback function failed");
return KAL_FALSE;
}
/* Duplicated register -> should return failed */
status = DclSerialPort_DrvDeRegisterCb(handle);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] Driver De-register callback function twice successfully");
return KAL_FALSE;
}
}
/*Test 3 : open non-registered port with NEW API*/
/* Init non-register port -> should not return failed */
handle = DclSerialPort_Open(uart_max_port, 0);
for (idx = 0; idx < TEST_ROUND; idx ++)
{
status = DclSerialPort_UpModuleInit(handle, MOD_TTY_UT, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module first init non-registered port failed");
return KAL_FALSE;
}
/* Duplicated init -> should init failed */
status = DclSerialPort_UpModuleInit(handle, MOD_TTY_UT, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init twice (non-registered port)successfully!!");
return KAL_FALSE;
}
/* First deinit -> should deinit successfully */
status = DclSerialPort_UpModuleDeinit(handle);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module first deinit non-registered port failed");
return KAL_FALSE;
}
/* Duplicated deinit -> should deinit failed */
status = DclSerialPort_UpModuleDeinit(handle);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module deinit twice (non-registered port)successfully!!");
return KAL_FALSE;
}
}
/*Test 4 : open non-registered port with Conv API*/
/* Init non-register port -> should not return failed */
handle = DclSerialPort_Open(uart_max_port, 0);
ur_ctrl_open.u4OwenrId = MOD_TTY_UT;
ur_ctrl_close.u4OwenrId = MOD_TTY_UT;
for (idx = 0; idx < TEST_ROUND; idx ++)
{
status = DclSerialPort_Control(handle, SIO_CMD_OPEN, (DCL_CTRL_DATA_T*) &ur_ctrl_open);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module first init non-registered port failed");
return KAL_FALSE;
}
/* Duplicated init -> should init failed */
status = DclSerialPort_Control(handle, SIO_CMD_OPEN, (DCL_CTRL_DATA_T*) &ur_ctrl_open);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init twice (non-registered port)successfully!!");
return KAL_FALSE;
}
/* First deinit -> should deinit successfully */
status = DclSerialPort_Control(handle, SIO_CMD_CLOSE, (DCL_CTRL_DATA_T*) &ur_ctrl_close);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module first deinit non-registered port failed");
return KAL_FALSE;
}
/* Duplicated deinit -> should deinit failed */
status = DclSerialPort_Control(handle, SIO_CMD_CLOSE, (DCL_CTRL_DATA_T*) &ur_ctrl_close);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module deinit twice (non-registered port)successfully!!");
return KAL_FALSE;
}
}
/*Test 5 : open registered port test*/
handle = DclSerialPort_Open(uart_port, 0);
for (idx = 0; idx < TEST_ROUND; idx ++)
{
/* First init -> should init successfully */
status = DclSerialPort_UpModuleInit(handle, MOD_TTY_UT, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init failed");
return KAL_FALSE;
}
DclSerialPort_UpModuleRegisterCb(handle, _ttyut_rx_cb, NULL, _ttyut_drv_state_cb);
/* Duplicated init -> should init failed */
status = DclSerialPort_UpModuleInit(handle, MOD_TTY_UT, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init twice successfully!!");
return KAL_FALSE;
}
/* First deinit -> should deinit successfully */
status = DclSerialPort_UpModuleDeinit(handle);
if (status != STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init failed");
return KAL_FALSE;
}
/* Duplicated deinit -> should deinit failed */
status = DclSerialPort_UpModuleDeinit(handle);
if (status == STATUS_OK) {
ttyut_print("[ERROR][TTY UT] DCL upper module init failed");
return KAL_FALSE;
}
}
return KAL_TRUE;
}
kal_bool _ttyut_upmod_change_owner_test()
{
DCL_STATUS status;
DCL_HANDLE handle;
UART_CTRL_OPEN_T ur_ctrl_open;
UART_CTRL_CLOSE_T ur_ctrl_close;
UART_CTRL_OWNER_T ur_ctrl_owner;
UART_CTRL_GET_DRV_STATE_T getDrvState;
UART_CTRL_GET_CHUNK_SIZE_T getChunkSize;
handle = DclSerialPort_Open(TTY_UT_COM1, 0);
kal_sleep_task(KAL_TICKS_3_SEC);
/* Conventional owner change to conventional owner */
{
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
char *test_string1 = "[Change owner test] Conventional Owner A change to ";
char *test_string2 = "Conventional owner B\r\n";
ur_ctrl_open.u4OwenrId = MOD_TTY_UT;
DclSerialPort_Control(handle, SIO_CMD_OPEN, (DCL_CTRL_DATA_T*) &ur_ctrl_open);
/* Send string */
ur_ctrl_putbytes.u4OwenrId = MOD_TTY_UT;
ur_ctrl_putbytes.puBuffaddr = (DCL_UINT8*)test_string1;
ur_ctrl_putbytes.u2Length = strlen(test_string1);
DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes);
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Change owner to MOD_TTY_UT99 */
ur_ctrl_owner.u4OwenrId = MOD_TTY_UT99;
DclSerialPort_Control(handle, SIO_CMD_SET_OWNER, (DCL_CTRL_DATA_T*) &ur_ctrl_owner);
kal_set_active_module_id(MOD_TTY_UT99);
/* Send string */
ur_ctrl_putbytes.u4OwenrId = MOD_TTY_UT99;
ur_ctrl_putbytes.puBuffaddr = (DCL_UINT8*)test_string2;
ur_ctrl_putbytes.u2Length = strlen(test_string2);
DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes);
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Close com port */
ur_ctrl_close.u4OwenrId = MOD_TTY_UT99;
DclSerialPort_Control(handle, SIO_CMD_CLOSE, (DCL_CTRL_DATA_T*) &ur_ctrl_close);
kal_set_active_module_id(MOD_TTY_UT);
}
BUSY_WAIT(1000);
/* Conventional owner change to new owner */
{
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
char *test_string1 = "[Change owner test] Conventional Owner A change to ";
char *test_string2 = "New owner B\r\n";
void *tx_gpd;
tty_io_request_t *tx_ior;
unsigned char *tx_buf_ptr;
ur_ctrl_open.u4OwenrId = MOD_TTY_UT;
DclSerialPort_Control(handle, SIO_CMD_OPEN, (DCL_CTRL_DATA_T*) &ur_ctrl_open);
/* Send string */
ur_ctrl_putbytes.u4OwenrId = MOD_TTY_UT;
ur_ctrl_putbytes.puBuffaddr = (DCL_UINT8*)test_string1;
ur_ctrl_putbytes.u2Length = strlen(test_string1);
DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes);
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Change owner to MOD_TTY_UT99 */
ur_ctrl_owner.u4OwenrId = MOD_TTY_UT99;
DclSerialPort_Control(handle, SIO_CMD_SET_OWNER, (DCL_CTRL_DATA_T*) &ur_ctrl_owner);
kal_set_active_module_id(MOD_TTY_UT99);
DclSerialPort_UpModuleReinit(handle, MOD_TTY_UT99, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
DclSerialPort_UpModuleRegisterCb(handle, _ttyut_rx_cb, NULL, _ttyut_drv_state_cb);
// Wait for device ready
getDrvState.u4OwnerId = MOD_TTY_UT;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while (getDrvState.drv_state != DRV_ST_ATTACHED);
// Get chunk size
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_CHUNK_SIZE, (DCL_CTRL_DATA_T*) &getChunkSize);
} while (status != STATUS_OK);
/* Send string */
tx_gpd = QBM_ALLOC_ONE(QBM_TYPE_TTY_TYPE1);
if (tx_gpd) {
tx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(tx_gpd);
tx_ior->next_request = NULL;
tx_ior->first_gpd = tx_gpd;
tx_ior->last_gpd = tx_gpd;
tx_buf_ptr = QBM_DES_GET_DATAPTR(tx_gpd);
kal_mem_cpy((void*)tx_buf_ptr, test_string2, strlen(test_string2));
QBM_DES_SET_DATALEN(tx_gpd, strlen(test_string2)); // Set data length
QBM_DES_SET_HWO(tx_gpd);
qbm_cal_set_checksum(tx_gpd);
//QBM_CACHE_FLUSH(tx_gpd, sizeof(qbm_gpd));
DclSerialPort_UpModuleTransmit(handle, tx_ior);
} else {
ttyut_print("[ERROR] [TTY UT] GPD allocate failed in QBM_TYPE_TTY_TYPE1 type\r\n");
return KAL_FALSE;
}
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Close com port */
DclSerialPort_UpModuleDeinit(handle);
kal_set_active_module_id(MOD_TTY_UT);
}
BUSY_WAIT(1000);
/* New owner change to new owner */
{
char *test_string1 = "[Change owner test] New Owner A change to ";
char *test_string2 = "New owner B\r\n";
void *tx_gpd;
tty_io_request_t *tx_ior;
unsigned char *tx_buf_ptr;
UART_CTRL_CLR_BUFFER_T ur_ctrl_clr_buf;
/* Bind COM port - initialization */
status = DclSerialPort_UpModuleInit(handle, MOD_TTY_UT, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status != STATUS_OK) {
ttyut_print("[TTY UT] DCL upper module init failed");
return KAL_FALSE;
} else {
DclSerialPort_UpModuleRegisterCb(handle, _ttyut_rx_cb, NULL, _ttyut_drv_state_cb);
// Wait for device ready
getDrvState.u4OwnerId = MOD_TTY_UT;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while (getDrvState.drv_state != DRV_ST_ATTACHED);
// Get chunk size
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_CHUNK_SIZE, (DCL_CTRL_DATA_T*) &getChunkSize);
} while (status != STATUS_OK);
}
/* Send string */
tx_gpd = QBM_ALLOC_ONE(QBM_TYPE_TTY_TYPE1);
if (tx_gpd) {
tx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(tx_gpd);
tx_ior->next_request = NULL;
tx_ior->first_gpd = tx_gpd;
tx_ior->last_gpd = tx_gpd;
tx_buf_ptr = QBM_DES_GET_DATAPTR(tx_gpd);
kal_mem_cpy((void*)tx_buf_ptr, test_string1, strlen(test_string1));
QBM_DES_SET_DATALEN(tx_gpd, strlen(test_string1)); // Set data length
QBM_DES_SET_HWO(tx_gpd);
qbm_cal_set_checksum(tx_gpd);
QBM_CACHE_FLUSH(tx_gpd, sizeof(qbm_gpd));
DclSerialPort_UpModuleTransmit(handle, tx_ior);
} else {
ttyut_print("[ERROR] [TTY UT] GPD allocate failed in QBM_TYPE_TTY_TYPE1 type\r\n");
return KAL_FALSE;
}
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Send Clear Tx/Rx buffer commands */
ur_ctrl_clr_buf.u4OwenrId = MOD_TTY_UT;
DclSerialPort_Control(handle, SIO_CMD_CLR_TX_BUF, (DCL_CTRL_DATA_T*) &ur_ctrl_clr_buf);
DclSerialPort_Control(handle, SIO_CMD_CLR_RX_BUF, (DCL_CTRL_DATA_T*) &ur_ctrl_clr_buf);
/* Change owner to MOD_TTY_UT99 */
ur_ctrl_owner.u4OwenrId = MOD_TTY_UT99;
DclSerialPort_Control(handle, SIO_CMD_SET_OWNER, (DCL_CTRL_DATA_T*) &ur_ctrl_owner);
kal_set_active_module_id(MOD_TTY_UT99);
DclSerialPort_UpModuleReinit(handle, MOD_TTY_UT99, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
DclSerialPort_UpModuleRegisterCb(handle, _ttyut_rx_cb, NULL, _ttyut_drv_state_cb);
// Wait for device ready
getDrvState.u4OwnerId = MOD_TTY_UT;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while (getDrvState.drv_state != DRV_ST_ATTACHED);
// Get chunk size
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_CHUNK_SIZE, (DCL_CTRL_DATA_T*) &getChunkSize);
} while (status != STATUS_OK);
/* Send string */
tx_gpd = QBM_ALLOC_ONE(QBM_TYPE_TTY_TYPE1);
if (tx_gpd) {
tx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(tx_gpd);
tx_ior->next_request = NULL;
tx_ior->first_gpd = tx_gpd;
tx_ior->last_gpd = tx_gpd;
tx_buf_ptr = QBM_DES_GET_DATAPTR(tx_gpd);
kal_mem_cpy((void*)tx_buf_ptr, test_string2, strlen(test_string2));
QBM_DES_SET_DATALEN(tx_gpd, strlen(test_string2)); // Set data length
QBM_DES_SET_HWO(tx_gpd);
qbm_cal_set_checksum(tx_gpd);
//QBM_CACHE_FLUSH(tx_gpd, sizeof(qbm_gpd));
DclSerialPort_UpModuleTransmit(handle, tx_ior);
} else {
ttyut_print("[ERROR] [TTY UT] GPD allocate failed in QBM_TYPE_TTY_TYPE1 type\r\n");
return KAL_FALSE;
}
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Close com port */
DclSerialPort_UpModuleDeinit(handle);
kal_set_active_module_id(MOD_TTY_UT);
}
BUSY_WAIT(1000);
/* New owner change to conventional owner */
{
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
char *test_string1 = "[Change owner test] New Owner A change to ";
char *test_string2 = "Conventional owner B\r\nPASS\r\n";
void *tx_gpd;
tty_io_request_t *tx_ior;
unsigned char *tx_buf_ptr;
UART_CTRL_CLR_BUFFER_T ur_ctrl_clr_buf;
/* Bind COM port - initialization */
status = DclSerialPort_UpModuleInit(handle, MOD_TTY_UT, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status != STATUS_OK) {
ttyut_print("[TTY UT] DCL upper module init failed");
return KAL_FALSE;
} else {
DclSerialPort_UpModuleRegisterCb(handle, _ttyut_rx_cb, NULL, _ttyut_drv_state_cb);
// Wait for device ready
getDrvState.u4OwnerId = MOD_TTY_UT;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while (getDrvState.drv_state != DRV_ST_ATTACHED);
// Get chunk size
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_CHUNK_SIZE, (DCL_CTRL_DATA_T*) &getChunkSize);
} while (status != STATUS_OK);
}
/* Send string */
tx_gpd = QBM_ALLOC_ONE(QBM_TYPE_TTY_TYPE1);
if (tx_gpd) {
tx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(tx_gpd);
tx_ior->next_request = NULL;
tx_ior->first_gpd = tx_gpd;
tx_ior->last_gpd = tx_gpd;
tx_buf_ptr = QBM_DES_GET_DATAPTR(tx_gpd);
kal_mem_cpy((void*)tx_buf_ptr, test_string1, strlen(test_string1));
QBM_DES_SET_DATALEN(tx_gpd, strlen(test_string1)); // Set data length
QBM_DES_SET_HWO(tx_gpd);
qbm_cal_set_checksum(tx_gpd);
//QBM_CACHE_FLUSH(tx_gpd, sizeof(qbm_gpd));
DclSerialPort_UpModuleTransmit(handle, tx_ior);
} else {
ttyut_print("[ERROR] [TTY UT] GPD allocate failed in QBM_TYPE_TTY_TYPE1 type\r\n");
return KAL_FALSE;
}
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Send Clear Tx/Rx buffer commands */
ur_ctrl_clr_buf.u4OwenrId = MOD_TTY_UT;
DclSerialPort_Control(handle, SIO_CMD_CLR_TX_BUF, (DCL_CTRL_DATA_T*) &ur_ctrl_clr_buf);
DclSerialPort_Control(handle, SIO_CMD_CLR_RX_BUF, (DCL_CTRL_DATA_T*) &ur_ctrl_clr_buf);
/* Change owner to MOD_TTY_UT99 */
ur_ctrl_owner.u4OwenrId = MOD_TTY_UT99;
DclSerialPort_Control(handle, SIO_CMD_SET_OWNER, (DCL_CTRL_DATA_T*) &ur_ctrl_owner);
kal_set_active_module_id(MOD_TTY_UT99);
/* Send string */
ur_ctrl_putbytes.u4OwenrId = MOD_TTY_UT99;
ur_ctrl_putbytes.puBuffaddr = (DCL_UINT8*)test_string2;
ur_ctrl_putbytes.u2Length = strlen(test_string2);
DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes);
kal_sleep_task(KAL_TICKS_10_MSEC/10);
/* Close com port */
ur_ctrl_close.u4OwenrId = MOD_TTY_UT99;
DclSerialPort_Control(handle, SIO_CMD_CLOSE, (DCL_CTRL_DATA_T*) &ur_ctrl_close);
kal_set_active_module_id(MOD_TTY_UT);
}
BUSY_WAIT(1000);
return KAL_TRUE;
}
static kal_bool ttyut_test_preproc(tty_ut_mode_e test_mode, kal_uint8 uart_port)
{
DCL_STATUS status;
DCL_HANDLE handle;
DCL_UINT32 owner = MOD_NIL;
handle = DclSerialPort_Open(uart_port, 0);
if (TTY_UT_COM1 == uart_port) {
owner = MOD_TTY_UT;
} else if (TTY_UT_COM2 == uart_port) {
owner = MOD_TTY_UT2;
} else if (TTY_UT_COM3 == uart_port) {
owner = MOD_TTY_UT3;
} else {
// Unsupported mode, ASSERT.
ASSERT(0);
}
ttyut_create_instance(handle, owner);
switch (test_mode)
{
case TTY_UT_BYPASS:
{
//Do nothing;
break;
}
case TTY_UT_CONV_TX_CONV_RX:
case TTY_UT_CONV_TX_ONLY:
case TTY_UT_CONV_RX_ONLY:
{
UART_CTRL_OPEN_T data;
data.u4OwenrId = owner;
DclSerialPort_Control(handle, SIO_CMD_OPEN, (DCL_CTRL_DATA_T*) &data);
}
break;
case TTY_UT_NEW_INIT_CONV_TX_CONV_RX:
{
status = DclSerialPort_UpModuleInit(handle, owner, 0);
if (status != STATUS_OK) {
ttyut_print("[TTY UT] DCL upper module init failed");
}
}
break;
case TTY_UT_NEW_TX_NEW_RX:
case TTY_UT_NEW_TX_ONLY:
case TTY_UT_NEW_RX_ONLY:
{
void *rx_gpd_first, *rx_gpd_last;
tty_io_request_t *rx_ior;
void *rx_gpd_tmp;
int i;
UART_CTRL_GET_DRV_STATE_T getDrvState;
UART_CTRL_GET_CHUNK_SIZE_T getChunkSize;
/* Bind COM port - initialization */
status = DclSerialPort_UpModuleInit(handle, owner, TTY_FLAG_NEW_TX | TTY_FLAG_NEW_RX);
if (status != STATUS_OK) {
ttyut_print("[TTY UT] DCL upper module init failed");
} else {
DclSerialPort_UpModuleRegisterCb(handle, _ttyut_rx_cb, _ttyut_tx_done_cb, _ttyut_drv_state_cb);
// Wait for device ready
getDrvState.u4OwnerId = owner;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while ((getDrvState.drv_state != DRV_ST_ATTACHED) || (status != STATUS_OK));
// Get chunk size
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_CHUNK_SIZE, (DCL_CTRL_DATA_T*) &getChunkSize);
} while (status != STATUS_OK);
qbmt_alloc_q_no_tail(QBM_TYPE_TTY_TYPE1, 2, &rx_gpd_first, &rx_gpd_last);
rx_gpd_tmp = rx_gpd_first;
if (!rx_gpd_first || !rx_gpd_last) {
ttyut_print("[TTY UT] DCL upper module init failed");
return KAL_FALSE;
}
// Set allow length
for (i=0; i<2; i++) {
if(getChunkSize.chunkSize == 1) //Some HIF doesn't have chunksize restrictions(ex: uart)
{
QBM_DES_SET_ALLOW_LEN(rx_gpd_tmp, TTY_UT_CHUNK_SIZE_DEFAULT);
}
else
{
QBM_DES_SET_ALLOW_LEN(rx_gpd_tmp, (kal_uint16)getChunkSize.chunkSize);
}
qbm_cal_set_checksum((kal_uint8*)rx_gpd_tmp);
QBM_CACHE_FLUSH(rx_gpd_tmp, sizeof(qbm_gpd));
rx_gpd_tmp = QBM_DES_GET_NEXT(rx_gpd_tmp);
}
rx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(rx_gpd_first);
rx_ior->next_request = NULL;
rx_ior->first_gpd = rx_gpd_first;
rx_ior->last_gpd = rx_gpd_last;
DclSerialPort_UpModuleAssignRxIor(handle, rx_ior);
}
}
break;
case TTY_UT_CONV_TX_NEW_RX:
{
void *rx_gpd_first, *rx_gpd_last;
tty_io_request_t *rx_ior;
void *rx_gpd_tmp;
int i;
UART_CTRL_GET_DRV_STATE_T getDrvState;
UART_CTRL_GET_CHUNK_SIZE_T getChunkSize;
/* Bind COM port - initialization */
status = DclSerialPort_UpModuleInit(handle, owner, TTY_FLAG_NEW_RX);
if (status != STATUS_OK) {
ttyut_print("[TTY UT] DCL upper module init failed");
} else {
DclSerialPort_UpModuleRegisterCb(handle, _ttyut_rx_cb, NULL, _ttyut_drv_state_cb);
// Wait for device ready
getDrvState.u4OwnerId = owner;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while ((getDrvState.drv_state != DRV_ST_ATTACHED) || (status != STATUS_OK));
// Get chunk size
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_CHUNK_SIZE, (DCL_CTRL_DATA_T*) &getChunkSize);
} while (status != STATUS_OK);
qbmt_alloc_q_no_tail(QBM_TYPE_TTY_TYPE1, 2, &rx_gpd_first, &rx_gpd_last);
rx_gpd_tmp = rx_gpd_first;
if (!rx_gpd_first || !rx_gpd_last) {
ttyut_print("[TTY UT] DCL upper module init failed");
return KAL_FALSE;
}
// Set allow length
for (i=0; i<2; i++) {
QBM_DES_SET_ALLOW_LEN(rx_gpd_tmp, (kal_uint16)getChunkSize.chunkSize);
qbm_cal_set_checksum((kal_uint8*)rx_gpd_tmp);
QBM_CACHE_FLUSH(rx_gpd_tmp, sizeof(qbm_gpd));
rx_gpd_tmp = QBM_DES_GET_NEXT(rx_gpd_tmp);
}
rx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(rx_gpd_first);
rx_ior->next_request = NULL;
rx_ior->first_gpd = rx_gpd_first;
rx_ior->last_gpd = rx_gpd_last;
DclSerialPort_UpModuleAssignRxIor(handle, rx_ior);
}
}
break;
case TTY_UT_NEW_TX_CONV_RX:
{
UART_CTRL_GET_DRV_STATE_T getDrvState;
/* Bind COM port - initialization */
status = DclSerialPort_UpModuleInit(handle, owner, TTY_FLAG_NEW_TX);
if (status != STATUS_OK) {
ttyut_print("[TTY UT] DCL upper module init failed");
} else {
DclSerialPort_UpModuleRegisterCb(handle, NULL, NULL, _ttyut_drv_state_cb);
// Wait for device ready
getDrvState.u4OwnerId = owner;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while ((getDrvState.drv_state != DRV_ST_ATTACHED) || (status != STATUS_OK));
}
}
break;
default:
break;
}
return KAL_TRUE;
}
static void _tty_ut_conv_tx_conv_rx_rd_handler(DCL_HANDLE handle)
{
UART_CTRL_GET_BYTES_T ur_ctrl_getbytes;
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
ttyut_instance_t *ttyut_inst_p;
ttyut_inst_p = ttyut_get_instance(handle);
ur_ctrl_getbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_getbytes.puBuffaddr = ttyut_inst_p->conv_tx_rx_buf + ttyut_inst_p->conv_tx_rx_rd_idx;
ur_ctrl_getbytes.u2Length = ttyut_inst_p->conv_tx_rx_wrap
? (ttyut_inst_p->conv_tx_rx_wt_idx - ttyut_inst_p->conv_tx_rx_rd_idx)
: (TTY_UT_LB_CON_TX_TX_BUF_SIZE - ttyut_inst_p->conv_tx_rx_rd_idx);
if (ur_ctrl_getbytes.u2Length == 0) {
return;
}
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_GET_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_getbytes)
&& ur_ctrl_getbytes.u2RetSize > 0)
{
ttyut_inst_p->conv_tx_rx_rd_idx += ur_ctrl_getbytes.u2RetSize;
if (ttyut_inst_p->conv_tx_rx_rd_idx == TTY_UT_LB_CON_TX_TX_BUF_SIZE ) {
/* reach the end of buffer, wrap to head */
ASSERT(ttyut_inst_p->conv_tx_rx_wrap == 0);
ttyut_inst_p->conv_tx_rx_rd_idx = 0;
ttyut_inst_p->conv_tx_rx_wrap = 1;
}
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->conv_tx_rx_buf + ttyut_inst_p->conv_tx_rx_wt_idx;
ur_ctrl_putbytes.u2Length = ttyut_inst_p->conv_tx_rx_wrap
? (TTY_UT_LB_CON_TX_TX_BUF_SIZE - ttyut_inst_p->conv_tx_rx_wt_idx)
: (ttyut_inst_p->conv_tx_rx_rd_idx - ttyut_inst_p->conv_tx_rx_wt_idx);
ASSERT(ur_ctrl_putbytes.u2Length > 0);
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes)
&& ur_ctrl_putbytes.u2RetSize > 0)
{
ttyut_inst_p->conv_tx_rx_wt_idx += ur_ctrl_putbytes.u2RetSize;
if (ttyut_inst_p->conv_tx_rx_wt_idx == TTY_UT_LB_CON_TX_TX_BUF_SIZE ) {
/* reach the end of buffer, de-wrap to head */
ASSERT(ttyut_inst_p->conv_tx_rx_wrap == 1);
ttyut_inst_p->conv_tx_rx_wt_idx = 0;
ttyut_inst_p->conv_tx_rx_wrap = 0;
if (ttyut_inst_p->conv_tx_rx_rd_idx > 0) {
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->conv_tx_rx_buf;
ur_ctrl_putbytes.u2Length = ttyut_inst_p->conv_tx_rx_rd_idx - ttyut_inst_p->conv_tx_rx_wt_idx;
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes)
&& ur_ctrl_putbytes.u2RetSize > 0)
{
ttyut_inst_p->conv_tx_rx_wt_idx += ur_ctrl_putbytes.u2RetSize;
}
}
}
}
}
}
static void _ttyut_process_ilm(DCL_HANDLE handle, ilm_struct *ilm_ptr, tty_ut_mode_e test_mode)
{
ttyut_instance_t *ttyut_inst_p;
ASSERT(ilm_ptr != NULL);
ttyut_inst_p = ttyut_get_instance(handle);
if (ilm_ptr != NULL)
{
switch (ilm_ptr->msg_id)
{
case MSG_ID_UART_READY_TO_WRITE_IND:
{
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
if (test_mode == TTY_UT_CONV_TX_CONV_RX || test_mode == TTY_UT_NEW_INIT_CONV_TX_CONV_RX)
{
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->conv_tx_rx_buf + ttyut_inst_p->conv_tx_rx_wt_idx;
ur_ctrl_putbytes.u2Length = ttyut_inst_p->conv_tx_rx_wrap
? (TTY_UT_LB_CON_TX_TX_BUF_SIZE - ttyut_inst_p->conv_tx_rx_wt_idx)
: (ttyut_inst_p->conv_tx_rx_rd_idx - ttyut_inst_p->conv_tx_rx_wt_idx);
if (ur_ctrl_putbytes.u2Length > 0
&& STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes)
&& ur_ctrl_putbytes.u2RetSize > 0)
{
ttyut_inst_p->conv_tx_rx_wt_idx += ur_ctrl_putbytes.u2RetSize;
if (ttyut_inst_p->conv_tx_rx_wt_idx == TTY_UT_LB_CON_TX_TX_BUF_SIZE ) {
/* reach the end of buffer, de-wrap to head */
ASSERT(ttyut_inst_p->conv_tx_rx_wrap == 1);
ttyut_inst_p->conv_tx_rx_wt_idx = 0;
ttyut_inst_p->conv_tx_rx_wrap = 0;
if (ttyut_inst_p->conv_tx_rx_rd_idx > 0) {
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->conv_tx_rx_buf;
ur_ctrl_putbytes.u2Length = ttyut_inst_p->conv_tx_rx_rd_idx - ttyut_inst_p->conv_tx_rx_wt_idx;
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes)
&& ur_ctrl_putbytes.u2RetSize > 0)
{
ttyut_inst_p->conv_tx_rx_wt_idx += ur_ctrl_putbytes.u2RetSize;
}
}
}
}
} else if (test_mode == TTY_UT_CONV_TX_ONLY || test_mode == TTY_UT_CONV_TX_NEW_RX) {
if (ttyut_inst_p->ttyut_tx_len > 0)
{
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->ttyut_tx_buf + ttyut_inst_p->ttyut_tx_offset;
ur_ctrl_putbytes.u2Length = ttyut_inst_p->ttyut_tx_len;
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes))
{
ttyut_print("[TTY UT] send %d bytes data\r\n", ur_ctrl_putbytes.u2RetSize);
ttyut_inst_p->ttyut_tx_len -= ur_ctrl_putbytes.u2RetSize;
ttyut_inst_p->ttyut_tx_offset += ur_ctrl_putbytes.u2RetSize;
}
}
}
}
break;
case MSG_ID_UART_READY_TO_READ_IND:
{
UART_CTRL_GET_BYTES_T ur_ctrl_getbytes;
int idx;
switch (test_mode)
{
case TTY_UT_CONV_TX_CONV_RX:
case TTY_UT_NEW_INIT_CONV_TX_CONV_RX:
{
_tty_ut_conv_tx_conv_rx_rd_handler(handle);
}
break;
case TTY_UT_NEW_TX_CONV_RX:
{
ur_ctrl_getbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_getbytes.puBuffaddr = ttyut_inst_p->ttyut_rx_buf;
ur_ctrl_getbytes.u2Length = QBM_TTY_XXX_DATA_LEN;
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_GET_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_getbytes)
&& ur_ctrl_getbytes.u2RetSize > 0)
{
void *tx_gpd;
tty_io_request_t *tx_ior;
unsigned char *tx_buf_ptr;
tx_gpd = QBM_ALLOC_ONE(QBM_TYPE_TTY_TYPE1);
if (tx_gpd) {
tx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(tx_gpd);
tx_ior->next_request = NULL;
tx_ior->first_gpd = tx_gpd;
tx_ior->last_gpd = tx_gpd;
tx_buf_ptr = QBM_DES_GET_DATAPTR(tx_gpd);
kal_mem_cpy((void*)tx_buf_ptr, ur_ctrl_getbytes.puBuffaddr, ur_ctrl_getbytes.u2RetSize);
QBM_DES_SET_DATALEN(tx_gpd, ur_ctrl_getbytes.u2RetSize); // Set data length
QBM_DES_SET_HWO(tx_gpd);
qbm_cal_set_checksum(tx_gpd);
//QBM_CACHE_FLUSH(tx_gpd, sizeof(qbm_gpd));
ttyut_print("[TTY UT] Receive data and re-send to Host, len=%d\r\n", ur_ctrl_getbytes.u2RetSize);
DclSerialPort_UpModuleTransmit(handle, tx_ior);
} else {
ttyut_print("[ERROR] [TTY UT] GPD allocate failed in QBM_TYPE_TTY_TYPE1 type\r\n");
ASSERT(tx_gpd);
}
}
}
break;
case TTY_UT_CONV_RX_ONLY:
{
ur_ctrl_getbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_getbytes.puBuffaddr = ttyut_inst_p->ttyut_rx_buf;
ur_ctrl_getbytes.u2Length = TTY_UT_CONV_BUF_SIZE;
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_GET_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_getbytes)
&& ur_ctrl_getbytes.u2RetSize > 0)
{
ttyut_print("[TTY UT] Rx Only Test, len=%d, data: ", ur_ctrl_getbytes.u2RetSize);
for (idx = 0; idx < ur_ctrl_getbytes.u2RetSize; idx ++) {
ttyut_print("%c", ur_ctrl_getbytes.puBuffaddr[idx]);
}
ttyut_print("\r\n");
}
}
break;
default:
break;
}
}
break;
default:
break;
}
}
}
static void ttyut_test(tty_ut_mode_e test_mode, kal_uint8 uart_port)
{
ilm_struct current_ilm = {0};
DCL_HANDLE handle;
ttyut_instance_t *ttyut_inst_p;
UART_CTRL_GET_DRV_STATE_T getDrvState;
DCL_UINT32 owner = MOD_NIL;
DCL_STATUS status;
handle = DclSerialPort_Open(uart_port, 0);
ttyut_inst_p = ttyut_get_instance(handle);
ASSERT(ttyut_inst_p);
// Wait for device ready
if (TTY_UT_COM1 == uart_port) {
owner = MOD_TTY_UT;
} else if (TTY_UT_COM2 == uart_port) {
owner = MOD_TTY_UT2;
} else if (TTY_UT_COM3 == uart_port) {
owner = MOD_TTY_UT3;
} else {
// Unsupported mode, ASSERT.
ASSERT(0);
}
getDrvState.u4OwnerId = owner;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while ((getDrvState.drv_state != DRV_ST_ATTACHED) || (status != STATUS_OK));
switch (test_mode)
{
case TTY_UT_BYPASS:
{
while(1)
{
//do nothing;
kal_sleep_task(KAL_TICKS_1_MIN);
}
}
case TTY_UT_CONV_TX_CONV_RX:
ttyut_print("[TTY UT] loopback Test of conventional Tx and conventional Rx - in Old init procedure\r\n");
{
while (1)
{
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) == KAL_TRUE)
{
_ttyut_process_ilm(handle, &current_ilm, test_mode);
destroy_ilm(&current_ilm);
}
}
/* Polling Read */
kal_sleep_task(KAL_TICKS_10_MSEC/10);
_tty_ut_conv_tx_conv_rx_rd_handler(handle);
}
}
break;
case TTY_UT_NEW_INIT_CONV_TX_CONV_RX:
ttyut_print("[TTY UT] loopback Test of conventional Tx and conventional Rx - in New init procedure\r\n");
{
while (1)
{
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) == KAL_TRUE)
{
_ttyut_process_ilm(handle, &current_ilm, test_mode);
destroy_ilm(&current_ilm);
}
}
/* Polling Read */
kal_sleep_task(KAL_TICKS_10_MSEC/10);
_tty_ut_conv_tx_conv_rx_rd_handler(handle);
}
}
break;
case TTY_UT_NEW_TX_CONV_RX:
ttyut_print("[TTY UT] loopback Test of new Tx and conventional Rx\r\n");
{
while (1)
{
if (msg_receive_extq(&current_ilm) == KAL_TRUE)
{
_ttyut_process_ilm(handle, &current_ilm, test_mode);
destroy_ilm(&current_ilm);
}
}
}
break;
case TTY_UT_CONV_RX_ONLY:
ttyut_print("[TTY UT] conventional Rx Only Test\r\n");
{
while (1)
{
if (msg_receive_extq(&current_ilm) == KAL_TRUE)
{
_ttyut_process_ilm(handle, &current_ilm, test_mode);
destroy_ilm(&current_ilm);
}
}
}
break;
case TTY_UT_NEW_RX_ONLY:
ttyut_print("[TTY UT] new Rx Only Test\r\n");
{
while (1)
{
tty_io_request_t *rx_ior;
unsigned char *rx_buf_ptr;
int rx_buf_len;
int idx;
kal_take_mutex(ttyut_inst_p->ttyut_mutex);
if (ttyut_inst_p->ttyut_rx_ior) {
rx_ior = ttyut_inst_p->ttyut_rx_ior;
ttyut_inst_p->ttyut_rx_ior = ttyut_inst_p->ttyut_rx_ior->next_request;
kal_give_mutex(ttyut_inst_p->ttyut_mutex);
rx_ior->next_request = NULL;
/* Assert if first gpd is not equal to last gpd, unless Clear Rx/Set owner/Close command is requested */
ASSERT(rx_ior->first_gpd == rx_ior->last_gpd);
rx_buf_ptr = QBM_DES_GET_DATAPTR(rx_ior->first_gpd);
rx_buf_len = QBM_DES_GET_DATALEN(rx_ior->first_gpd);
QBM_CACHE_INVALID(rx_buf_ptr, rx_buf_len);
ttyut_print("[TTY UT] Rx Only Test, len=%d, data: ", rx_buf_len);
for (idx = 0; idx < rx_buf_len; idx ++) {
ttyut_print("%c", rx_buf_ptr[idx]);
}
ttyut_print("\r\n");
QBM_DES_SET_HWO(rx_ior->first_gpd);
qbm_cal_set_checksum(rx_ior->first_gpd);
QBM_CACHE_FLUSH(rx_ior->first_gpd, sizeof(qbm_gpd));
/* Re-assign this rx ior to driver for the following receiving */
DclSerialPort_UpModuleAssignRxIor(handle, rx_ior);
} else {
kal_give_mutex(ttyut_inst_p->ttyut_mutex);
}
/* TODO: check scheduling/priority issue */
kal_sleep_task(KAL_TICKS_10_MSEC);
/* msg_receive_extq will block, therefore we poll if any message first */
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) != KAL_TRUE)
{
break;
}
destroy_ilm(&current_ilm);
}
}
}
break;
case TTY_UT_CONV_TX_ONLY:
kal_sleep_task(KAL_TICKS_3_SEC);
ttyut_print("[TTY UT] conventional Tx Only Test\r\n");
{
int idx, len;
DCL_STATUS ret_st;
for (idx = 0; idx < TTY_UT_CONV_BUF_SIZE; idx ++) {
ttyut_inst_p->ttyut_tx_buf[idx] = 'a' + idx % ('z'-'a'+1);
}
/* 1st round - 1~2048 bytes in order */
for (len = 1; len <= 2048; len ++) {
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
ttyut_print("[TTY UT] expect send %d bytes data\r\n", len);
ttyut_inst_p->ttyut_tx_offset = 0;
ttyut_inst_p->ttyut_tx_len = len;
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->ttyut_tx_buf;
ur_ctrl_putbytes.u2Length = len;
ret_st = DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes);
if (STATUS_OK == ret_st && ur_ctrl_putbytes.u2RetSize > 0) {
ttyut_print("[TTY UT] send %d bytes data\r\n", ur_ctrl_putbytes.u2RetSize);
ttyut_inst_p->ttyut_tx_offset = ur_ctrl_putbytes.u2RetSize;
ttyut_inst_p->ttyut_tx_len -= ur_ctrl_putbytes.u2RetSize;
}
kal_sleep_task(KAL_TICKS_10_MSEC);
/* Polling ttyut_tx_len until all tx buffer are sent */
while (ttyut_inst_p->ttyut_tx_len != 0)
{
kal_sleep_task(KAL_TICKS_10_MSEC/10);
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) != KAL_TRUE) {
break;
} else {
_ttyut_process_ilm(handle, &current_ilm, test_mode);
}
destroy_ilm(&current_ilm);
}
}
}
/* 2nd round - 1~2048 bytes in random size */
while (1)
{
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
len = rand()%TTY_UT_CONV_BUF_SIZE + 1;
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->ttyut_tx_buf;
ur_ctrl_putbytes.u2Length = len;
ttyut_inst_p->ttyut_tx_offset = 0;
ttyut_inst_p->ttyut_tx_len = len;
ret_st = DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes);
if (STATUS_OK == ret_st && ur_ctrl_putbytes.u2RetSize > 0)
{
ttyut_print("[TTY UT] send %d bytes data\r\n", ur_ctrl_putbytes.u2RetSize);
ttyut_inst_p->ttyut_tx_offset = ur_ctrl_putbytes.u2RetSize;
ttyut_inst_p->ttyut_tx_len -= ur_ctrl_putbytes.u2RetSize;
}
/* Polling ttyut_tx_len until all tx buffer are sent */
while (ttyut_inst_p->ttyut_tx_len != 0)
{
kal_sleep_task(KAL_TICKS_10_MSEC);
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) != KAL_TRUE) {
break;
} else {
_ttyut_process_ilm(handle, &current_ilm, test_mode);
}
destroy_ilm(&current_ilm);
}
}
} /* while */
}
break;
case TTY_UT_NEW_TX_ONLY:
kal_sleep_task(KAL_TICKS_3_SEC);
ttyut_print("[TTY UT] new Tx Only Test\r\n");
{
int idx;
for (idx = 0; idx < TTY_UT_NEW_BUF_SIZE; idx ++) {
ttyut_inst_p->ttyut_tx_buf[idx] = 'a' + idx % ('z'-'a'+1);
}
while (1)
{
void *tx_gpd;
tty_io_request_t *tx_ior;
unsigned char *tx_buf_ptr;
tx_gpd = QBM_ALLOC_ONE(QBM_TYPE_TTY_TYPE1);
if (tx_gpd) {
tx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(tx_gpd);
tx_ior->next_request = NULL;
tx_ior->first_gpd = tx_gpd;
tx_ior->last_gpd = tx_gpd;
ttyut_inst_p->ttyut_tx_len = rand()%TTY_UT_NEW_BUF_SIZE + 1;
tx_buf_ptr = QBM_DES_GET_DATAPTR(tx_gpd);
kal_mem_cpy((void*)tx_buf_ptr, ttyut_inst_p->ttyut_tx_buf, ttyut_inst_p->ttyut_tx_len);
QBM_DES_SET_DATALEN(tx_gpd, ttyut_inst_p->ttyut_tx_len); // Set data length
QBM_DES_SET_HWO(tx_gpd);
qbm_cal_set_checksum(tx_gpd);
//QBM_CACHE_FLUSH(tx_gpd, sizeof(qbm_gpd));
ttyut_print("[TTY UT] send %d bytes data\r\n", ttyut_inst_p->ttyut_tx_len);
DclSerialPort_UpModuleTransmit(handle, tx_ior);
} else {
ttyut_print("[ERROR] [TTY UT] GPD allocate failed in QBM_TYPE_TTY_TYPE1 type\r\n");
}
/* TODO: check scheduling/priority issue */
kal_sleep_task(KAL_TICKS_10_MSEC);
/* msg_receive_extq will block, therefore we poll if any message first */
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) != KAL_TRUE)
{
break;
}
destroy_ilm(&current_ilm);
}
}
}
break;
case TTY_UT_NEW_TX_NEW_RX:
ttyut_print("[TTY UT] loopback Test of new Tx and new Rx\r\n");
{
while (1)
{
void *tx_gpd;
tty_io_request_t *tx_ior;
tty_io_request_t *rx_ior;
unsigned char *tx_buf_ptr;
unsigned char *rx_buf_ptr;
kal_uint16 rx_len;
kal_take_mutex(ttyut_inst_p->ttyut_mutex);
if (ttyut_inst_p->ttyut_rx_ior)
{
rx_ior = ttyut_inst_p->ttyut_rx_ior;
ttyut_inst_p->ttyut_rx_ior = ttyut_inst_p->ttyut_rx_ior->next_request;
kal_give_mutex(ttyut_inst_p->ttyut_mutex);
rx_ior->next_request = NULL;
/* Assert if first gpd is not equal to last gpd, unless Clear Rx/Set owner/Close command is requested */
ASSERT(rx_ior->first_gpd == rx_ior->last_gpd);
tx_gpd = QBM_ALLOC_ONE(QBM_TYPE_TTY_TYPE1);
if (tx_gpd) {
tx_ior = (tty_io_request_t*)QBM_DES_GET_SW_CTRL_FIELD(tx_gpd);
tx_ior->next_request = NULL;
tx_ior->first_gpd = tx_gpd;
tx_ior->last_gpd = tx_gpd;
tx_buf_ptr = QBM_DES_GET_DATAPTR(tx_gpd);
rx_buf_ptr = QBM_DES_GET_DATAPTR(rx_ior->first_gpd);
rx_len = QBM_DES_GET_DATALEN(rx_ior->first_gpd);
QBM_CACHE_INVALID(rx_buf_ptr, rx_len);
kal_mem_cpy((void*)tx_buf_ptr, (void*)rx_buf_ptr, rx_len);
QBM_CACHE_FLUSH(tx_buf_ptr, rx_len); // flush tx data
QBM_DES_SET_DATALEN(tx_gpd, rx_len); // Set data length
QBM_DES_SET_HWO(tx_gpd);
qbm_cal_set_checksum(tx_gpd);
QBM_CACHE_FLUSH(tx_gpd, sizeof(qbm_gpd));
ttyut_print("[TTY UT] Receive data and re-send to Host, len=%d\r\n", rx_len);
DclSerialPort_UpModuleTransmitLight(handle, tx_ior);
} else {
ttyut_print("[ERROR] [TTY UT] GPD allocate failed in QBM_TYPE_TTY_TYPE1 type\r\n");
}
QBM_DES_SET_HWO(rx_ior->first_gpd);
qbm_cal_set_checksum(rx_ior->first_gpd);
QBM_CACHE_FLUSH(rx_ior->first_gpd, sizeof(qbm_gpd));
/* Re-assign this rx ior to driver for the following receiving */
DclSerialPort_UpModuleAssignRxIor(handle, rx_ior);
} else {
kal_give_mutex(ttyut_inst_p->ttyut_mutex);
}
/* TODO: check scheduling/priority issue */
kal_sleep_task(KAL_TICKS_10_MSEC);
/* msg_receive_extq will block, therefore we poll if any message first */
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) != KAL_TRUE)
{
break;
}
destroy_ilm(&current_ilm);
}
}
}
break;
case TTY_UT_CONV_TX_NEW_RX:
ttyut_print("[TTY UT] loopback Test of conventional Tx and new Rx\r\n");
{
while (1)
{
UART_CTRL_PUT_BYTES_T ur_ctrl_putbytes;
tty_io_request_t *rx_ior;
void *rx_data;
kal_uint16 rx_len;
kal_take_mutex(ttyut_inst_p->ttyut_mutex);
if (ttyut_inst_p->ttyut_rx_ior)
{
rx_ior = ttyut_inst_p->ttyut_rx_ior;
ttyut_inst_p->ttyut_rx_ior = ttyut_inst_p->ttyut_rx_ior->next_request;
kal_give_mutex(ttyut_inst_p->ttyut_mutex);
rx_ior->next_request = NULL;
/* Assert if first gpd is not equal to last gpd, unless Clear Rx/Set owner/Close command is requested */
ASSERT(rx_ior->first_gpd == rx_ior->last_gpd);
rx_data = QBM_DES_GET_DATAPTR(rx_ior->first_gpd);
rx_len = QBM_DES_GET_DATALEN(rx_ior->first_gpd);
if (rx_len > 0)
{ /* in the test case, only one gpd is used in one ior since we only send 2 gpds to driver and one is for tailing */
QBM_CACHE_INVALID(rx_data, rx_len);
ASSERT(rx_len <= QBM_TTY_XXX_DATA_LEN);
kal_mem_cpy(ttyut_inst_p->ttyut_tx_buf, rx_data, rx_len);
ttyut_inst_p->ttyut_tx_len = rx_len;
ur_ctrl_putbytes.u4OwenrId = ttyut_inst_p->owner;
ur_ctrl_putbytes.puBuffaddr = ttyut_inst_p->ttyut_tx_buf;
ur_ctrl_putbytes.u2Length = ttyut_inst_p->ttyut_tx_len;
if (STATUS_OK == DclSerialPort_Control(handle, SIO_CMD_PUT_BYTES, (DCL_CTRL_DATA_T*) &ur_ctrl_putbytes)
&& ur_ctrl_putbytes.u2RetSize < ttyut_inst_p->ttyut_tx_len)
{
ttyut_inst_p->ttyut_tx_offset = ur_ctrl_putbytes.u2RetSize;
ttyut_inst_p->ttyut_tx_len -= ur_ctrl_putbytes.u2RetSize;
}
}
QBM_DES_SET_HWO(rx_ior->first_gpd);
QBM_DES_SET_NEXT(rx_ior->first_gpd, NULL);
qbm_cal_set_checksum(rx_ior->first_gpd);
QBM_CACHE_FLUSH(rx_ior->first_gpd, sizeof(qbm_gpd));
/* Re-assign this rx ior to driver for the following receiving */
DclSerialPort_UpModuleAssignRxIor(handle, rx_ior);
} else {
kal_give_mutex(ttyut_inst_p->ttyut_mutex);
}
/* TODO: check scheduling/priority issue */
kal_sleep_task(KAL_TICKS_10_MSEC);
/* msg_receive_extq will block, therefore we poll if any message first */
while (msg_get_extq_messages() > 0)
{
if (msg_receive_extq(&current_ilm) != KAL_TRUE) {
break;
} else {
_ttyut_process_ilm(handle, &current_ilm, test_mode);
}
destroy_ilm(&current_ilm);
}
}
}
break;
default:
break;
}
}
// ==========================================================
// TTY_UT Task Function
// ==========================================================
kal_uint32 ttyut_tsk_num=0;
kal_spinlockid ttyut_tsk_pri_spl;
kal_taskid tty_tsk_pri[TTY_UT_COM_NUM];
kal_uint32 ttyut_get_current_task_priority()
{
kal_uint32 tty_pri, tty_ist=ttyut_tsk_num;
kal_taskid tskp=kal_get_current_task();
ASSERT(tskp);
kal_take_spinlock(ttyut_tsk_pri_spl, KAL_INFINITE_WAIT);
for(tty_pri=0;tty_pri<ttyut_tsk_num&&tty_tsk_pri[tty_pri]!=tskp;tty_pri++) tty_ist=tty_ist==ttyut_tsk_num&&!tty_tsk_pri[tty_pri]?tty_pri:tty_ist;
if(tty_pri==ttyut_tsk_num&&tty_ist<ttyut_tsk_num) tty_tsk_pri[tty_pri=tty_ist]=tskp;
kal_give_spinlock(ttyut_tsk_pri_spl);
return tty_pri==ttyut_tsk_num?0:tty_pri+1;
}
kal_bool ttyut_task_init(void)
{
if(ttyut_tsk_num==0) ttyut_tsk_pri_spl=kal_create_spinlock("TTYUT_TSK_SPL");
tty_tsk_pri[ttyut_tsk_num++]=NULL;
// Init ttyut instance struct.
kal_mem_set(&ttyut_inst_g, 0, sizeof(ttyut_inst_g));
return KAL_TRUE;
}
static void ttyut_task_main(task_entry_struct *task_entry_ptr)
{
kal_uint32 tsk_pri;
kal_bool ret = KAL_TRUE;
tsk_pri = ttyut_get_current_task_priority();
#if TTY_UT_MISC_TEST
DCL_STATUS status;
DCL_HANDLE handle;
UART_CTRL_GET_DRV_STATE_T getDrvState;
/*Init test and change owner test*/
if (TTY_UT_TASK_1_PRIORITY == tsk_pri) {
// Init_deinit test
kal_set_active_module_id(MOD_TTY_UT);
/*Make sure driver is already attached*/
handle = DclSerialPort_Open(TTY_UT_COM1, 0);
getDrvState.u4OwnerId = MOD_TTY_UT;
do {
kal_sleep_task(KAL_TICKS_100_MSEC);
status = DclSerialPort_Control(handle, TTY_CMD_GET_DRV_STATE, (DCL_CTRL_DATA_T*) &getDrvState);
} while ((getDrvState.drv_state != DRV_ST_ATTACHED) || (status != STATUS_OK));
if (_ttyut_upmod_init_deinit_test(TTY_UT_COM1)) {
ttyut_print("[TTY UT] init-deinit test OK\r\n");
} else {
ttyut_print("[TTY UT] init-deinit test failed\r\n");
//return;
ASSERT(0);
}
// Change_owner test
if (_ttyut_upmod_change_owner_test()) {
ttyut_print("[TTY UT] change owner test OK\r\n");
} else {
ttyut_print("[TTY UT] change owner test failed\r\n");
//return;
ASSERT(0);
}
}
#endif
/*
* S1.TTYUT_PREPROC.
*/
switch (tsk_pri)
{
case TTY_UT_TASK_1_PRIORITY:
kal_set_active_module_id(MOD_TTY_UT);
ret = ttyut_test_preproc(tty_ut_mode_1, TTY_UT_COM1);
break;
case TTY_UT_TASK_2_PRIORITY:
if (TTY_UT_COM_NUM > 1) {
kal_set_active_module_id(MOD_TTY_UT2);
ret = ttyut_test_preproc(tty_ut_mode_2, TTY_UT_COM2);
}
break;
case TTY_UT_TASK_3_PRIORITY:
if (TTY_UT_COM_NUM > 2) {
kal_set_active_module_id(MOD_TTY_UT3);
ret = ttyut_test_preproc(tty_ut_mode_3, TTY_UT_COM3);
}
break;
default:
// Unsupported mode, ASSERT.
ASSERT(0);
break;
}
if (KAL_TRUE == ret) {
} else {
// Failed to ttyut_test_preproc(), ASSERT.
ASSERT(0);
}
/*
* S2. TTYUT_MAIN.
*/
switch (tsk_pri)
{
case TTY_UT_TASK_1_PRIORITY:
ttyut_test(tty_ut_mode_1, TTY_UT_COM1);
break;
case TTY_UT_TASK_2_PRIORITY:
if (TTY_UT_COM_NUM > 1) {
ttyut_test(tty_ut_mode_2, TTY_UT_COM2);
}
break;
case TTY_UT_TASK_3_PRIORITY:
if (TTY_UT_COM_NUM > 2) {
ttyut_test(tty_ut_mode_3, TTY_UT_COM3);
}
break;
default:
// Unsupport mode, ASSERT.
ASSERT(0);
break;
}
while (1) {
kal_sleep_task(KAL_TICKS_30_SEC);
}
}
kal_bool ttyut_create(comptask_handler_struct **handle)
{
static const comptask_handler_struct ttyut_handler_info =
{
ttyut_task_main, /* task entry function */
ttyut_task_init, /* task initialization function */
NULL /* task reset handler */
};
ttyut_print("=========>ttyut_create\r\n");
*handle = (comptask_handler_struct *)&ttyut_handler_info;
return KAL_TRUE;
}