examples/edma3_driver/src/dma_misc_test.c

   1 #include "sample.h"
   2
   3 /**
   4  *  \brief   EDMA3 misc test cases.
   5  *              This test case will read/write to some CC registers.
   6  *
   7  *  \return  EDMA3_DRV_SOK or EDMA3_DRV Error Code
   8  */
   9 EDMA3_DRV_Result edma3_misc_test()
  10     {
  11     EDMA3_DRV_Result drvResult = EDMA3_DRV_SOK;
  12     unsigned int ccRegOffset = 0u;
  13     unsigned int ccRegVal = 0u;
  14     unsigned int newRegVal = 0u;
  15     unsigned int origRegVal = 0u;
  16
  17
  18     /**
  19      *1. Try fetching some CC registers value.
  20      * It should PASS.
  21      */
  22     /* PID Register */
  23     ccRegOffset = 0x0u;
  24     ccRegVal = 0;
  25     drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
  26
  27     if (drvResult != EDMA3_DRV_SOK)
  28         {
  29 #ifdef EDMA3_DRV_DEBUG
  30         EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
  31 #endif
  32         }
  33     else
  34         {
  35 #ifdef EDMA3_DRV_DEBUG
  36         EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
  37 #endif
  38
  39 #ifdef EDMA3_DEBUG_PRINT
  40         EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, ccRegVal);
  41 #endif  /* EDMA3_DEBUG_PRINT */
  42         }
  43
  44
  45     if (drvResult == EDMA3_DRV_SOK)
  46         {
  47         /* Fetch DRAE1 Register */
  48         ccRegOffset = 0x0348u;
  49         ccRegVal = 0;
  50         drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
  51
  52         if (drvResult != EDMA3_DRV_SOK)
  53             {
  54 #ifdef EDMA3_DRV_DEBUG
  55             EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
  56 #endif
  57             }
  58         else
  59             {
  60 #ifdef EDMA3_DRV_DEBUG
  61             EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
  62 #endif
  63
  64 #ifdef EDMA3_DEBUG_PRINT
  65             EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, ccRegVal);
  66 #endif  /* EDMA3_DEBUG_PRINT */
  67             }
  68         }
  69
  70
  71     if (drvResult == EDMA3_DRV_SOK)
  72         {
  73         /* Fetch QWMTHRA Register */
  74         ccRegOffset = 0x0620u;
  75         ccRegVal = 0;
  76         drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
  77
  78         if (drvResult != EDMA3_DRV_SOK)
  79             {
  80 #ifdef EDMA3_DRV_DEBUG
  81             EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
  82 #endif
  83             return drvResult;
  84             }
  85         else
  86             {
  87 #ifdef EDMA3_DRV_DEBUG
  88             EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
  89 #endif
  90
  91 #ifdef EDMA3_DEBUG_PRINT
  92             EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, ccRegVal);
  93 #endif  /* EDMA3_DEBUG_PRINT */
  94             }
  95         }
  96
  97
  98
  99     /**
 100      * 2. Try fetching some CC registers value, whose offset is not 4-bytes
 101      * aligned. It should FAIL.
 102      */
 103     if (drvResult == EDMA3_DRV_SOK)
 104         {
 105         ccRegOffset = 0x1002u;
 106         ccRegVal = 0x0u;
 107         drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
 108
 109         if (drvResult == EDMA3_DRV_E_INVALID_PARAM)
 110             {
 111 #ifdef EDMA3_DEBUG_PRINT
 112             EDMA3_DEBUG_PRINTF ("Fetching Invalid CC Register (offset 0X%x) Failed, test PASSED\r\n", ccRegOffset);
 113 #endif  /* EDMA3_DEBUG_PRINT */
 114             drvResult = EDMA3_DRV_SOK;
 115             }
 116         else
 117             {
 118 #ifdef EDMA3_DEBUG_PRINT
 119             EDMA3_DEBUG_PRINTF ("Fetching Invalid CC Register (offset 0X%x) Passed, test FAILED\r\n", ccRegOffset);
 120 #endif  /* EDMA3_DEBUG_PRINT */
 121             }
 122         }
 123
 124
 125
 126     /**
 127      * 3. Read CC Register QWMTHRA. Store the current value. Write a different
 128      * value on it. Read it back. Write the original value again. Read it back to
 129      * cross-check. It should PASS.
 130      */
 131     if (drvResult == EDMA3_DRV_SOK)
 132         {
 133         ccRegOffset = 0x0620u;
 134         origRegVal = 0x0u;
 135         drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &origRegVal);
 136
 137         if (drvResult != EDMA3_DRV_SOK)
 138             {
 139 #ifdef EDMA3_DRV_DEBUG
 140             EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
 141 #endif
 142             }
 143         else
 144             {
 145 #ifdef EDMA3_DRV_DEBUG
 146             EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
 147 #endif
 148
 149 #ifdef EDMA3_DEBUG_PRINT
 150             EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, origRegVal);
 151 #endif  /* EDMA3_DEBUG_PRINT */
 152
 153             /* Find the new value to be written, it depends on the no of event queues */
 154             switch (origRegVal)
 155                 {
 156                 /* Write a new value on the same register */
 157                 case 0x10:
 158                     /* 1 TC */
 159                     newRegVal = 0x0Fu;
 160                     break;
 161
 162                 case 0x1010:
 163                     /* 2 TC */
 164                     newRegVal = 0x0F0Fu;
 165                     break;
 166
 167                 case 0x101010:
 168                     /* 3 TC */
 169                     newRegVal = 0x0F0F0Fu;
 170                     break;
 171
 172                 case 0x10101010:
 173                     /* 4 TC */
 174                     newRegVal = 0x0F0F0F0Fu;
 175                     break;
 176
 177                 default:
 178                     newRegVal = origRegVal;
 179                     break;
 180                 }
 181
 182             drvResult = EDMA3_DRV_setCCRegister (hEdma, ccRegOffset, newRegVal);
 183             if (drvResult == EDMA3_DRV_SOK)
 184                 {
 185                 /* If write is successful, read it back to check */
 186                 ccRegVal = 0x0u;
 187
 188                 drvResult = EDMA3_DRV_getCCRegister (hEdma, ccRegOffset, &ccRegVal);
 189                 if (drvResult == EDMA3_DRV_SOK)
 190                     {
 191                     /* Check with the value which we have written */
 192                     if (newRegVal == ccRegVal)
 193                         {
 194 #ifdef EDMA3_DEBUG_PRINT
 195                         EDMA3_DEBUG_PRINTF ("Value written successfully \r\n");
 196 #endif  /* EDMA3_DEBUG_PRINT */
 197                         }
 198                     else
 199                         {
 200 #ifdef EDMA3_DRV_DEBUG
 201                         EDMA3_DRV_PRINTF ("QWMTHRA write FAILED \r\n");
 202 #endif
 203                         drvResult = EDMA3_DRV_E_INVALID_PARAM;
 204                         }
 205                     }
 206
 207                 /* Restore the original value */
 208                 if (drvResult == EDMA3_DRV_SOK)
 209                     {
 210                     drvResult = EDMA3_DRV_setCCRegister (hEdma, ccRegOffset, origRegVal);
 211                     if (drvResult != EDMA3_DRV_SOK)
 212                         {
 213 #ifdef EDMA3_DEBUG_PRINT
 214                         EDMA3_DEBUG_PRINTF ("QWMTHRA Restore FAILED\r\n");
 215 #endif  /* EDMA3_DEBUG_PRINT */
 216                         }
 217                     else
 218                         {
 219 #ifdef EDMA3_DEBUG_PRINT
 220                         EDMA3_DEBUG_PRINTF ("QWMTHRA Restore Successful\r\n");
 221 #endif  /* EDMA3_DEBUG_PRINT */
 222                         }
 223                     }
 224                 }
 225             }
 226         }
 227
 228
 229     return drvResult;
 230     }
 231