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 #ifdef SDRAM_BASE
 175 int sdram_access_test(void)
 176 {
 177   unsigned int *ptr;
 178   unsigned int pattern;
 179   size_t ramsz = SDRAM_SIZE;
 180   size_t cnt;
 181   lt_mstime_t tic;
 182   size_t blksz, i;
 183
 184   lt_mstime_update();
 185   tic = actual_msec;
 186
 187   pattern = 0x12abcdef;
 188
 189   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 190   {
 191     *(ptr++) = pattern;
 192     pattern = pattern + 0x87654321;
 193   }
 194
 195   lt_mstime_update();
 196   printf("SDRAM write %d ms\n", (int)(lt_msdiff_t)(actual_msec - tic));
 197
 198   lt_mstime_update();
 199   tic = actual_msec;
 200
 201   pattern = 0x12abcdef;
 202
 203   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 204   {
 205     if (*ptr != pattern)
 206     {
 207       printf("SDRAM error modify at %p (%08x)\n", ptr, *ptr ^ pattern);
 208       return -1;
 209     }
 210
 211     *(ptr++) = ~pattern;
 212     pattern = pattern + 0x87654321;
 213   }
 214
 215   lt_mstime_update();
 216   printf("SDRAM modify %d ms\n", (int)(lt_msdiff_t)(actual_msec - tic));
 217
 218   lt_mstime_update();
 219   tic = actual_msec;
 220
 221   pattern = 0x12abcdef;
 222
 223   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 224   {
 225     if (*(ptr++) != ~pattern)
 226     {
 227       printf("SDRAM error read at %p (%08x)\n", ptr, *ptr ^ pattern);
 228       return -1;
 229     }
 230
 231     pattern = pattern + 0x87654321;
 232   }
 233
 234   lt_mstime_update();
 235   printf("SDRAM read %d ms\n", (int)(lt_msdiff_t)(actual_msec - tic));
 236
 237   lt_mstime_update();
 238   tic = actual_msec;
 239
 240   pattern = 0;
 241
 242   for (cnt = ramsz / sizeof(*ptr), ptr = (typeof(ptr))SDRAM_BASE; cnt--;)
 243   {
 244     pattern += *(ptr++);
 245   }
 246
 247   lt_mstime_update();
 248   printf("SDRAM sum %d ms res 0x%08x\n", (int)(lt_msdiff_t)(actual_msec - tic), pattern);
 249
 250   for (blksz = 1; blksz < 256 ; blksz *= 2)
 251   {
 252     lt_mstime_update();
 253     tic = actual_msec;
 254
 255     pattern = 0;
 256
 257     for (cnt = ramsz / sizeof(*ptr); cnt; cnt -= blksz)
 258     {
 259       ptr = (typeof(ptr))SDRAM_BASE;
 260
 261       //ptr = (typeof(ptr))cmd_do_test_memusage;
 262       //ptr = (typeof(ptr))&ptr;
 263       for (i = blksz; i--;)
 264         pattern += *(ptr++);
 265     }
 266
 267     lt_mstime_update();
 268     printf("SDRAM sum %d blksz %d ms res 0x%08x\n", (int)(lt_msdiff_t)(actual_msec - tic), (int)blksz, pattern);
 269   }
 270
 271   return 0;
 272 }
 273
 274 int cmd_do_testsdram(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 275 {
 276   sdram_access_test();
 277   return 0;
 278 }
 279 #endif /*SDRAM_BASE*/
 280
 281 int cmd_do_testlxpwrrx(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 282 {
 283   char *ps = param[1];
 284   long mode = 0;
 285   uint32_t *ptr;
 286
 287   if (ps != NULL) {
 288     si_skspace(&ps);
 289     if (*ps) {
 290       if (si_ulong(&ps, &mode, 0) < 0)
 291         return -CMDERR_BADPAR;
 292     }
 293   }
 294   pxmc_rocon_rx_data_hist_buff = NULL;
 295   pxmc_rocon_rx_data_hist_mode = mode;
 296
 297  #ifndef PXMC_ROCON_TIMED_BY_RX_DONE
 298   pxmc_rocon_rx_done_isr_setup(pxmc_rocon_rx_done_isr);
 299  #endif /*PXMC_ROCON_TIMED_BY_RX_DONE*/
 300   pxmc_rocon_rx_data_hist_buff_end = (void *)(FPGA_CONFIGURATION_FILE_ADDRESS +
 301                                          0x80000);
 302   ptr = (void *)FPGA_CONFIGURATION_FILE_ADDRESS;
 303   if (mode != 0) {
 304     *(ptr++) = '10XL';
 305     *(ptr++) = mode;
 306   }
 307   pxmc_rocon_rx_data_hist_buff = (void *)ptr;
 308   return 0;
 309 }
 310
 311 int cmd_do_testlxpwrstat(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 312 {
 313   printf("lxpwrrx period %ld latency %ld max %ld\n",
 314          (long)pxmc_rocon_rx_cycle_time, (long)pxmc_rocon_rx_irq_latency,
 315          (long)pxmc_rocon_rx_irq_latency_max);
 316   return 0;
 317 }
 318
 319 #include <math.h>
 320
 321 int cmd_do_testfncapprox(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 322 {
 323   char *ps = param[1];
 324   unsigned long fnc;
 325   unsigned long val;
 326   unsigned long res;
 327   long diff;
 328   long diff_max = 0;
 329   unsigned int  xb;
 330   uint32_t x;
 331   uint32_t xl;
 332   double   xf;
 333   int64_t  yl;
 334   long count = 1;
 335   long step = 1 << (30-7-18+1  +4);
 336
 337   si_skspace(&ps);
 338   if (si_ulong(&ps, &fnc, 0) < 0)
 339       return -CMDERR_BADPAR;
 340
 341   si_skspace(&ps);
 342   if (!strcmp(ps, "all")) {
 343     val = 0;
 344     count = 0x80000000UL / step;
 345     if (fnc == 1) {
 346       val = 1;
 347     }
 348   } else {
 349     if (si_ulong(&ps, &val, 0) < 0)
 350         return -CMDERR_BADPAR;
 351   }
 352
 353   for (; count--;  val += step) {
 354
 355     if (fnc == 1) {
 356       x = val;
 357       xb = __builtin_clz(x);
 358       xl = x << xb;
 359     } else {
 360       xl = val;
 361     }
 362
 363     fpga_fncapprox_base[fnc] = xl;
 364
 365     /* dummy read to provide time to function aproximator to proceed computation */
 366     res = fpga_fncapprox_base[fnc];
 367     res = fpga_fncapprox_base[fnc];
 368
 369     switch (fnc) {
 370       case 0:
 371         yl = xl;
 372       case 1:
 373         yl = (1LL << 62) / xl;
 374         break;
 375       case 2:
 376         xf = (double)xl * M_PI / 2.0 / (1UL << 30);
 377         yl = round(sin(xf) * (1UL << 16));
 378         break;
 379       case 3:
 380         xf = (double)xl * M_PI / 2.0 / (1UL << 30);
 381         yl = round(cos(xf) * (1UL << 16));
 382         break;
 383       default:
 384       yl = 0;
 385     }
 386
 387     diff = yl - res;
 388
 389     if ((diff > 0) && (diff > diff_max))
 390       diff_max = diff;
 391     else if ((diff < 0) && (-diff > diff_max))
 392       diff_max = -diff;
 393
 394   }
 395
 396   val -= step;
 397
 398   printf("fnc=%ld val=0x%08lx res=0x%08lx ref=0x%08lx diff=%ld max %ld\n",
 399          fnc, val, res, (unsigned long)yl, diff, diff_max);
 400
 401   return 0;
 402 }
 403
 404 int cmd_do_testtumblefw(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 405 {
 406   char *ps = param[1];
 407   long pwm_d;
 408   long pwm_q;
 409   pxmc_state_t *mcs = pxmc_main_list.pxml_arr[0];
 410   volatile pxmcc_data_t *mcc_data = pxmc_rocon_mcc_data();
 411
 412   pxmcc_axis_enable(mcs, 0);
 413
 414   si_skspace(&ps);
 415   if (si_long(&ps, &pwm_d, 0) < 0)
 416       return -CMDERR_BADPAR;
 417
 418   si_skspace(&ps);
 419   if (si_ulong(&ps, &pwm_q, 0) < 0)
 420         return -CMDERR_BADPAR;
 421
 422
 423   if (0) {
 424     pxmcc_axis_setup(mcs, PXMCC_MODE_BLDC);
 425   }
 426   pxmc_clear_flags(mcs,PXMS_ENO_m|PXMS_ENG_m|PXMS_ENR_m|PXMS_BSY_m);
 427   pxmcc_axis_pwm_dq_out(mcs, pwm_d, pwm_q);
 428   pxmcc_axis_enable(mcs, 1);
 429
 430   if (0) {
 431     mcc_data->axis[1].inp_info = 0;
 432     mcc_data->axis[1].out_info = 3;
 433     mcc_data->axis[1].pwmtx_info = (12 << 0) | (13 << 8) | (14 << 16);
 434     mcc_data->axis[1].mode = PXMCC_MODE_BLDC;
 435     mcc_data->axis[1].ccflg = 1;
 436     mcc_data->axis[2].inp_info = 0;
 437     mcc_data->axis[2].out_info = 6;
 438     mcc_data->axis[2].pwmtx_info = (15 << 0) | (16 << 8) | (18 << 16);
 439     mcc_data->axis[2].mode = PXMCC_MODE_BLDC;
 440     mcc_data->axis[2].ccflg = 1;
 441     mcc_data->axis[3].inp_info = 0;
 442     mcc_data->axis[3].out_info = 9;
 443     mcc_data->axis[3].pwmtx_info = (19 << 0) | (20 << 8) | (21 << 16);
 444     mcc_data->axis[3].mode = PXMCC_MODE_BLDC;
 445     mcc_data->axis[3].ccflg = 1;
 446   }
 447
 448   printf("spd %ld act_idle %"PRIu32" min_idle %"PRIu32" avail %lu pwm_cycle %"PRIu32"\n",
 449          mcs->pxms_as, mcc_data->common.act_idle, mcc_data->common.min_idle,
 450          (mcc_data->common.pwm_cycle + 6) / 6, mcc_data->common.pwm_cycle);
 451   mcc_data->common.min_idle = 0x7fff;
 452
 453   return 0;
 454 }
 455
 456 #define CK_IRC_WORDS 16
 457 #define CK_TX_WORDS  16
 458 #define CK_RX_WORDS  16
 459
 460 #define CK_IRC_START ((uint32_t*)fpga_irc[0])
 461 #define CK_TX_START  (fpga_lx_master_transmitter_base+9)
 462 #define CK_RX_START  (fpga_lx_master_receiver_base+44)
 463
 464 typedef struct ck_state_t {
 465   uint32_t ck_irc_base[CK_IRC_WORDS];
 466   uint32_t ck_irc_read[CK_IRC_WORDS];
 467   uint32_t ck_tx_base[CK_TX_WORDS];
 468   uint32_t ck_tx_read[CK_TX_WORDS];
 469   uint32_t ck_rx_base[CK_RX_WORDS];
 470   uint32_t ck_rx_read[CK_RX_WORDS];
 471
 472   uint32_t ck_irc_err;
 473   uint32_t ck_tx_err;
 474   uint32_t ck_rx_err;
 475 } ck_state_t;
 476
 477 int cmd_do_testtumblebus(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 478 {
 479   int i;
 480   int cycles = 10000;
 481   static ck_state_t *ckst = NULL;
 482   if (ckst == NULL)
 483     ckst = malloc(sizeof(*ckst));
 484   if (ckst == NULL)
 485     return 1;
 486
 487   ckst->ck_irc_err = 0;
 488   ckst->ck_tx_err = 0;
 489   ckst->ck_rx_err = 0;
 490
 491   for (i = 0; i < CK_IRC_WORDS; i++)
 492     ckst->ck_irc_base[i] = CK_IRC_START[i];
 493
 494   for (i = 0; i < CK_TX_WORDS; i++)
 495     ckst->ck_tx_base[i] = CK_TX_START[i];
 496
 497   for (i = 0; i < CK_RX_WORDS; i++)
 498     ckst->ck_rx_base[i] = CK_RX_START[i];
 499
 500   while (cycles--) {
 501     if (!ckst->ck_irc_err) {
 502       for (i = 0; i < CK_IRC_WORDS; i++)
 503         ckst->ck_irc_read[i] = CK_IRC_START[i];
 504       for (i = 0; i < CK_IRC_WORDS; i++)
 505         if (ckst->ck_irc_read[i] != ckst->ck_irc_base[i]) {
 506           ckst->ck_irc_err++;
 507           printf("irc+%x %08"PRIx32" != %08"PRIx32"\n",
 508                  i, ckst->ck_irc_read[i], ckst->ck_irc_base[i]);
 509         }
 510     }
 511
 512     if (!ckst->ck_tx_err) {
 513       for (i = 0; i < CK_TX_WORDS; i++)
 514         ckst->ck_tx_read[i] = CK_TX_START[i];
 515       for (i = 0; i < CK_TX_WORDS; i++)
 516         if (ckst->ck_tx_read[i] != ckst->ck_tx_base[i]) {
 517           ckst->ck_tx_err++;
 518           printf("tx+%x %08"PRIx32" != %08"PRIx32"\n",
 519                  i, ckst->ck_tx_read[i], ckst->ck_tx_base[i]);
 520         }
 521     }
 522
 523     if (!ckst->ck_rx_err) {
 524       for (i = 0; i < CK_RX_WORDS; i++)
 525         ckst->ck_rx_read[i] = CK_RX_START[i];
 526       for (i = 0; i < CK_RX_WORDS; i++)
 527         if (ckst->ck_rx_read[i] != ckst->ck_rx_base[i]) {
 528           ckst->ck_rx_err++;
 529           printf("rx+%x %08"PRIx32" != %08"PRIx32"\n",
 530                  i, ckst->ck_rx_read[i], ckst->ck_rx_base[i]);
 531         }
 532     }
 533   }
 534
 535   return 0;
 536 }
 537
 538 int cmd_do_testcuradc(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
 539 {
 540   char *ps = param[1];
 541   long pwm_chan_a;
 542   long pwm_chan_b;
 543   long pwm_b = 0;
 544   pxmc_state_t *mcs;
 545   volatile pxmcc_data_t *mcc_data = pxmc_rocon_mcc_data();
 546   int i;
 547   long cur_a;
 548   long cur_b;
 549   long pwm_cycle = mcc_data->common.pwm_cycle;
 550
 551   si_skspace(&ps);
 552   if (si_long(&ps, &pwm_chan_a, 0) < 0)
 553       return -CMDERR_BADPAR;
 554
 555   si_skspace(&ps);
 556   if (si_ulong(&ps, &pwm_chan_b, 0) < 0)
 557         return -CMDERR_BADPAR;
 558
 559   si_skspace(&ps);
 560   if (*ps) {
 561     if (si_ulong(&ps, &pwm_b, 0) < 0)
 562           return -CMDERR_BADPAR;
 563     pxmc_for_each_mcs(i, mcs) {
 564       /* PXMS_ENI_m - check if input (IRC) update is enabled */
 565       if (mcs->pxms_flg & (PXMS_ENR_m | PXMS_ENO_m)) {
 566         pxmc_set_const_out(mcs,0);
 567         pxmc_clear_flag(mcs, PXMS_ENO_b);
 568       }
 569     }
 570
 571     for (i = 0; i < 16; i++) {
 572       if (i == pwm_chan_a) {
 573         if (pxmc_rocon_pwm_direct_wr(i, 0, 1) < 0)
 574           return -CMDERR_EIO;
 575       } else if (i == pwm_chan_b) {
 576         if (pxmc_rocon_pwm_direct_wr(i, pwm_b, 1) < 0)
 577           return -CMDERR_EIO;
 578       } else {
 579         pxmc_rocon_pwm_direct_wr(i, 0, 0);
 580       }
 581     }
 582   }
 583
 584   cur_a = mcc_data->curadc[pwm_chan_a].cur_val;
 585   cur_b = mcc_data->curadc[pwm_chan_b].cur_val;
 586   if (pwm_b < pwm_cycle)
 587     cur_b = (pwm_cycle * cur_b + pwm_cycle / 2) / (pwm_cycle - pwm_b);
 588
 589   printf("ch %2ld pwm %5ld cur %7ld\n", pwm_chan_a, 0l, cur_a);
 590   printf("ch %2ld pwm %5ld cur %7ld\n", pwm_chan_b, pwm_b, cur_b);
 591
 592   return 0;
 593 }
 594
 595 cmd_des_t const cmd_des_test_memusage = {0, 0,
 596                 "memusage", "report memory usage", cmd_do_test_memusage,
 597 {
 598   0,
 599   0
 600 }
 601                                         };
 602
 603 cmd_des_t const cmd_des_test_adc = {0, 0,
 604                                     "testadc", "adc test", cmd_do_test_adc,
 605 {
 606   0,
 607   0
 608 }
 609                                    };
 610
 611 #ifdef APPL_WITH_DISTORE_EEPROM_USER
 612 cmd_des_t const cmd_des_test_distore = {0, 0,
 613                                         "testdistore", "test DINFO store", cmd_do_test_distore,
 614 {
 615   0,
 616   0
 617 }
 618                                        };
 619
 620 cmd_des_t const cmd_des_test_diload = {0, 0,
 621                                        "testdiload", "test DINFO load", cmd_do_test_diload,
 622 {
 623   0,
 624   0
 625 }
 626                                       };
 627 #endif /*APPL_WITH_DISTORE_EEPROM_USER*/
 628
 629 cmd_des_t const cmd_des_test_loglevel = {0, 0,
 630                 "loglevel", "select logging level",
 631                 cmd_do_test_loglevel, {}
 632                                         };
 633
 634 cmd_des_t const cmd_des_spimst = {0, CDESM_OPCHR | CDESM_WR,
 635                                   "SPIMST", "SPI master communication request",
 636                                   cmd_do_spimst_blocking, {(void *)0}
 637                                  };
 638
 639 cmd_des_t const cmd_des_spimstx = {0, CDESM_OPCHR | CDESM_WR,
 640                                    "SPIMST#", "SPI# master communication request",
 641                                    cmd_do_spimst_blocking, {(void *) - 1}
 642                                   };
 643
 644 #ifdef SDRAM_BASE
 645 cmd_des_t const cmd_des_testsdram = {0, 0,
 646                                      "testsdram", "test SDRAM",
 647                                      cmd_do_testsdram, {(void *)0}
 648                                     };
 649 #endif /*SDRAM_BASE*/
 650
 651
 652 cmd_des_t const cmd_des_testlxpwrrx = {0, 0,
 653                                      "testlxpwrrx", "capture data stream from lxpwr",
 654                                      cmd_do_testlxpwrrx, {(void *)0}
 655                                     };
 656
 657 cmd_des_t const cmd_des_testlxpwrstat = {0, 0,
 658                                      "testlxpwrstat", "lxpwr interrupt statistic",
 659                                      cmd_do_testlxpwrstat, {(void *)0}
 660                                     };
 661
 662 cmd_des_t const cmd_des_testfncapprox = {0, 0,
 663                                      "testfncapprox", "test of function approximator",
 664                                      cmd_do_testfncapprox, {(void *)0}
 665                                     };
 666
 667 cmd_des_t const cmd_des_testtumblefw = {0, 0,
 668                                      "testtumblefw", "test Tumble coprocesor firmware",
 669                                      cmd_do_testtumblefw, {(void *)0}
 670                                     };
 671
 672 cmd_des_t const cmd_des_testtumblebus = {0, 0,
 673                                      "testtumblebus", "test Tumble coprocesor bus",
 674                                      cmd_do_testtumblebus, {(void *)0}
 675                                     };
 676
 677 cmd_des_t const cmd_des_testcuradc = {0, 0,
 678                                      "testcuradc", "test current adc channel calibration",
 679                                      cmd_do_testcuradc, {(void *)0}
 680                                     };
 681
 682 cmd_des_t const *const cmd_appl_tests[] =
 683 {
 684   &cmd_des_test_memusage,
 685   &cmd_des_test_adc,
 686 #ifdef APPL_WITH_DISTORE_EEPROM_USER
 687   &cmd_des_test_distore,
 688   &cmd_des_test_diload,
 689 #endif /*APPL_WITH_DISTORE_EEPROM_USER*/
 690   &cmd_des_test_loglevel,
 691   &cmd_des_spimst,
 692   &cmd_des_spimstx,
 693 #ifdef SDRAM_BASE
 694   &cmd_des_testsdram,
 695 #endif /*SDRAM_BASE*/
 696   &cmd_des_testlxpwrrx,
 697   &cmd_des_testlxpwrstat,
 698   &cmd_des_testfncapprox,
 699   &cmd_des_testtumblefw,
 700   &cmd_des_testtumblebus,
 701   &cmd_des_testcuradc,
 702   NULL
 703 };