📄 dma_test_misc2.c

📁 MMI层OBJ不能完全编译
💻 C
📖 第 1 页 / 共 4 页
字号:
    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)
  {
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -