sw/app/rocon/appl_tests.c

   1 #include <system_def.h>
   2 #include <stdio.h>
   3 #include <unistd.h>
   4 #include <string.h>
   5 #include <ctype.h>
   6 #include <stddef.h>
   7 #include <malloc.h>
   8 #include <utils.h>
   9 #include <cmd_proc.h>
  10 #include <hal_gpio.h>
  11 #include <hal_machperiph.h>
  12 #include <LPC17xx.h>
  13 #include <lpcTIM.h>
  14 #include <spi_drv.h>
  15 #include <pxmc.h>
  16 #include <inttypes.h>
  17
  18 #include <ul_log.h>
  19 #include <ul_logreg.h>
  20
  21 #include "appl_defs.h"
  22 #include "appl_fpga.h"
  23 #include "appl_pxmc.h"
  24 #include "pxmcc_types.h"
  25 #include "pxmcc_interface.h"
  26
  27 int cmd_do_test_memusage(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  28 {
  29   void *maxaddr;
  30   char str[40];
  31
  32   maxaddr = sbrk(0);
  33
  34   snprintf(str, sizeof(str), "memusage maxaddr 0x%08lx\n", (unsigned long)maxaddr);
  35   cmd_io_write(cmd_io, str, strlen(str));
  36
  37   return 0;
  38 }
  39
  40 int cmd_do_test_adc(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  41 {
  42   printf("ADC: %ld %ld %ld %ld %ld\n", (LPC_ADC->DR[0] & 0xFFF0) >> 4,
  43          (LPC_ADC->DR[1] & 0xFFF0) >> 4,
  44          (LPC_ADC->DR[2] & 0xFFF0) >> 4,
  45          (LPC_ADC->DR[3] & 0xFFF0) >> 4,
  46          (LPC_ADC->DR[7] & 0xFFF0) >> 4);
  47   return 0;
  48 }
  49
  50 #ifdef APPL_WITH_DISTORE_EEPROM_USER
  51 int cmd_do_test_distore(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  52 {
  53   appl_distore_user_set_check4change();
  54   return 0;
  55 }
  56
  57 int cmd_do_test_diload(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  58 {
  59   appl_distore_user_restore();
  60   return 0;
  61 }
  62 #endif /*APPL_WITH_DISTORE_EEPROM_USER*/
  63
  64 int cmd_do_test_loglevel_cb(ul_log_domain_t *domain, void *context)
  65 {
  66   char s[30];
  67   cmd_io_t *cmd_io = (cmd_io_t *)context;
  68
  69   s[sizeof(s) - 1] = 0;
  70   snprintf(s, sizeof(s) - 1, "%s (%d)\n\r", domain->name, domain->level);
  71   cmd_io_puts(cmd_io, s);
  72   return 0;
  73 }
  74
  75 int cmd_do_test_loglevel(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  76 {
  77   int res = 0;
  78   char *line;
  79   line = param[1];
  80
  81   if (!line || (si_skspace(&line), !*line))
  82   {
  83     ul_logreg_for_each_domain(cmd_do_test_loglevel_cb, cmd_io);
  84   }
  85   else
  86   {
  87     res = ul_log_domain_arg2levels(line);
  88   }
  89
  90   return res >= 0 ? 0 : CMDERR_BADPAR;
  91 }
  92
  93 int cmd_do_spimst_blocking(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
  94 {
  95   int res;
  96   int opchar;
  97   char *p = param[3];
  98   int spi_chan = (int)(intptr_t)des->info[0];
  99   uint8_t *tx_buff = NULL;
 100   uint8_t *rx_buff = NULL;
 101   long addr = 0;
 102   int len = 0;
 103   spi_drv_t *spi_drv;
 104
 105   if ((opchar = cmd_opchar_check(cmd_io, des, param)) < 0)
 106     return opchar;
 107
 108   if (opchar != ':')
 109     return -CMDERR_OPCHAR;
 110
 111   if (spi_chan == -1)
 112     spi_chan = *param[1] - '0';
 113
 114   spi_drv = spi_find_drv(NULL, spi_chan);
 115
 116   if (spi_drv == NULL)
 117     return -CMDERR_BADSUF;
 118
 119   p = param[3];
 120
 121   si_skspace(&p);
 122
 123   if (isdigit((int)*p))
 124   {
 125     if (si_long(&p, &addr, 16) < 0)
 126       return -CMDERR_BADPAR;
 127   }
 128
 129   if (si_fndsep(&p, "({") < 0)
 130     return -CMDERR_BADSEP;
 131
 132   if ((res = si_add_to_arr(&p, (void **)&tx_buff, &len, 16, 1, "})")) < 0)
 133     return -CMDERR_BADPAR;
 134
 135   rx_buff = malloc(len);
 136
 137   res = -1;
 138
 139   if (rx_buff != NULL)
 140     res = spi_transfer(spi_drv, addr, len, tx_buff, rx_buff);
 141
 142   if (res < 0)
 143   {
 144     printf("SPI! %02lX ERROR\n", addr);
 145   }
 146   else
 147   {
 148     int i;
 149     printf("SPI! %02lX ", addr);
 150     printf("TX(");
 151
 152     for (i = 0; i < len; i++)
 153       printf("%s%02X", i ? "," : "", tx_buff[i]);
 154
 155     printf(") RX(");
 156
 157     for (i = 0; i < len; i++)
 158       printf("%s%02X", i ? "," : "", rx_buff[i]);
 159
 160     printf(")");
 161     printf("\n");
 162     return 0;
 163   }
 164
 165   if (rx_buff)
 166     free(rx_buff);
 167
 168   if (tx_buff)
 169     free(tx_buff);
 170
 171   return 0;
 172 }
 173
 174 int cmd_do_mtdspitest(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 175 {
 176   mtd_spi_test();
 177   return 0;
 178 }
 179
 180 #ifdef SDRAM_BASE
 181 int sdram_access_test(void)
 182 {
 183   unsigned int *ptr;
 184   unsigned int pattern;
 185   size_t ramsz = SDRAM_SIZE;
 186   size_t cnt;
 187   lt_mstime_t tic;
 188   size_t blksz, i;
 189
 190   lt_mstime_update();
 191   tic = actual_msec;
 192
 193   pattern = 0x12abcdef;
 194
 195   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 196   {
 197     *(ptr++) = pattern;
 198     pattern = pattern + 0x87654321;
 199   }
 200
 201   lt_mstime_update();
 202   printf("SDRAM write %d ms\n", (int)(lt_msdiff_t)(actual_msec - tic));
 203
 204   lt_mstime_update();
 205   tic = actual_msec;
 206
 207   pattern = 0x12abcdef;
 208
 209   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 210   {
 211     if (*ptr != pattern)
 212     {
 213       printf("SDRAM error modify at %p (%08x)\n", ptr, *ptr ^ pattern);
 214       return -1;
 215     }
 216
 217     *(ptr++) = ~pattern;
 218     pattern = pattern + 0x87654321;
 219   }
 220
 221   lt_mstime_update();
 222   printf("SDRAM modify %d ms\n", (int)(lt_msdiff_t)(actual_msec - tic));
 223
 224   lt_mstime_update();
 225   tic = actual_msec;
 226
 227   pattern = 0x12abcdef;
 228
 229   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 230   {
 231     if (*(ptr++) != ~pattern)
 232     {
 233       printf("SDRAM error read at %p (%08x)\n", ptr, *ptr ^ pattern);
 234       return -1;
 235     }
 236
 237     pattern = pattern + 0x87654321;
 238   }
 239
 240   lt_mstime_update();
 241   printf("SDRAM read %d ms\n", (int)(lt_msdiff_t)(actual_msec - tic));
 242
 243   lt_mstime_update();
 244   tic = actual_msec;
 245
 246   pattern = 0;
 247
 248   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 249   {
 250     pattern += *(ptr++);
 251   }
 252
 253   lt_mstime_update();
 254   printf("SDRAM sum %d ms res 0x%08x\n", (int)(lt_msdiff_t)(actual_msec - tic), pattern);
 255
 256   for (blksz = 1; blksz < 256 ; blksz *= 2)
 257   {
 258     lt_mstime_update();
 259     tic = actual_msec;
 260
 261     pattern = 0;
 262
 263     for (cnt = ramsz / sizeof(*ptr); cnt; cnt -= blksz)
 264     {
 265       ptr = (typeof(ptr))SDRAM_BASE;
 266
 267       //ptr = (typeof(ptr))cmd_do_test_memusage;
 268       //ptr = (typeof(ptr))&ptr;
 269       for (i = blksz; i--;)
 270         pattern += *(ptr++);
 271     }
 272
 273     lt_mstime_update();
 274     printf("SDRAM sum %d blksz %d ms res 0x%08x\n", (int)(lt_msdiff_t)(actual_msec - tic), (int)blksz, pattern);
 275   }
 276
 277   return 0;
 278 }
 279
 280 int cmd_do_testsdram(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 281 {
 282   sdram_access_test();
 283   return 0;
 284 }
 285 #endif /*SDRAM_BASE*/
 286
 287 int cmd_do_testlxpwrrx(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 288 {
 289   char *ps = param[1];
 290   long mode = 0;
 291   uint32_t *ptr;
 292
 293   if (ps != NULL) {
 294     si_skspace(&ps);
 295     if (*ps) {
 296       if (si_ulong(&ps, &mode, 0) < 0)
 297         return -CMDERR_BADPAR;
 298     }
 299   }
 300   pxmc_rocon_rx_data_hist_buff = NULL;
 301   pxmc_rocon_rx_data_hist_mode = mode;
 302
 303  #ifndef PXMC_ROCON_TIMED_BY_RX_DONE
 304   pxmc_rocon_rx_done_isr_setup(pxmc_rocon_rx_done_isr);
 305  #endif /*PXMC_ROCON_TIMED_BY_RX_DONE*/
 306   pxmc_rocon_rx_data_hist_buff_end = (void *)(FPGA_CONFIGURATION_FILE_ADDRESS +
 307                                          0x80000);
 308   ptr = (void *)FPGA_CONFIGURATION_FILE_ADDRESS;
 309   if (mode != 0) {
 310     *(ptr++) = '10XL';
 311     *(ptr++) = mode;
 312   }
 313   pxmc_rocon_rx_data_hist_buff = (void *)ptr;
 314   return 0;
 315 }
 316
 317 int cmd_do_testlxpwrstat(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 318 {
 319   printf("lxpwrrx period %ld latency %ld max %ld\n",
 320          (long)pxmc_rocon_rx_cycle_time, (long)pxmc_rocon_rx_irq_latency,
 321          (long)pxmc_rocon_rx_irq_latency_max);
 322   return 0;
 323 }
 324
 325 #include <math.h>
 326
 327 int cmd_do_testfncapprox(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 328 {
 329   char *ps = param[1];
 330   unsigned long fnc;
 331   unsigned long val;
 332   unsigned long res;
 333   long diff;
 334   long diff_max = 0;
 335   unsigned int  xb;
 336   uint32_t x;
 337   uint32_t xl;
 338   double   xf;
 339   int64_t  yl;
 340   long count = 1;
 341   long step = 1 << (30-7-18+1  +4);
 342
 343   si_skspace(&ps);
 344   if (si_ulong(&ps, &fnc, 0) < 0)
 345       return -CMDERR_BADPAR;
 346
 347   si_skspace(&ps);
 348   if (!strcmp(ps, "all")) {
 349     val = 0;
 350     count = 0x80000000UL / step;
 351     if (fnc == 1) {
 352       val = 1;
 353     }
 354   } else {
 355     if (si_ulong(&ps, &val, 0) < 0)
 356         return -CMDERR_BADPAR;
 357   }
 358
 359   for (; count--;  val += step) {
 360
 361     if (fnc == 1) {
 362       x = val;
 363       xb = __builtin_clz(x);
 364       xl = x << xb;
 365     } else {
 366       xl = val;
 367     }
 368
 369     fpga_fncapprox_base[fnc] = xl;
 370
 371     /* dummy read to provide time to function aproximator to proceed computation */
 372     res = fpga_fncapprox_base[fnc];
 373     res = fpga_fncapprox_base[fnc];
 374
 375     switch (fnc) {
 376       case 0:
 377         yl = xl;
 378       case 1:
 379         yl = (1LL << 62) / xl;
 380         break;
 381       case 2:
 382         xf = (double)xl * M_PI / 2.0 / (1UL << 30);
 383         yl = round(sin(xf) * (1UL << 16));
 384         break;
 385       case 3:
 386         xf = (double)xl * M_PI / 2.0 / (1UL << 30);
 387         yl = round(cos(xf) * (1UL << 16));
 388         break;
 389       default:
 390       yl = 0;
 391     }
 392
 393     diff = yl - res;
 394
 395     if ((diff > 0) && (diff > diff_max))
 396       diff_max = diff;
 397     else if ((diff < 0) && (-diff > diff_max))
 398       diff_max = -diff;
 399
 400   }
 401
 402   val -= step;
 403
 404   printf("fnc=%ld val=0x%08lx res=0x%08lx ref=0x%08lx diff=%ld max %ld\n",
 405          fnc, val, res, (unsigned long)yl, diff, diff_max);
 406
 407   return 0;
 408 }
 409
 410 int cmd_do_testtumblefw(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 411 {
 412   char *ps = param[1];
 413   long pwm_d;
 414   long pwm_q;
 415   pxmc_state_t *mcs = pxmc_main_list.pxml_arr[0];
 416   volatile pxmcc_data_t *mcc_data = pxmc_rocon_mcc_data();
 417
 418   pxmcc_axis_enable(mcs, 0);
 419
 420   si_skspace(&ps);
 421   if (si_long(&ps, &pwm_d, 0) < 0)
 422       return -CMDERR_BADPAR;
 423
 424   si_skspace(&ps);
 425   if (si_ulong(&ps, &pwm_q, 0) < 0)
 426         return -CMDERR_BADPAR;
 427
 428
 429   if (0) {
 430     pxmcc_axis_setup(mcs, PXMCC_MODE_BLDC);
 431   }
 432   pxmc_clear_flags(mcs,PXMS_ENO_m|PXMS_ENG_m|PXMS_ENR_m|PXMS_BSY_m);
 433   pxmcc_axis_pwm_dq_out(mcs, pwm_d, pwm_q);
 434   pxmcc_axis_enable(mcs, 1);
 435
 436   if (0) {
 437     mcc_data->axis[1].inp_info = 0;
 438     mcc_data->axis[1].out_info = 3;
 439     mcc_data->axis[1].pwmtx_info = (12 << 0) | (13 << 8) | (14 << 16);
 440     mcc_data->axis[1].mode = PXMCC_MODE_BLDC;
 441     mcc_data->axis[1].ccflg = 1;
 442     mcc_data->axis[2].inp_info = 0;
 443     mcc_data->axis[2].out_info = 6;
 444     mcc_data->axis[2].pwmtx_info = (15 << 0) | (16 << 8) | (18 << 16);
 445     mcc_data->axis[2].mode = PXMCC_MODE_BLDC;
 446     mcc_data->axis[2].ccflg = 1;
 447     mcc_data->axis[3].inp_info = 0;
 448     mcc_data->axis[3].out_info = 9;
 449     mcc_data->axis[3].pwmtx_info = (19 << 0) | (20 << 8) | (21 << 16);
 450     mcc_data->axis[3].mode = PXMCC_MODE_BLDC;
 451     mcc_data->axis[3].ccflg = 1;
 452   }
 453
 454   printf("spd %ld act_idle %"PRIu32" min_idle %"PRIu32" avail %lu pwm_cycle %"PRIu32"\n",
 455          mcs->pxms_as, mcc_data->common.act_idle, mcc_data->common.min_idle,
 456          (mcc_data->common.pwm_cycle + 6) / 6, mcc_data->common.pwm_cycle);
 457   mcc_data->common.min_idle = 0x7fff;
 458
 459   return 0;
 460 }
 461
 462 #define CK_IRC_WORDS 16
 463 #define CK_TX_WORDS  16
 464 #define CK_RX_WORDS  16
 465
 466 #define CK_IRC_START ((uint32_t*)fpga_irc[0])
 467 #define CK_TX_START  (fpga_lx_master_transmitter_base+9)
 468 #define CK_RX_START  (fpga_lx_master_receiver_base+44)
 469
 470 typedef struct ck_state_t {
 471   uint32_t ck_irc_base[CK_IRC_WORDS];
 472   uint32_t ck_irc_read[CK_IRC_WORDS];
 473   uint32_t ck_tx_base[CK_TX_WORDS];
 474   uint32_t ck_tx_read[CK_TX_WORDS];
 475   uint32_t ck_rx_base[CK_RX_WORDS];
 476   uint32_t ck_rx_read[CK_RX_WORDS];
 477
 478   uint32_t ck_irc_err;
 479   uint32_t ck_tx_err;
 480   uint32_t ck_rx_err;
 481 } ck_state_t;
 482
 483 int cmd_do_testtumblebus(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 484 {
 485   int i;
 486   int cycles = 10000;
 487   static ck_state_t *ckst = NULL;
 488   if (ckst == NULL)
 489     ckst = malloc(sizeof(*ckst));
 490   if (ckst == NULL)
 491     return 1;
 492
 493   ckst->ck_irc_err = 0;
 494   ckst->ck_tx_err = 0;
 495   ckst->ck_rx_err = 0;
 496
 497   for (i = 0; i < CK_IRC_WORDS; i++)
 498     ckst->ck_irc_base[i] = CK_IRC_START[i];
 499
 500   for (i = 0; i < CK_TX_WORDS; i++)
 501     ckst->ck_tx_base[i] = CK_TX_START[i];
 502
 503   for (i = 0; i < CK_RX_WORDS; i++)
 504     ckst->ck_rx_base[i] = CK_RX_START[i];
 505
 506   while (cycles--) {
 507     if (!ckst->ck_irc_err) {
 508       for (i = 0; i < CK_IRC_WORDS; i++)
 509         ckst->ck_irc_read[i] = CK_IRC_START[i];
 510       for (i = 0; i < CK_IRC_WORDS; i++)
 511         if (ckst->ck_irc_read[i] != ckst->ck_irc_base[i]) {
 512           ckst->ck_irc_err++;
 513           printf("irc+%x %08"PRIx32" != %08"PRIx32"\n",
 514                  i, ckst->ck_irc_read[i], ckst->ck_irc_base[i]);
 515         }
 516     }
 517
 518     if (!ckst->ck_tx_err) {
 519       for (i = 0; i < CK_TX_WORDS; i++)
 520         ckst->ck_tx_read[i] = CK_TX_START[i];
 521       for (i = 0; i < CK_TX_WORDS; i++)
 522         if (ckst->ck_tx_read[i] != ckst->ck_tx_base[i]) {
 523           ckst->ck_tx_err++;
 524           printf("tx+%x %08"PRIx32" != %08"PRIx32"\n",
 525                  i, ckst->ck_tx_read[i], ckst->ck_tx_base[i]);
 526         }
 527     }
 528
 529     if (!ckst->ck_rx_err) {
 530       for (i = 0; i < CK_RX_WORDS; i++)
 531         ckst->ck_rx_read[i] = CK_RX_START[i];
 532       for (i = 0; i < CK_RX_WORDS; i++)
 533         if (ckst->ck_rx_read[i] != ckst->ck_rx_base[i]) {
 534           ckst->ck_rx_err++;
 535           printf("rx+%x %08"PRIx32" != %08"PRIx32"\n",
 536                  i, ckst->ck_rx_read[i], ckst->ck_rx_base[i]);
 537         }
 538     }
 539   }
 540
 541   return 0;
 542 }
 543
 544 int cmd_do_testcuradc(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 545 {
 546   char *ps = param[1];
 547   long pwm_chan_a;
 548   long pwm_chan_b;
 549   long pwm_b = 0;
 550   pxmc_state_t *mcs;
 551   volatile pxmcc_data_t *mcc_data = pxmc_rocon_mcc_data();
 552   int i;
 553   long cur_a;
 554   long cur_b;
 555   long pwm_cycle = mcc_data->common.pwm_cycle;
 556
 557   si_skspace(&ps);
 558   if (si_long(&ps, &pwm_chan_a, 0) < 0)
 559       return -CMDERR_BADPAR;
 560
 561   si_skspace(&ps);
 562   if (si_ulong(&ps, &pwm_chan_b, 0) < 0)
 563         return -CMDERR_BADPAR;
 564
 565   if (pwm_chan_a >= PXMCC_CURADC_CHANNELS)
 566     return -CMDERR_BADPAR;
 567
 568   if (pwm_chan_b >= PXMCC_CURADC_CHANNELS)
 569     return -CMDERR_BADPAR;
 570
 571   si_skspace(&ps);
 572   if (*ps) {
 573     if (si_ulong(&ps, &pwm_b, 0) < 0)
 574           return -CMDERR_BADPAR;
 575     pxmc_for_each_mcs(i, mcs) {
 576       /* PXMS_ENI_m - check if input (IRC) update is enabled */
 577       if (mcs->pxms_flg & (PXMS_ENR_m | PXMS_ENO_m)) {
 578         pxmc_axis_release(mcs);
 579       }
 580     }
 581
 582     for (i = 0; i < 16; i++) {
 583       if (i == pwm_chan_a) {
 584         if (pxmc_rocon_pwm_direct_wr(i, 0, 1) < 0)
 585           return -CMDERR_EIO;
 586       } else if (i == pwm_chan_b) {
 587         if (pxmc_rocon_pwm_direct_wr(i, pwm_b, 1) < 0)
 588           return -CMDERR_EIO;
 589       } else {
 590         pxmc_rocon_pwm_direct_wr(i, 0, 0);
 591       }
 592     }
 593   }
 594
 595   cur_a = mcc_data->curadc[pwm_chan_a].cur_val;
 596   cur_b = mcc_data->curadc[pwm_chan_b].cur_val;
 597   if (pwm_b < pwm_cycle)
 598     cur_b = (pwm_cycle * cur_b + pwm_cycle / 2) / (pwm_cycle - pwm_b);
 599
 600   printf("ch %2ld pwm %5ld cur %7ld\n", pwm_chan_a, 0l, cur_a);
 601   printf("ch %2ld pwm %5ld cur %7ld\n", pwm_chan_b, pwm_b, cur_b);
 602
 603   return 0;
 604 }
 605
 606 int cmd_do_curadc(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 607 {
 608   int chan;
 609   volatile pxmcc_data_t *mcc_data = pxmc_rocon_mcc_data();
 610   volatile pxmcc_curadc_data_t *curadc;
 611   int subcmd = (int)des->info[0];
 612
 613   for (chan = 0; chan < PXMCC_CURADC_CHANNELS; chan++) {
 614     curadc = mcc_data->curadc + chan;
 615     switch (subcmd) {
 616       case 0:
 617         printf("%s%ld", chan?",":"", (long)curadc->cur_val);
 618         break;
 619       case 1:
 620         printf("%s%ld", chan?",":"", (long)curadc->siroladc_offs);
 621         break;
 622       case 2:
 623         curadc->siroladc_offs += curadc->cur_val;
 624         break;
 625     }
 626   }
 627
 628   if (subcmd < 2)
 629     printf("\n");
 630
 631   return 0;
 632 }
 633
 634 cmd_des_t const cmd_des_test_memusage = {0, 0,
 635                 "memusage", "report memory usage", cmd_do_test_memusage,
 636 {
 637   0,
 638   0
 639 }
 640                                         };
 641
 642 cmd_des_t const cmd_des_test_adc = {0, 0,
 643                                     "testadc", "adc test", cmd_do_test_adc,
 644 {
 645   0,
 646   0
 647 }
 648                                    };
 649
 650 #ifdef APPL_WITH_DISTORE_EEPROM_USER
 651 cmd_des_t const cmd_des_test_distore = {0, 0,
 652                                         "testdistore", "test DINFO store", cmd_do_test_distore,
 653 {
 654   0,
 655   0
 656 }
 657                                        };
 658
 659 cmd_des_t const cmd_des_test_diload = {0, 0,
 660                                        "testdiload", "test DINFO load", cmd_do_test_diload,
 661 {
 662   0,
 663   0
 664 }
 665                                       };
 666 #endif /*APPL_WITH_DISTORE_EEPROM_USER*/
 667
 668 cmd_des_t const cmd_des_test_loglevel = {0, 0,
 669                 "loglevel", "select logging level",
 670                 cmd_do_test_loglevel, {}
 671                                         };
 672
 673 cmd_des_t const cmd_des_spimst = {0, CDESM_OPCHR | CDESM_WR,
 674                                   "SPIMST", "SPI master communication request",
 675                                   cmd_do_spimst_blocking, {(void *)0}
 676                                  };
 677
 678 cmd_des_t const cmd_des_spimstx = {0, CDESM_OPCHR | CDESM_WR,
 679                                    "SPIMST#", "SPI# master communication request",
 680                                    cmd_do_spimst_blocking, {(void *) - 1}
 681                                   };
 682
 683 cmd_des_t const cmd_des_mtdspitest = {0, 0,
 684                                    "mtdspitest", "test SPI connected Flash",
 685                                    cmd_do_mtdspitest, {(void *) - 1}
 686                                   };
 687
 688 #ifdef SDRAM_BASE
 689 cmd_des_t const cmd_des_testsdram = {0, 0,
 690                                      "testsdram", "test SDRAM",
 691                                      cmd_do_testsdram, {(void *)0}
 692                                     };
 693 #endif /*SDRAM_BASE*/
 694
 695
 696 cmd_des_t const cmd_des_testlxpwrrx = {0, 0,
 697                                      "testlxpwrrx", "capture data stream from lxpwr",
 698                                      cmd_do_testlxpwrrx, {(void *)0}
 699                                     };
 700
 701 cmd_des_t const cmd_des_testlxpwrstat = {0, 0,
 702                                      "testlxpwrstat", "lxpwr interrupt statistic",
 703                                      cmd_do_testlxpwrstat, {(void *)0}
 704                                     };
 705
 706 cmd_des_t const cmd_des_testfncapprox = {0, 0,
 707                                      "testfncapprox", "test of function approximator",
 708                                      cmd_do_testfncapprox, {(void *)0}
 709                                     };
 710
 711 cmd_des_t const cmd_des_testtumblefw = {0, 0,
 712                                      "testtumblefw", "test Tumble coprocesor firmware",
 713                                      cmd_do_testtumblefw, {(void *)0}
 714                                     };
 715
 716 cmd_des_t const cmd_des_testtumblebus = {0, 0,
 717                                      "testtumblebus", "test Tumble coprocesor bus",
 718                                      cmd_do_testtumblebus, {(void *)0}
 719                                     };
 720
 721 cmd_des_t const cmd_des_testcuradc = {0, 0,
 722                                      "testcuradc", "test current adc channel calibration",
 723                                      cmd_do_testcuradc, {(void *)0}
 724                                     };
 725
 726 cmd_des_t const cmd_des_showcuradc = {0, 0,
 727                                      "showcuradc", "print current ADC offsets",
 728                                      cmd_do_curadc, {(void *)0}
 729                                     };
 730
 731 cmd_des_t const cmd_des_showcuradcoffs = {0, 0,
 732                                      "showcuradcoffs", "print current ADC offsets",
 733                                      cmd_do_curadc, {(void *)1}
 734                                     };
 735
 736 cmd_des_t const cmd_des_calcuradcoffs = {0, 0,
 737                                      "calcuradcoffs", "calibrate current ADC offsets",
 738                                      cmd_do_curadc, {(void *)2}
 739                                     };
 740
 741 cmd_des_t const *const cmd_appl_tests[] =
 742 {
 743   &cmd_des_test_memusage,
 744   &cmd_des_test_adc,
 745 #ifdef APPL_WITH_DISTORE_EEPROM_USER
 746   &cmd_des_test_distore,
 747   &cmd_des_test_diload,
 748 #endif /*APPL_WITH_DISTORE_EEPROM_USER*/
 749   &cmd_des_test_loglevel,
 750   &cmd_des_spimst,
 751   &cmd_des_spimstx,
 752   &cmd_des_mtdspitest,
 753 #ifdef SDRAM_BASE
 754   &cmd_des_testsdram,
 755 #endif /*SDRAM_BASE*/
 756   &cmd_des_testlxpwrrx,
 757   &cmd_des_testlxpwrstat,
 758   &cmd_des_testfncapprox,
 759   &cmd_des_testtumblefw,
 760   &cmd_des_testtumblebus,
 761   &cmd_des_testcuradc,
 762   &cmd_des_showcuradc,
 763   &cmd_des_showcuradcoffs,
 764   &cmd_des_calcuradcoffs,
 765   NULL
 766 };