www.pudn.com > drivers.rar > dma_test_misc2.c
/**
* @file dma_test_misc2.c
*
* Gathers functions used for demonstration of DMA SWE.
*
* @author ()
* @version 0.1
*/
/*
* History:
*
* Date Author Modification
* -------------------------------------------------------------------
* 7/1/2003 () Create.
*
* (C) Copyright 2003 by Texas Instruments Incorporated, All Rights Reserved
*/
#include "rvm/rvm_api.h"
#include "rvm/rvm_use_id_list.h"
#include "rvm/rvm_ext_use_id_list.h"
#include "tests/rtest/rtest_api.h"
#include "dma/dma_api.h"
#include "dma/dma_message.h"
#include "dma/dma_i.h"
#include "dma/tests/dma_test_misc.h"
#include "dma/tests/dma_test_misc2.h"
/** Macro used for tracing DMA messages. */
#define DMA_TEST_SEND_TRACE(string, trace_level) \
rvf_send_trace (string, (sizeof(string) - 1), NULL_PARAM, trace_level, RTEST_USE_ID)
#define DMA_TEST_SEND_TRACE_PARAM(text,param,level) \
rvf_send_trace(text, sizeof(text)-1, param, level, RTEST_USE_ID )
#define SW_PRIORITY_NORMAL 100
/**********************************************************************
/ SDRAM for DMA Test
/**********************************************************************/
#define DMA_TEST_SDRAM_BUF_SIZE (64 * 4)
#define DMA_TEST_SDRAM_BASE_ADDR (0x08040000)
#define DMA_TEST_SDRAM_SRC_BUFFER (DMA_TEST_SDRAM_BASE_ADDR)
#define DMA_TEST_SDRAM_DST_BUFFER (DMA_TEST_SDRAM_SRC_BUFFER + DMA_TEST_SDRAM_BUF_SIZE)
#ifdef _WINDOWS
extern UINT32 dma_source_buffer [];
extern UINT32 dma_destination_buffer [];
#define DMA_TEST_SRC_MEM(offset) dma_source_buffer [offset]
#define DMA_TEST_DST_MEM(offset) dma_destination_buffer [offset]
#else
#define DMA_TEST_SRC_MEM(offset) * (volatile SYS_UWORD32 *) (DMA_TEST_SDRAM_SRC_BUFFER + offset)
#define DMA_TEST_DST_MEM(offset) * (volatile SYS_UWORD32 *) (DMA_TEST_SDRAM_DST_BUFFER + offset)
#endif //_WINDOWS
/**********************************************************************/
/**
* All ICT tests shall start at 200
*/
#define ICT_TEST_OFFSET 200
/**
* Manages the messages that DMA can send during the MISC test number 1.
* The messages are forwarded by RTEST.
*
* @param msg_p Pointer on the header of the message.
* @return RVM_OK
*/
T_RVM_RETURN dma_test_handle_message_1 (T_RV_HDR *msg_p)
{
if (msg_p != NULL)
{
switch (((T_RV_HDR*)msg_p)->msg_id)
{
/*
* We use rtest_send_result to end the test and to
* send the result of the test back to the test task.
* It unblocks the test task.
* The parameter of rtest_send_result can take the values
* TEST_PASSED, TEST_FAILED or TEST_IRRECOVERABLY_FAILED
*/
/*rtest_send_result(TEST_IRRECOVERABLY_FAILED);*/
default:
RV_TEST_TRACE_WARNING("DMA Test: Unexpected message returned");
break;
}
rvf_free_buf(msg_p);
}
return RVM_OK;
}
/**
* Initializes some parameters so that a test can start with a reset situation
*
*/
void dma_test_init (void)
{
UINT8 n;
extern T_DMA_ENV_CTRL_BLK* dma_env_ctrl_blk_p;
extern T_DMA_CHANNEL_ARRAY dma_channel_array [DMA_MAX_NUMBER_OF_CHANNEL];
extern T_DMA_QUEUE_ARRAY dma_queue_array [DMA_MAX_QUEUED_REQUESTS];
extern UINT8 dma_function_status [DMA_MAX_NUMBER_OF_CHANNEL];
/* At start up all the channels are free */
for (n=0; ndma_queue_index = DMA_QUEUE_INDEX_MIN;
}
/**
* Initializes all the parameters required for a transfer to a default value
*
*/
void dma_test_set_default_parameters (T_DMA_CHANNEL_PARAMETERS *dma_channel_parameters)
{
dma_channel_parameters->data_width = DMA_DATA_S32;
dma_channel_parameters->sync = DMA_SYNC_DEVICE_NONE;
dma_channel_parameters->hw_priority = DMA_HW_PRIORITY_LOW;
dma_channel_parameters->dma_mode = DMA_SINGLE;
dma_channel_parameters->flush = DMA_FLUSH_DISABLED;
dma_channel_parameters->nmb_frames = 1;
dma_channel_parameters->nmb_elements = 64;
dma_channel_parameters->dma_end_notification = DMA_NO_NOTIFICATION;
dma_channel_parameters->secure = DMA_NOT_SECURED;
dma_channel_parameters->transfer = DMA_MODE_TRANSFER_DISABLE;
dma_channel_parameters->source_address = DMA_TEST_SDRAM_SRC_BUFFER;
dma_channel_parameters->source_address_mode = DMA_ADDR_MODE_POST_INC;
dma_channel_parameters->source_packet = DMA_NOT_PACKED;
dma_channel_parameters->source_burst = DMA_NO_BURST;
dma_channel_parameters->destination_address = DMA_TEST_SDRAM_DST_BUFFER;
dma_channel_parameters->destination_address_mode = DMA_ADDR_MODE_POST_INC;
dma_channel_parameters->destination_packet = DMA_NOT_PACKED;
dma_channel_parameters->destination_burst = DMA_NO_BURST;
}
/**
* This test will reservate channel number 3 (specific)
*/
void dma_test_misc_201 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,3, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_RESERVE_OK:
case DMA_QUEUED:
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST channel returned: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
break;
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will remove a request from the queue
*/
void dma_test_misc_202 (void)
{
UINT8 queue_ind=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
UINT8 test_channel = DMA_MIN_CHANNEL +2;
/* set all needed parameters to zero */
dma_test_init ();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
/* Reserve a specific channel */
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,test_channel, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_RESERVE_OK:
{
DMA_TEST_SEND_TRACE ("DMA TEST specific channel reservated ",\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST channel returned: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
break;
}
rvf_free_buf (msg_p);
/* Reservate the channel again, so it is queued */
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,test_channel, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_QUEUED:
{
/* store the index the function has returned */
queue_ind = msg_p->result.channel;
DMA_TEST_SEND_TRACE ("DMA TEST specific channel has been queued",\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST index value: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
break;
}
rvf_free_buf (msg_p);
/* remove the reservation from the queue */
if (dma_remove_from_queue (queue_ind) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_REMOVED_FROM_QUEUE)
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST ok. Queued place freed. Index: ",\
queue_ind,\
DMA_TRACE_LEVEL);
}
else
{
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
/* release the channel */
if (dma_release_channel (test_channel) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if ((msg_p->result.status == DMA_CHANNEL_RELEASED) &&
(msg_p->result.channel == test_channel))
{
DMA_TEST_SEND_TRACE_PARAM("DMA released channel number:" ,\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
}
else
{
DMA_TEST_SEND_TRACE_PARAM("DMA released WRONG channel number:" ,\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
/* reserve the channel again, it should not be queue or something like that */
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,test_channel, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if ((msg_p->result.status== DMA_RESERVE_OK) &&
(msg_p->result.channel == test_channel))
{
DMA_TEST_SEND_TRACE ("DMA TEST OK: specific channel reservated ",\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST channel returned: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will set the parameters to setup a DMA transfer
*/
void dma_test_misc_203 (void)
{
T_DMA_CHANNEL_PARAMETERS dma_channel_parameters;
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
dma_test_init ();
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,3, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_RESERVE_OK:
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST channel returned: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
break;
}
rvf_free_buf (msg_p);
for (n=0; n<64; n++)
{
DMA_TEST_SRC_MEM(n) = 0x55555555;
DMA_TEST_DST_MEM(n) = 0xFEFEFEFE;
}
dma_test_set_default_parameters(&dma_channel_parameters);
/* As for a message from the interrupt handler */
dma_channel_parameters.dma_end_notification = DMA_NOTIFICATION;
if (dma_set_channel_parameters (3, &dma_channel_parameters) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status != DMA_PARAM_SET)
{
rtest_send_result (TEST_FAILED);
}
else
{
rtest_send_result (TEST_PASSED);
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will start the DMA transfer
*/
void dma_test_misc_204 (void)
{
T_DMA_STATUS_RSP_MSG *msg_p;
UINT8 n=0, test_channel =3;
extern UINT8 dma_function_status [];
extern T_DMA_CHANNEL_ARRAY dma_channel_array [DMA_MAX_NUMBER_OF_CHANNEL];
if (dma_function_status[test_channel] >=
DMA_FUNCTION_PARAMS_SET_UP)
{
if (dma_enable_transfer (test_channel) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_CHANNEL_ENABLED)
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST received DMA_CHANNEL_ENABLED ",\
msg_p->result.status, DMA_TRACE_LEVEL);
}
else
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST did NOT receive DMA_CHANNEL_ENABLED ",\
msg_p->result.status, DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
if (dma_channel_array[test_channel].dma_end_notification_bool == DMA_NOTIFICATION)
{
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_COMPLETED)
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST interrupt received: DMA_COMPLETED",\
msg_p->result.status, DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST interrupt NOT received: DMA_COMPLETED",\
msg_p->result.status, DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
}
}
else
{
DMA_TEST_SEND_TRACE("DMA TEST !! TEST NOT EXECUTED !!!!!!",\
RV_TRACE_LEVEL_ERROR);
DMA_TEST_SEND_TRACE("DMA TEST !! Run test 203 before running this test !!",\
RV_TRACE_LEVEL_ERROR);
rtest_send_result (TEST_PASSED);
return;
}
return;
}
/**
* This test will read the destination buffer to see if the DMA
* transfer was successfull
*/
void dma_test_misc_205 (void)
{
UINT8 n=0;
for (n=0; n<32; n++)
{
DMA_TEST_SEND_TRACE_PARAM("S. buffer:" ,DMA_TEST_SRC_MEM(n),\
DMA_TRACE_LEVEL);
}
for (n=0; n<32; n++)
{
DMA_TEST_SEND_TRACE_PARAM("D. buffer:" ,DMA_TEST_DST_MEM(n),\
DMA_TRACE_LEVEL);
}
rtest_send_result (TEST_PASSED);
return;
}
/**
* This test will release channel 3
*/
void dma_test_misc_206 (void)
{
UINT8 dma_channel_to_be_released=3;
T_DMA_STATUS_RSP_MSG *msg_p;
T_RV_RETURN_PATH dma_test_path;
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
/* clear everything */
dma_test_init();
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,dma_channel_to_be_released,
DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_RESERVE_OK:
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST channel returned: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
break;
}
rvf_free_buf (msg_p);
if (dma_release_channel (dma_channel_to_be_released) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if ((msg_p->result.status == DMA_CHANNEL_RELEASED) &&
(msg_p->result.channel == dma_channel_to_be_released))
{
DMA_TEST_SEND_TRACE_PARAM("DMA released channel number:" ,\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
}
else
{
DMA_TEST_SEND_TRACE_PARAM("DMA released WRONG channel number:" ,\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
/* now reservate the channel again to see if it was realley released */
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,dma_channel_to_be_released,
DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_RESERVE_OK &&
msg_p->result.channel == dma_channel_to_be_released)
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST channel returned: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will reservate channel number DMA_MAX_CHANNEL+1 (specific)
* This is not allowed
*/
void dma_test_misc_207 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
/* clear everything */
dma_test_init();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,DMA_MAX_CHANNEL+1,
DMA_QUEUE_ENABLE, SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_INVALID_PARAMETER:
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA TEST channel returned: ",\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
break;
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will give a memory dump
*/
void dma_test_misc_210 (void)
{
rvf_dump_mem();
rvf_dump_tasks();
rtest_send_result (TEST_PASSED);
}
/**
*
* This test will try to occupy 6 channels
*/
void dma_test_misc_211 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
UINT8 test_result = DMA_TRUE;
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_ANY,0, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status != DMA_RESERVE_OK)
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
if (dma_reserve_channel (DMA_CHAN_ANY,0, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status != DMA_RESERVE_OK)
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
if (dma_reserve_channel (DMA_CHAN_ANY,0, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status != DMA_RESERVE_OK)
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
if (dma_reserve_channel (DMA_CHAN_ANY,0, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status != DMA_RESERVE_OK)
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
if (dma_reserve_channel (DMA_CHAN_ANY,0, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status != DMA_RESERVE_OK)
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
if (dma_reserve_channel (DMA_CHAN_ANY,0, DMA_QUEUE_ENABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status != DMA_RESERVE_OK)
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
if (test_result == DMA_TRUE)
{
rtest_send_result (TEST_PASSED);
}
else
{
rtest_send_result (TEST_PASSED);
}
return;
}
/**
* This test will get the software version
*/
void dma_test_misc_212 (void)
{
DMA_TEST_SEND_TRACE_PARAM("DMA major software version: " ,DMA_MAJOR,\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA minor software version: " ,DMA_MINOR,\
DMA_TRACE_LEVEL);
DMA_TEST_SEND_TRACE_PARAM("DMA build software version: " ,DMA_BUILD,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
return;
}
/**
* This test will reservate a channel and then provide it with
* information, so that the bytes to be transferred is 0. This
* is not allowed. An INVALID parameter indication should be returned
*
* This test will reset all parameters at the beginning of the start
*/
void dma_test_misc_213 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
T_DMA_CHANNEL_PARAMETERS dma_channel_parameters;
/* reset all parameters needed */
dma_test_init();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_ANY,DMA_MIN_CHANNEL, DMA_QUEUE_DISABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_RESERVE_OK:
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
break;
}
rvf_free_buf (msg_p);
dma_test_set_default_parameters(&dma_channel_parameters);
dma_channel_parameters.nmb_frames = 0;
dma_channel_parameters.nmb_elements = 0;
if (dma_set_channel_parameters (DMA_MIN_CHANNEL, &dma_channel_parameters) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_INVALID_PARAMETER)
{
DMA_TEST_SEND_TRACE ("DMA TEST result OK, INVALID parameter returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE
("DMA TEST result NOT OK, INVALID parameter NOT returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will reservate a channel and then provide it with
* information. This information contains an illegal memory adress.
*
* An INVALID parameter indication should be returned
*/
void dma_test_misc_215 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
T_DMA_CHANNEL_PARAMETERS dma_channel_parameters;
/* reset all parameters needed */
dma_test_init();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_ANY,DMA_MIN_CHANNEL, DMA_QUEUE_DISABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
switch (msg_p->result.status)
{
case DMA_RESERVE_OK:
{
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
}
break;
default:
DMA_TEST_SEND_TRACE_PARAM("DMA TEST result NOT OK, return value: ",\
msg_p->result.status,\
DMA_TRACE_LEVEL);
break;
}
rvf_free_buf (msg_p);
/* Adress mapping. The given adress should be out of the defined
* range to receive an error
* #define DMA_IMIF_MIN (0x08000000)
* #define DMA_IMIF_MAX (0x0FFFFFFF)
* Address mapping API RAM
* #define DMA_API_MIN1 (0xFFD00000)
* #define DMA_API_MAX1 (0xFFD03FFF)
* Address mapping API CTRL
* #define DMA_API_MIN2 (0xFFE00000)
* #define DMA_API_MAX2 (0xFFE00001)
* Address mapping RHEA (strobe 0)
* #define DMA_RHEA_MIN1 (0xFFFE0000)
* #define DMA_RHEA_MAX1 (0xFFFEFFFF)
* Address mapping RHEA (strobe 1)
* #define DMA_RHEA_MIN2 (0xFFFF0000)
* #define DMA_RHEA_MAX2 (0xFFFFFFFF)
*/
/* set the default values */
dma_test_set_default_parameters(&dma_channel_parameters);
/* set source adress to an illegal value */
dma_channel_parameters.source_address = 0;
if (dma_set_channel_parameters (DMA_MIN_CHANNEL, &dma_channel_parameters) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_INVALID_PARAMETER)
{
DMA_TEST_SEND_TRACE ("DMA TEST result OK, INVALID parameter returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE
("DMA TEST result NOT OK, INVALID parameter NOT returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will reservate a channel and then provide it with
* information.
* A wrong alignment for 16 bits data transfer will be provided
* in the source adress
*
* An INVALID parameter indication should be returned
*/
void dma_test_misc_218 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
T_DMA_CHANNEL_PARAMETERS dma_channel_parameters;
/* reset all parameters needed */
dma_test_init();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_ANY,DMA_MIN_CHANNEL, DMA_QUEUE_DISABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
/* msg_p not checked as it is assumed to be ok (because of reset)*/
rvf_free_buf (msg_p);
/* Adress mapping. The given adress should be out of the defined
* range to receive an error
* #define DMA_IMIF_MIN (0x08000000)
* #define DMA_IMIF_MAX (0x0FFFFFFF)
* Address mapping API RAM
* #define DMA_API_MIN1 (0xFFD00000)
* #define DMA_API_MAX1 (0xFFD03FFF)
* Address mapping API CTRL
* #define DMA_API_MIN2 (0xFFE00000)
* #define DMA_API_MAX2 (0xFFE00001)
* Address mapping RHEA (strobe 0)
* #define DMA_RHEA_MIN1 (0xFFFE0000)
* #define DMA_RHEA_MAX1 (0xFFFEFFFF)
* Address mapping RHEA (strobe 1)
* #define DMA_RHEA_MIN2 (0xFFFF0000)
* #define DMA_RHEA_MAX2 (0xFFFFFFFF)
*/
/* set the default values */
dma_test_set_default_parameters(&dma_channel_parameters);
/* Dest. adress plus data to be transferred is out of range */
dma_channel_parameters.source_address = DMA_TEST_SDRAM_SRC_BUFFER+1;
dma_channel_parameters.data_width = DMA_DATA_S16;
/* Prevent memory overlap for this test */
dma_channel_parameters.nmb_elements = 32;
if (dma_set_channel_parameters (DMA_MIN_CHANNEL, &dma_channel_parameters) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_INVALID_PARAMETER)
{
DMA_TEST_SEND_TRACE ("DMA TEST result OK, INVALID parameter returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE
("DMA TEST result NOT OK, INVALID parameter NOT returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will reservate a channel and then provide it with
* information.
* A wrong alignment for 32 bits data transfer will be provided
* in the destination adress
*
* An INVALID parameter indication should be returned
*/
void dma_test_misc_219 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
T_DMA_CHANNEL_PARAMETERS dma_channel_parameters;
/* reset all parameters needed */
dma_test_init();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_ANY,DMA_MIN_CHANNEL, DMA_QUEUE_DISABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
/* msg_p not checked as it is assumed to be ok (because of reset)*/
rvf_free_buf (msg_p);
/* Adress mapping. The given adress should be out of the defined
* range to receive an error
* #define DMA_IMIF_MIN (0x08000000)
* #define DMA_IMIF_MAX (0x0FFFFFFF)
* Address mapping API RAM
* #define DMA_API_MIN1 (0xFFD00000)
* #define DMA_API_MAX1 (0xFFD03FFF)
* Address mapping API CTRL
* #define DMA_API_MIN2 (0xFFE00000)
* #define DMA_API_MAX2 (0xFFE00001)
* Address mapping RHEA (strobe 0)
* #define DMA_RHEA_MIN1 (0xFFFE0000)
* #define DMA_RHEA_MAX1 (0xFFFEFFFF)
* Address mapping RHEA (strobe 1)
* #define DMA_RHEA_MIN2 (0xFFFF0000)
* #define DMA_RHEA_MAX2 (0xFFFFFFFF)
*/
/* set the default values */
dma_test_set_default_parameters(&dma_channel_parameters);
/* Dest. adress plus data to be transferred is out of range */
dma_channel_parameters.destination_address = DMA_TEST_SDRAM_DST_BUFFER+3;
if (dma_set_channel_parameters (DMA_MIN_CHANNEL, &dma_channel_parameters) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_INVALID_PARAMETER)
{
DMA_TEST_SEND_TRACE ("DMA TEST result OK, INVALID parameter returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE
("DMA TEST result NOT OK, INVALID parameter NOT returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
return;
}
/**
* This test will reservate a channel and then provide it with
* information.
* For the source adress a value is choosen in API memory and the burst
* option is choosen. This combiantion is not allowed
*
* An INVALID parameter indication should be returned
*/
void dma_test_misc_220 (void)
{
UINT8 n=0;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
T_DMA_CHANNEL_PARAMETERS dma_channel_parameters;
/* reset all parameters needed */
dma_test_init();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
if (dma_reserve_channel (DMA_CHAN_ANY,DMA_MIN_CHANNEL, DMA_QUEUE_DISABLE,
SW_PRIORITY_NORMAL, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
/* msg_p not checked as it is assumed to be ok (because of reset)*/
rvf_free_buf (msg_p);
/* Adress mapping. The given adress should be out of the defined
* range to receive an error
* #define DMA_IMIF_MIN (0x08000000)
* #define DMA_IMIF_MAX (0x0FFFFFFF)
* Address mapping API RAM
* #define DMA_API_MIN1 (0xFFD00000)
* #define DMA_API_MAX1 (0xFFD03FFF)
* Address mapping API CTRL
* #define DMA_API_MIN2 (0xFFE00000)
* #define DMA_API_MAX2 (0xFFE00001)
* Address mapping RHEA (strobe 0)
* #define DMA_RHEA_MIN1 (0xFFFE0000)
* #define DMA_RHEA_MAX1 (0xFFFEFFFF)
* Address mapping RHEA (strobe 1)
* #define DMA_RHEA_MIN2 (0xFFFF0000)
* #define DMA_RHEA_MAX2 (0xFFFFFFFF)
*/
/* set the default values */
dma_test_set_default_parameters(&dma_channel_parameters);
/* Dest. adress plus data to be transferred is out of range */
dma_channel_parameters.source_address = DMA_API_MIN1;
dma_channel_parameters.source_burst = DMA_BURST_ENABLED;
if (dma_set_channel_parameters (DMA_MIN_CHANNEL, &dma_channel_parameters) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if (msg_p->result.status == DMA_INVALID_PARAMETER)
{
DMA_TEST_SEND_TRACE ("DMA TEST result OK, INVALID parameter returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_PASSED);
}
else
{
DMA_TEST_SEND_TRACE
("DMA TEST result NOT OK, INVALID parameter NOT returned ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
}
rvf_free_buf (msg_p);
return;
}
/**
*
* This test will test the contention mechanism
*/
void dma_test_misc_221 (void)
{
UINT8 n=0,p;
T_RV_RETURN_PATH dma_test_path;
T_DMA_STATUS_RSP_MSG *msg_p;
UINT8 test_result = DMA_TRUE;
/* reset all parameters needed */
dma_test_init();
/* Sets message forwarding */
dma_test_path.addr_id = rtest_get_addr_id();
dma_test_path.callback_func = NULL;
/* Reserve 10 channels with increasing software priority */
/* last 4 reservatinos are queued */
for (n=10; n>0; n--)
{
p= n+10;
if (dma_reserve_channel (DMA_CHAN_ANY,0, DMA_QUEUE_ENABLE,
p, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if ((msg_p->result.status != DMA_RESERVE_OK) &&
(msg_p->result.status != DMA_QUEUED))
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
}
/* make an extra reservation with the highest priority and a specific channel */
if (dma_reserve_channel (DMA_CHAN_SPECIFIC,4, DMA_QUEUE_ENABLE,
0, dma_test_path) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if ((msg_p->result.status != DMA_RESERVE_OK) &&
(msg_p->result.status != DMA_QUEUED))
{
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
/* Free channel 4. Now the queued reservation with
the highest priority has to be granted */
/* free channel 4 */
if (dma_release_channel (4) != RV_OK)
{
DMA_TEST_SEND_TRACE("DMA TEST immediate return NOT OK ",\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
return;
}
/* wait for message that a channel is free (virtual client A) */
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if ((msg_p->result.status != DMA_CHANNEL_RELEASED) ||
(msg_p->result.channel != 4))
{
DMA_TEST_SEND_TRACE_PARAM("DMA released WRONG channel number:" ,\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
/* wait for message that a channel is free (virtual client B) */
msg_p = (T_DMA_STATUS_RSP_MSG *) rtest_wait_for_message (DMA_STATUS_RSP_MSG);
if ((msg_p->result.status != DMA_QUEUE_PROC) || ((msg_p->result.channel &0x7) != 4))
{
DMA_TEST_SEND_TRACE_PARAM
("WRONG queued reservation (shoot be 4) has been processed: " ,\
msg_p->result.channel,\
DMA_TRACE_LEVEL);
rtest_send_result (TEST_FAILED);
test_result = DMA_ZERO;
}
rvf_free_buf (msg_p);
if (test_result == DMA_TRUE)
{
rtest_send_result (TEST_PASSED);
}
else
{
rtest_send_result (TEST_PASSED);
}
return;
}
/**
* Main function multiplexing the different demos to process.
*
* This function returns the result of the test.
*
* @param test_number Number of the test to process
* @return Result of the test.
*/
T_RV_MISC_RET dma_test_misc2 (T_RV_MISC_TEST_NBR test_number)
{
T_RV_TEST_RET test_verdict;
switch (test_number)
{
case ICT_TEST1:
RV_TEST_TRACE_WARNING("*** DMA MISC 201 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_201);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST2:
RV_TEST_TRACE_WARNING("*** DMA MISC 202 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_202);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST3:
RV_TEST_TRACE_WARNING("*** DMA MISC 203 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_203);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST4:
RV_TEST_TRACE_WARNING("*** DMA MISC 204 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_204);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST5:
RV_TEST_TRACE_WARNING("*** DMA MISC 205 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_205);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST6:
RV_TEST_TRACE_WARNING("*** DMA MISC 206 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_206);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST7:
RV_TEST_TRACE_WARNING("*** DMA MISC 207 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_207);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST10:
RV_TEST_TRACE_WARNING("*** DMA MISC 210 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_210);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST11:
RV_TEST_TRACE_WARNING("*** DMA MISC 211 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_211);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST12:
RV_TEST_TRACE_WARNING("*** DMA MISC 212 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_212);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST13:
RV_TEST_TRACE_WARNING("*** DMA MISC 213 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_213);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
//#ifndef _WINDOWS
case ICT_TEST15:
RV_TEST_TRACE_WARNING("*** DMA MISC 215 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_215);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
//#endif // _WINDOWS
case ICT_TEST18:
RV_TEST_TRACE_WARNING("*** DMA MISC 218 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_218);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
case ICT_TEST19:
RV_TEST_TRACE_WARNING("*** DMA MISC 219 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_219);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
#ifndef _WINDOWS
case ICT_TEST20:
RV_TEST_TRACE_WARNING("*** DMA MISC 220 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_220);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
#endif //_WINDOWS
case ICT_TEST21:
RV_TEST_TRACE_WARNING("*** DMA MISC 221 BEGINS");
test_verdict = rtest_start_test(dma_test_misc_221);
rtest_trace_test_verdict(test_verdict);
return test_verdict;
default:
RV_TEST_TRACE_WARNING("DMA Test: Wrong test number");
return TEST_IRRECOVERABLY_FAILED;
}
}