target_firmware/magpie_fw_dev/target/cmnos/dbg_api.c

   1 /*
   2  * Copyright (c) 2013 Qualcomm Atheros, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted (subject to the limitations in the
   7  * disclaimer below) provided that the following conditions are met:
   8  *
   9  *  * Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  *  * Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  *  * Neither the name of Qualcomm Atheros nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
  22  * GRANTED BY THIS LICENSE.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
  23  * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
  24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  31  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  32  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  33  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35 #include "sys_cfg.h"
  36 #include "athos_api.h"
  37
  38 #if defined(PROJECT_K2)
  39 #if SYSTEM_MODULE_SFLASH
  40 #include "sflash_api.h"
  41 #endif
  42 #endif /* #if defined(PROJECT_K2) */
  43
  44 #if defined(SYSTEM_MODULE_DBG)
  45
  46 /* Function prototypes */
  47 int db_help_cmd(char *, char*, char*, char*);
  48 int db_ldr_cmd(char*, char*, char*, char*);
  49 int db_str_cmd(char*, char*, char*, char*);
  50 int db_info_cmd(char*, char*, char*, char*);
  51 int db_usb_cmd(char*, char*, char*, char*);
  52 int db_intr_cmd(char*, char*, char*, char*);
  53
  54 int db_cmd_starthtc(char* cmd, char* param1, char* param2, char* param3);
  55
  56 int db_wdt_cmd(char* cmd, char* param1, char* param2, char* param3);
  57
  58 #if defined(PROJECT_K2)
  59 #if SYSTEM_MODULE_SFLASH
  60 int db_cmd_sferase(char* cmd, char* param1, char* param2, char* param3);
  61 int db_cmd_sfpg(char* cmd, char* param1, char* param2, char* param3);
  62 int db_cmd_sfru(char* cmd, char* param1, char* param2, char* param3);
  63 int db_cmd_sfrm(char* cmd, char* param1, char* param2, char* param3);
  64 int db_cmd_sfrdsr(char* cmd, char* param1, char* param2, char* param3);
  65 #endif
  66 #endif /* #if defined(PROJECT_K2) */
  67 int db_cmd_memcmp(char* cmd, char* param1, char* param2, char* param3);
  68 int db_cmd_memdump(char* cmd, char* param1, char* param2, char* param3);
  69
  70 int db_clock_cmd(char* cmd, char* param1, char* param2, char* param3);
  71
  72 uint16_t db_get_cmd_line(uint8_t ch, char *cmd_line, uint16_t* i);
  73 int db_formalize_command(char*, char*);
  74 int db_ascii_to_hex(char*, unsigned long*);
  75 int db_hex_to_ascii(unsigned long, char*);
  76 void zfDebugTask(void);
  77
  78 int db_info_intr(char* cmd, char* param1, char* param2, char* param3);
  79
  80 extern u32_t this_is_global_variables;
  81
  82 /* Console debug command table */
  83 const struct DB_COMMAND_STRUCT command_table[] =
  84 {
  85         {"HELP",   ", List all debug commands", db_help_cmd},
  86         {"?",      ", Equal to HELP comamnd", db_help_cmd},
  87
  88         /* Basic load/store/dump command */
  89         {"LDR",    "<Hex addr>, Load word", db_ldr_cmd},
  90         {"LDRH",   "<Hex addr>, Load half word", db_ldr_cmd},
  91         {"LDRB",   "<Hex addr>, Load byte", db_ldr_cmd},
  92         {"STR",    "<Hex addr> <Hex value>, Store word", db_str_cmd},
  93         {"STRH",   "<Hex addr> <Hex value>, Store half word", db_str_cmd},
  94         {"STRB",   "<Hex addr> <Hex value>, Store byte", db_str_cmd},
  95         {"INFO",   ", Print debug information", db_info_cmd},
  96         {"USB",   ", usb releated command", db_usb_cmd},
  97         {"INTR",   ", intr releated command", db_intr_cmd},
  98         {"CLOCK",    ", change the clock...", db_clock_cmd},
  99         {"HTCR", "Issue HTC ready to host", db_cmd_starthtc},
 100         {"WDT",   ", wdt debug command", db_wdt_cmd},
 101 #if defined(PROJECT_K2)
 102 #if SYSTEM_MODULE_SFLASH
 103         {"SFE", ", S<Hex>/B<Hex>/C, SPI Flash chip erase", db_cmd_sferase},
 104         {"SFPG", "<Hex addr> <Hex len> <Hex buf>, SPI Flash program", db_cmd_sfpg},
 105         {"SFRU", "f/r <Hex addr> <Hex addr>, SPI Flash fast read/read to UART", db_cmd_sfru},
 106         {"SFRM", "f/r <Hex addr> <Hex addr>, SPI Flash fast read/read to Memory 0x520000", db_cmd_sfrm},
 107         {"SFRDSR", ", SPI Flash status register read", db_cmd_sfrdsr},
 108 #endif
 109 #endif /* #if defined(PROJECT_K2) */
 110         {"MEMCMP", "<Hex addr> <Hex addr> <Hex len>, memory comparison", db_cmd_memcmp},
 111         {"MEMDMP", "<Hex addr> <Hex addr>, memory dump", db_cmd_memdump},
 112         {"", "", 0}
 113         /* {Command, Help description, function} */
 114 };
 115
 116 char cmd_buffer[COMMAND_BUFFER_SIZE][DB_MAX_COMMAND_LENGTH]; /* Backup previous command */
 117 int cmd_buf_ptr;
 118 int cmd_buf_full;
 119 char raw_cmd[DB_MAX_COMMAND_LENGTH];
 120 char cmd_str[DB_MAX_COMMAND_LENGTH*4];
 121 int cmd_not_found;
 122 uint16_t gvLen;
 123 int pressed_time;
 124
 125 //////////////////////////////////////////////////
 126 #define MAX_REG_NUM 16
 127
 128 typedef struct reg_elem {
 129         unsigned char valid;
 130         unsigned char mode;     // byte, half-word word
 131         unsigned long reg_addr;
 132 } t_reg_elem;
 133
 134 t_reg_elem reg_buffer[MAX_REG_NUM];
 135
 136 //////////////////////////////////////////////////
 137
 138 void zfDebugInit(void)
 139 {
 140         uint8_t ch;
 141
 142         /* Purge Rx FIFO */
 143         while ((zm_get_char(&ch)) != 0)
 144         {
 145         }
 146
 147         cmd_buf_ptr = 0;
 148         cmd_buf_full = FALSE;
 149         gvLen = 0;
 150         pressed_time = 0;
 151 }
 152
 153 void zfDebugTask(void)
 154 {
 155         int i;
 156         uint8_t ch;
 157
 158         if ((zm_get_char(&ch)) == 0)
 159         {
 160                 return;
 161         }
 162
 163         if (db_get_cmd_line(ch, raw_cmd, &gvLen) == 0)
 164         {
 165                 return;
 166         }
 167
 168         if (db_formalize_command(raw_cmd, cmd_str))
 169         {
 170                 gvLen = 0;
 171                 i = 0;
 172
 173                 cmd_not_found = TRUE;
 174                 while(command_table[i].cmd_func)
 175                 {
 176                         if (!strcmp(command_table[i].cmd_str, cmd_str))
 177                         {
 178                                 cmd_not_found = FALSE;
 179                                 command_table[i].cmd_func(cmd_str,
 180                                                           cmd_str+DB_MAX_COMMAND_LENGTH,
 181                                                           cmd_str+DB_MAX_COMMAND_LENGTH*2,
 182                                                           cmd_str+DB_MAX_COMMAND_LENGTH*3);
 183                                 break;
 184                         }
 185                         i++;
 186                 }
 187                 if (cmd_not_found)
 188                 {
 189                         A_PRINTF("Error, HELP for command list.\n\r");
 190                 }
 191
 192         }
 193
 194         A_PRINTF(">");
 195         return;
 196 }
 197
 198 uint16_t db_get_cmd_line(uint8_t ch, char *cmd_line, uint16_t* i)
 199 {
 200         int cmd_buf_loc;
 201
 202         switch (ch)
 203         {
 204         case '\\' : /* Last command */
 205                 pressed_time++;
 206                 if (pressed_time >= COMMAND_BUFFER_SIZE)
 207                 {
 208                         pressed_time--;
 209                 }
 210                 cmd_buf_loc = cmd_buf_ptr - pressed_time;
 211                 if (cmd_buf_loc < 0)
 212                 {
 213                         if (cmd_buf_full == TRUE)
 214                         {
 215                                 cmd_buf_loc += COMMAND_BUFFER_SIZE;
 216                         }
 217                         else
 218                         {
 219                                 cmd_buf_loc = 0;
 220                         }
 221                 }
 222
 223                 if (A_STRLEN(cmd_buffer[cmd_buf_loc]) != 0)
 224                 {
 225                         A_STRCPY(cmd_line, cmd_buffer[cmd_buf_loc]);
 226                         *i = A_STRLEN(cmd_buffer[cmd_buf_loc]);
 227                         A_PRINTF("\r>");
 228                         A_PRINTF("%s", cmd_line);
 229                 }
 230                 break;
 231         case 13 : /* Return */
 232                 pressed_time = 0;
 233                 cmd_line[*i] = 0;
 234                 A_PRINTF("\n\r");
 235                 if (*i != 0)
 236                 {
 237                         //Filter duplicated string in command history
 238                         if (strcmp(cmd_buffer[(cmd_buf_ptr==0)?(COMMAND_BUFFER_SIZE-1):(cmd_buf_ptr-1)], cmd_line) != 0)
 239                         {
 240                                 A_STRCPY(cmd_buffer[cmd_buf_ptr++], cmd_line);
 241                         }
 242                 }
 243                 if (cmd_buf_ptr >= COMMAND_BUFFER_SIZE)
 244                 {
 245                         cmd_buf_ptr = 0;
 246                         cmd_buf_full = TRUE;
 247                 }
 248                 return 1;
 249         case '\b' : /* Backspace */
 250                 pressed_time = 0;
 251                 if (*i > 0)
 252                 {
 253                         *i = *i-1;
 254                         A_PRINTF("\b \b");
 255                 }
 256                 break;
 257         case 0 : //None
 258                 break;
 259         default :
 260                 if ((ch >= ' ') && (ch <= '~'))
 261                 {
 262                         pressed_time = 0;
 263                         if (*i < DB_MAX_COMMAND_LENGTH-2)
 264                         {
 265                                 if ((ch >= 0x11) && (ch <= 0x7e))
 266                                 {
 267                                         //if ((buf <= 'z') && (buf >= 'a'))
 268                                         //{
 269                                         //    buf -= 'a' - 'A';
 270                                         //}
 271                                         cmd_line[*i] = ch;
 272                                         *i = *i + 1;
 273                                         A_PRINTF("%c", ch);
 274                                 }
 275                         }
 276                 }
 277                 else
 278                 {
 279                         ch = 7; /* Beep */
 280                         A_PRINTF("%c", ch);
 281                 }
 282                 break;
 283         } /* end of switch */
 284
 285         return 0;
 286
 287 }
 288
 289 int db_formalize_command(char* raw_str,  char* cmd_str)
 290 {
 291         int i = 0;
 292         int j;
 293         int k;
 294
 295
 296         for (k=0; k<4; k++)
 297         {
 298                 /* Remove preceeding spaces */
 299                 while (raw_str[i++] == ' '){}
 300                 i--;
 301
 302                 /* Copy command string */
 303                 j = 0;
 304                 while(raw_str[i] && (raw_str[i] != ' '))
 305                 {
 306                         if (k == 0)
 307                         {
 308                                 if ((raw_str[i] <= 'z') && (raw_str[i] >= 'a'))
 309                                 {
 310                                         raw_str[i] -= 'a' - 'A';
 311                                 }
 312                                 cmd_str[k*DB_MAX_COMMAND_LENGTH + j++] = raw_str[i++];
 313                         }
 314                         else
 315                         {
 316                                 cmd_str[k*DB_MAX_COMMAND_LENGTH + j++] = raw_str[i++];
 317                         }
 318                 }
 319                 cmd_str[k*DB_MAX_COMMAND_LENGTH + j] = 0;
 320         }
 321         return (int)A_STRLEN(cmd_str);
 322 }
 323
 324 int db_ascii_to_hex(char* num_str, unsigned long* hex_num)
 325 {
 326         int i = 0;
 327
 328         *hex_num = 0;
 329         while (num_str[i])
 330         {
 331                 if ((num_str[i] >= '0') && (num_str[i] <= '9'))
 332                 {
 333                         *hex_num <<= 4;
 334                         *hex_num += (num_str[i] - '0');
 335                 }
 336                 else if ((num_str[i] >= 'A') && (num_str[i] <= 'F'))
 337                 {
 338                         *hex_num <<= 4;
 339                         *hex_num += (num_str[i] - 'A' + 10);
 340                 }
 341                 else if ((num_str[i] >= 'a') && (num_str[i] <= 'f'))
 342                 {
 343                         *hex_num <<= 4;
 344                         *hex_num += (num_str[i] - 'a' + 10);
 345                 }
 346                 else
 347                 {
 348                         return -1;
 349                 }
 350                 i++;
 351         }
 352         return 0;
 353 }
 354
 355 int db_ascii_to_int(char* num_str, unsigned long* int_num)
 356 {
 357         int i = 0;
 358
 359         *int_num = 0;
 360         while (num_str[i])
 361         {
 362                 if ((num_str[i] >= '0') && (num_str[i] <= '9'))
 363                 {
 364                         *int_num *= 10;
 365                         *int_num += (num_str[i] - '0');
 366                 }
 367                 else
 368                 {
 369                         return -1;
 370                 }
 371                 i++;
 372         }
 373         return 0;
 374 }
 375
 376 int db_hex_to_ascii(unsigned long hex_num, char* num_str)
 377 {
 378         int i;
 379         unsigned long four_bits;
 380
 381         for (i=7; i>=0; i--)
 382         {
 383                 four_bits = (hex_num >> i*4) & 0xf;
 384                 if (four_bits < 10)
 385                 {
 386                         num_str[7-i] = four_bits + '0';
 387                 }
 388                 else
 389                 {
 390                         num_str[7-i] = four_bits - 10 + 'A';
 391                 }
 392         }
 393         num_str[8] = 0;
 394         return 0;
 395 }
 396
 397 int db_help_cmd(char* cmd, char* param1, char* param2, char* param3)
 398 {
 399         int i;
 400
 401         i = 0;
 402
 403         A_PRINTF("%s %s\n", ATH_DEBUGGER_VERSION_STR, ATH_COMMAND_LIST_STR);
 404
 405         while (command_table[i].cmd_func)
 406         {
 407                 A_PRINTF("%s\t%s\n\r", command_table[i].cmd_str,
 408                                        command_table[i].help_str);
 409                 i++;
 410         }
 411         return i;
 412 }
 413
 414 int db_ldr_cmd(char* cmd, char* param1, char* param2, char* param3)
 415 {
 416         unsigned long val;
 417         unsigned long addr;
 418         char val_str[20];
 419         char addr_str[20];
 420
 421         if (db_ascii_to_hex(param1, &addr) != -1)
 422         {
 423                 if( addr == 0 )
 424                 {
 425                         A_PRINTF("Error! bad address 0x%08x.\n\r",
 426                                  (unsigned long)addr);
 427                         return -1;
 428                 }
 429                 if (strcmp(cmd, "LDR") == 0)
 430                 {
 431                         addr &= 0xfffffffc;
 432                         //val = *(unsigned long *)addr;
 433
 434                         val = HAL_WORD_REG_READ(addr);
 435                 }
 436                 else if (strcmp(cmd, "LDRH") == 0)
 437                 {
 438                         addr &= 0xfffffffe;
 439                         val = HAL_HALF_WORD_REG_READ(addr);
 440                 }
 441                 else if (strcmp(cmd, "LDRB") == 0)
 442                 {
 443                 }
 444
 445                 db_hex_to_ascii(val, val_str);
 446                 db_hex_to_ascii(addr, addr_str);
 447
 448                 A_PRINTF("%s : %s\n\r", addr_str, val_str);
 449                 return 0;
 450         }
 451         else
 452         {
 453                 A_PRINTF("Error! Incorrect format.\n\r");
 454
 455                 return -1;
 456         }
 457 }
 458
 459 int db_str_cmd(char* cmd, char* param1, char* param2, char* param3)
 460 {
 461         unsigned long val;
 462         unsigned long addr;
 463         char val_str[20];
 464         char addr_str[20];
 465
 466         if ((A_STRLEN(param2) > 0) &&
 467             (db_ascii_to_hex(param1, &addr) != -1) &&
 468             (db_ascii_to_hex(param2, &val) != -1))
 469         {
 470                 if (strcmp(cmd, "STR") == 0)
 471                 {
 472                         addr &= 0xfffffffc;
 473                         //HAL_WORD_REG_WRITE(addr, val);
 474                         HAL_WORD_REG_WRITE(addr, val);
 475                         //*(volatile unsigned long *)(addr & 0xfffffffc) = (unsigned long)val;
 476                 }
 477
 478                 else if (strcmp(cmd, "STRH") == 0)
 479                 {
 480                         addr &= 0xfffffffe;
 481                         //*(volatile unsigned short *)(addr & 0xfffffffe) = (unsigned short)val;
 482                         HAL_HALF_WORD_REG_WRITE(addr, val);
 483                 }
 484                 else if (strcmp(cmd, "STRB") == 0)
 485                 {
 486                         if( addr & 0x00f00000 )
 487                                 HAL_BYTE_REG_WRITE(addr, val);
 488                         else
 489                                 HAL_BYTE_REG_WRITE(addr^3, val);
 490                         //*(volatile unsigned char *)addr = (unsigned char)val;
 491                 }
 492
 493                 db_hex_to_ascii(val, val_str);
 494                 db_hex_to_ascii(addr, addr_str);
 495
 496                 A_PRINTF("%s : %s\n\r", addr_str, val_str);
 497                 return 0;
 498         }
 499         else
 500         {
 501                 A_PRINTF("Error! Incorrect format.\n\r");
 502
 503                 return -1;
 504         }
 505 }
 506
 507 LOCAL void dbg_timer_func(A_HANDLE alarm, void *data)
 508 {
 509         A_PRINTF("this is a timer alarm function 0x%08x\n\r", xthal_get_ccount());
 510 }
 511
 512 uint32_t delay = 0;
 513
 514 int db_intr_cmd(char* cmd, char* param1, char* param2, char* param3)
 515 {
 516 #if SYSTEM_MODULE_INTR
 517         uint32_t pending_intrs;
 518
 519         if(strcmp(param1, "read") == 0 )
 520         {
 521                 {
 522                         /* Update snapshot of pending interrupts */
 523
 524                         pending_intrs = A_INTR_GET_INTRPENDING();
 525
 526                         A_PRINTF("intr mask [0x%08x]\n\r", xthal_get_intenable());
 527                         A_PRINTF("intr on [0x%08x]\n\r", pending_intrs);
 528                 }
 529         }
 530         else if (strcmp(param1, "timer") == 0 )
 531         {
 532                 uint32_t data = 0;
 533
 534                 if (strcmp(param2, "on") == 0 )
 535                 {
 536                         /* TODO: this part is probably dead. */
 537                         pending_intrs = A_INTR_GET_INTRENABLE()|CMNOS_IMASK_XTTIMER;
 538                         A_INTR_SET_INTRENABLE(pending_intrs);
 539                         A_PRINTF("- intr [0x%08x]\n\r", pending_intrs);
 540                 }
 541                 else if ( strcmp(param2, "off") == 0 )
 542                 {
 543                         pending_intrs = A_INTR_GET_INTRENABLE()&(~CMNOS_IMASK_XTTIMER);
 544                         A_INTR_SET_INTRENABLE(pending_intrs);
 545                         A_PRINTF("- intr [0x%08x]\n\r", pending_intrs);
 546
 547                 }
 548                 else if( db_ascii_to_hex(param2, &data)==0 )
 549                 {
 550                         if( data>=0 && data <=10 )
 551                                 delay = data;
 552                         else
 553                                 delay = 3;
 554
 555                         A_PRINTF("==>set cb to %d seconds \n\r", delay);
 556                 }
 557
 558         }
 559         else
 560         {
 561                 A_PRINTF("\tintr read - read the interrenable status\n\r");
 562                 A_PRINTF("\tintr timer on/off/tick - timer attach on/off/ticks\n\r");
 563
 564         }
 565
 566 #endif //#if SYSTEM_MODULE_INTR
 567         return 0;
 568 }
 569
 570 uint32_t usb_swap_flag = 0; //default
 571 uint32_t usb_swap_flag_changed = 0;
 572 int db_usb_cmd(char* cmd, char* param1, char* param2, char* param3)
 573 {
 574         A_PRINTF("THIS IS USB COMMAND\n\r");
 575
 576         if( strcmp(param1, "que") == 0 )
 577         {
 578                 HIFusb_DescTraceDump();
 579         }
 580         else
 581         {
 582                 A_PRINTF("\tusb que - dump descriptor queue\n\r");
 583                 A_PRINTF("\tusb fw on/off - enable/disable write fw download to ram\n\r");
 584
 585         }
 586         return 0;
 587 }
 588
 589 static void clk_change(uint32_t clk, uint32_t ratio, uint32_t baud)
 590 {
 591         uint32_t clk_sel = 0;
 592
 593         switch(clk){
 594         case 22:
 595                 clk_sel = 0;
 596                 break;
 597         case 88:
 598                 clk_sel = 1;
 599                 break;
 600         case 44:
 601                 clk_sel = 2;
 602                 break;
 603         case 117:
 604                 clk_sel = 4;
 605                 break;
 606         case 40:
 607                 clk_sel = 6;
 608                 break;
 609         default:
 610                 clk_sel = 6;
 611                 break;
 612         }
 613
 614         HAL_WORD_REG_WRITE(0x50040, (0x300|clk_sel|(ratio>>1)<<12));
 615         A_UART_HWINIT((clk*1000*1000)/ratio, baud);
 616
 617 }
 618
 619 int db_clock_cmd(char* cmd, char* param1, char* param2, char* param3)
 620 {
 621         uint32_t ratio = 1;
 622         uint32_t baud = 19200;
 623         uint32_t clk = 0;
 624
 625         if( db_ascii_to_int(param1, &clk) != -1 )
 626         {
 627                 A_PRINTF("changing clock to %d\n", clk);
 628                 clk_change(clk, ratio, baud);
 629         }
 630 }
 631
 632 int db_info_cmd(char* cmd, char* param1, char* param2, char* param3)
 633 {
 634 #if 1
 635
 636         if(strcmp(param1, "ram") == 0 )
 637         {
 638                 A_ALLOCRAM_DEBUG();
 639         }
 640 #if 0  /* TODO: SYSTEM_MODULE_SYS_MONITOR depends on _ROM_ or _RAM_ which
 641         * is dead too */
 642         else if(strcmp(param1, "cpu") == 0)
 643                 zfPrintCpuUtilization();
 644 #endif
 645         else   // defalut dump
 646                 HIFusb_DescTraceDump();
 647
 648         return 1;
 649
 650 #else
 651
 652         {
 653                 uint32_t ccount1;
 654                 uint32_t ccount2;
 655
 656                 uint32_t data;
 657                 register uint32_t data1;
 658                 if( db_ascii_to_hex(param1, &data1)==0 )
 659                 {
 660                         __asm__ __volatile__ (
 661                                 "rsr     %0, ccount"
 662                                 : "=a" (ccount1) : : "memory"
 663                                 );
 664                         data = *(volatile uint32_t *)(data1);
 665                         __asm__ __volatile__ (
 666                                 "rsr     %0, ccount"
 667                                 : "=a" (ccount2) : : "memory"
 668                                 );
 669                         A_PRINTF("\n\rread 0x%08x (0x%08x) use %d clocks\n\r", data1, data, ccount2-ccount1);
 670                 }
 671
 672                 __asm__ __volatile__ (
 673                         "rsr     %0, ccount"
 674                         : "=a" (ccount1) : : "memory"
 675                         );
 676                 data = *(volatile uint32_t *)(data1);
 677                 __asm__ __volatile__ (
 678                         "rsr     %0, ccount"
 679                         : "=a" (ccount2) : : "memory"
 680                         );
 681                 A_PRINTF("\n\rread 0x%08x (0x%08x) use %d clocks\n\r", data1, data, ccount2-ccount1);
 682
 683
 684                 __asm__ __volatile__ (
 685                         "rsr     %0, ccount"
 686                         : "=a" (ccount1) : : "memory"
 687                         );
 688                 data = *(volatile uint32_t *)(data2);
 689                 __asm__ __volatile__ (
 690                         "rsr     %0, ccount"
 691                         : "=a" (ccount2) : : "memory"
 692                         );
 693                 A_PRINTF("read 0x%08x (0x%08x) use %d clocks\n\r", data2, data, ccount2-ccount1);
 694
 695
 696                 __asm__ __volatile__ (
 697                         "rsr     %0, ccount"
 698                         : "=a" (ccount1) : : "memory"
 699                         );
 700                 data = *(volatile uint32_t *)(data3);
 701                 __asm__ __volatile__ (
 702                         "rsr     %0, ccount"
 703                         : "=a" (ccount2) : : "memory"
 704                         );
 705                 A_PRINTF("read 0x%08x (0x%08x) use %d clocks\n\r", data3, data, ccount2-ccount1);
 706
 707         }
 708 #endif
 709         return 1;
 710 }
 711
 712 int db_cmd_starthtc(char* cmd, char* param1, char* param2, char* param3)
 713 {
 714     extern htc_handle_t htc_handle;
 715     HTC_Ready(htc_handle);
 716 }
 717
 718 #define WRITE_USB_DESC(pDesc, Offset)                                   \
 719         {                                                               \
 720                 uint16_t *pSrc = 0;                                     \
 721                 uint16_t mSize = 0;                                     \
 722                 pSrc = (uint16_t *)(pDesc);                             \
 723                 mSize = (*pSrc&0xff)/2;                                 \
 724                 A_PRINTF("0x%04x, 0x%04x, 0x%08x\n", Offset, mSize, pSrc); \
 725                 A_EEP_WRITE(Offset, mSize, pSrc);                       \
 726                 A_DELAY_USECS(500);                                     \
 727         }
 728
 729 #define READ_USB_DESC(pDesc, Offset, Size)                              \
 730         {                                                               \
 731                 uint16_t *pDst;                                         \
 732                 uint16_t mSize;                                         \
 733                 pDst = (uint16_t *)pDesc;                               \
 734                 A_EEP_READ(Offset, 1, &mSize);                          \
 735                 mSize = mSize &0xff;                                    \
 736                 mSize = mSize/2;                                        \
 737                 if( mSize > Size)                                       \
 738                         mSize = Size;                                   \
 739                 A_PRINTF("0x%04x, 0x%04x, 0x%08x\n", Offset, mSize, pDst); \
 740                 A_EEP_READ(Offset, mSize, pDst);                        \
 741                 A_DELAY_USECS(500);                                     \
 742         }
 743
 744
 745 ////////////////////////////////////////////////////////////////////////////////////////////////
 746
 747 extern uint16_t UsbDeviceDescriptor[];
 748 extern uint16_t String00Descriptor[];
 749 extern uint16_t String10Descriptor[];
 750 extern uint16_t String20Descriptor[];
 751 extern uint16_t String30Descriptor[];
 752
 753 int db_wdt_cmd(char* cmd, char* param1, char* param2, char* param3)
 754 {
 755         if ( strcmp(param1, "rst") == 0 )
 756         {
 757                 A_PRINTF(" reseting.....................\n\n\r");
 758                 A_WDT_RESET();
 759         }
 760         else if( strcmp(param1, "on") == 0 )
 761         {
 762                 A_WDT_ENABLE();
 763         }
 764         else if (strcmp(param1, "off") == 0 )
 765         {
 766                 A_WDT_DISABLE();
 767         }
 768         else if ( strcmp(param1, "boot") == 0 )
 769         {
 770                 if (ENUM_WDT_BOOT == A_WDT_LASTBOOT() )
 771                         A_PRINTF("LAST BOOT IS %s", "wdt");
 772                 else
 773                         A_PRINTF("LAST BOOT IS %s", "normal boot");
 774         }
 775         else if (strcmp(param1, "loop") == 0 )
 776         {
 777                 T_WDT_CMD wdt_cmd;
 778                 uint32_t time_offset;
 779                 A_PRINTF(" doing the wdt reseting................\n\n\r");
 780
 781                 if( db_ascii_to_hex(param2, &time_offset)!=0 )
 782                 {
 783                         if( time_offset < 0 || time_offset >0xffffffff )
 784                                 time_offset = 0xffffff;
 785                 }
 786                 A_PRINTF(" doing the wdt reseting (wdt tick: 0x%08x................\n\n\r", time_offset);
 787                 wdt_cmd.cmd = WDT_TIMEOUT;
 788                 wdt_cmd.timeout = time_offset;
 789
 790                 A_WDT_SET(wdt_cmd);
 791                 while(1) ;
 792         }
 793         else if (strcmp(param1, "noloop") == 0 )
 794         {
 795                 T_WDT_CMD wdt_cmd;
 796                 uint32_t time_offset;
 797                 A_PRINTF(" doing the wdt reseting................\n\n\r");
 798
 799                 if( db_ascii_to_hex(param3, &time_offset)!=0 )
 800                 {
 801                         if( time_offset < 0 || time_offset >0xffffffff )
 802                                 time_offset = 0xffffff;
 803                 }
 804                 A_PRINTF(" doing the wdt reseting (wdt tick: 0x%08x................\n\n\r", time_offset);
 805
 806                 wdt_cmd.cmd = WDT_TIMEOUT;
 807                 wdt_cmd.timeout = time_offset;
 808
 809                 A_WDT_SET(wdt_cmd);
 810         }
 811         else if( strcmp(param1, "event") == 0 )
 812         {
 813                 uint32_t event= 0x00123400;
 814 #define USB_BYTE_REG_WRITE(addr, val)           HAL_BYTE_REG_WRITE(USB_CTRL_BASE_ADDRESS|(uint8_t)(addr^3), (val))
 815 #define USB_BYTE_REG_READ(addr)                 HAL_BYTE_REG_READ(USB_CTRL_BASE_ADDRESS|(uint8_t)(addr^3))
 816
 817 #define USB_WORD_REG_WRITE(addr, val)           HAL_WORD_REG_WRITE(USB_CTRL_BASE_ADDRESS|(uint32_t)(addr), (val))
 818 #define USB_WORD_REG_READ(addr)                 HAL_WORD_REG_READ(USB_CTRL_BASE_ADDRESS|(uint32_t)(addr))
 819
 820                 // disable ep3 intr
 821                 USB_BYTE_REG_WRITE(0x17, USB_BYTE_REG_READ(0x17)|0xc0);
 822
 823                 //ZM_CBUS_FIFO_SIZE_REG = 0xf;
 824                 USB_WORD_REG_WRITE(0x100, 0x0f);
 825
 826                 //ZM_EP3_DATA_REG = event;
 827                 USB_WORD_REG_WRITE(0xF8, event);
 828
 829                 // tx done
 830                 USB_BYTE_REG_WRITE(0xAE, USB_BYTE_REG_READ(0xAE)|0x08);
 831
 832                 // enable ep3 intr
 833                 USB_BYTE_REG_WRITE(0x17, USB_BYTE_REG_READ(0x17)&0xbf);
 834         }
 835 }
 836
 837 #if defined(PROJECT_K2)
 838 #if SYSTEM_MODULE_SFLASH
 839 /* Serial Flash -> Chip Erase, Sector Erase, Block Erase */
 840 int db_cmd_sferase(char* cmd, char* param1, char* param2, char* param3)
 841 {
 842         unsigned long       addr;
 843
 844         if (strcmp(param1, "s") == 0)
 845         {
 846                 if (db_ascii_to_hex(param2, &addr) != -1 && addr < SPI_FLASH_MAX_SIZE)
 847                 {
 848                         /* Sector size is 4K (0x1000) */
 849                         A_PRINTF("Sector addr : 0x%08X\n\r", addr - addr%0x1000);
 850                         A_SFLASH_ERASE(ZM_SFLASH_SECTOR_ERASE, addr);
 851
 852                         return 0;
 853                 }
 854                 else
 855                 {
 856                         A_PRINTF("Error! Incorrect format.\n\r");
 857                         return -1;
 858                 }
 859         }
 860         else if (strcmp(param2, "b") == 0)
 861         {
 862                 if (db_ascii_to_hex(param2, &addr) != -1 && addr < SPI_FLASH_MAX_SIZE)
 863                 {
 864                         /* Sector size is 64K (0x10000) */
 865                         A_PRINTF("Block addr : 0x%08X\n\r", addr - addr%0x10000);
 866                         A_SFLASH_ERASE(ZM_SFLASH_BLOCK_ERASE, addr);
 867
 868                         return 0;
 869                 }
 870                 else
 871                 {
 872                         A_PRINTF("Error! Incorrect format.\n\r");
 873                         return -1;
 874                 }
 875         }
 876         else if (strcmp(param1, "c") == 0)
 877         {
 878                 A_SFLASH_ERASE(ZM_SFLASH_CHIP_ERASE, addr);
 879
 880                 A_PRINTF("\n\r");
 881                 return 0;
 882         }
 883         else
 884         {
 885                 A_PRINTF("Error! Unknown command.\n\r");
 886                 return -1;
 887         }
 888 }
 889
 890 /* Serial Flash -> Program */
 891 int db_cmd_sfpg(char* cmd, char* param1, char* param2, char* param3)
 892 {
 893         unsigned long       addr, len, buf;
 894
 895         if (db_ascii_to_hex(param1, &addr) != -1 &&
 896             db_ascii_to_hex(param2, &len) != -1 &&
 897             db_ascii_to_hex(param3, &buf) != -1 &&
 898             ((addr+len) <= SPI_FLASH_MAX_SIZE) &&
 899             addr%4 == 0 && len%4 == 0 && buf%4 == 0 &&
 900             ((buf >=0x500000 && buf < 0x528000) || (buf >=0x4e0000 && buf < 0x4e6000)) )
 901         {
 902                 A_SFLASH_PROG(addr, len, (A_UINT8 *)buf);
 903
 904                 A_PRINTF("\n\r");
 905                 return 0;
 906         }
 907         else
 908         {
 909                 A_PRINTF("Error! Incorrect format.\n\r");
 910                 return -1;
 911         }
 912 }
 913
 914 /* Serial Flash -> Read, Fast Read to UART */
 915 int db_cmd_sfru(char* cmd, char* param1, char* param2, char* param3)
 916 {
 917         A_UINT32            i;
 918         unsigned long       addr1, addr2, t_addr;
 919         A_UINT32            fast, val;
 920
 921         if (strcmp(param1, "r") == 0)
 922                 fast = 0;
 923         else if (strcmp(param1, "f") == 0)
 924                 fast = 1;
 925         else
 926         {
 927                 A_PRINTF("Error! Unknown command.\n\r");
 928                 return -1;
 929         }
 930
 931         if (db_ascii_to_hex(param2, &addr1) != -1 &&
 932             db_ascii_to_hex(param3, &addr2) != -1 &&
 933             addr1 < addr2 && addr1 < SPI_FLASH_MAX_SIZE &&
 934             addr2 < SPI_FLASH_MAX_SIZE && addr1%4 == 0)
 935         {
 936                 A_PRINTF("addr    data     data     data     data     data     data     data     data\n\r");
 937                 A_PRINTF("======  ======== ======== ======== ======== ======== ======== ======== ========");
 938
 939                 for (i = 0, t_addr = addr1; t_addr < addr2; i++, t_addr += 4)
 940                 {
 941                         if ((i%8) == 0)
 942                                 A_PRINTF("\n\r%06X  ", t_addr);
 943
 944                         A_SFLASH_READ(fast, t_addr, 4, (A_UINT8 *)&val);
 945                         A_PRINTF("%08X ", val);
 946                 }
 947
 948                 A_PRINTF("\n\r");
 949                 return 0;
 950         }
 951         else
 952         {
 953                 A_PRINTF("Error! Incorrect format.\n\r");
 954                 return -1;
 955         }
 956 }
 957
 958 /* Serial Flash -> Read, Fast Read to Memory */
 959 int db_cmd_sfrm(char* cmd, char* param1, char* param2, char* param3)
 960 {
 961         A_UINT32            i;
 962         unsigned long       addr1, addr2, t_addr;
 963         A_UINT32            fast;
 964         A_UINT8             *buf = (A_UINT8 *)0x520000;
 965
 966         if (strcmp(param1, "r") == 0)
 967                 fast = 0;
 968         else if (strcmp(param1, "f") == 0)
 969                 fast = 1;
 970         else
 971         {
 972                 A_PRINTF("Error! Unknown command.\n\r");
 973                 return -1;
 974         }
 975
 976         if (db_ascii_to_hex(param2, &addr1) != -1 &&
 977             db_ascii_to_hex(param3, &addr2) != -1 &&
 978             addr1 < addr2 && addr1 < SPI_FLASH_MAX_SIZE &&
 979             addr2 < SPI_FLASH_MAX_SIZE && addr1%4 == 0)
 980         {
 981                 for (i = 0, t_addr = addr1; t_addr < addr2; i++, t_addr += 4)
 982                 {
 983                         A_SFLASH_READ(fast, t_addr, 4, buf + i*4);
 984                 }
 985
 986                 A_PRINTF("\n\r");
 987                 return 0;
 988         }
 989         else
 990         {
 991                 A_PRINTF("Error! Incorrect format.\n\r");
 992                 return -1;
 993         }
 994 }
 995
 996 /* Serial Flash -> Read Status Register */
 997 int db_cmd_sfrdsr(char* cmd, char* param1, char* param2, char* param3)
 998 {
 999         A_PRINTF("0x%02X\n\r", A_SFLASH_RDSR());
1000         return 0;
1001 }
1002 #endif
1003 #endif /* #if defined(PROJECT_K2) */
1004
1005 /* Memory Comparison */
1006 int db_cmd_memcmp(char* cmd, char* param1, char* param2, char* param3)
1007 {
1008         unsigned long       addr1, addr2, len;
1009         A_UINT8             *buf1, *buf2;
1010
1011         if (db_ascii_to_hex(param1, &addr1) != -1 &&
1012             db_ascii_to_hex(param2, &addr2) != -1 &&
1013             db_ascii_to_hex(param3, &len) != -1 &&
1014             addr1 != addr2 && addr1%4 == 0 && addr2%4 == 0 && len%4 == 0)
1015         {
1016                 buf1 = (A_UINT8 *)addr1;
1017                 buf2 = (A_UINT8 *)addr2;        ;
1018
1019                 A_PRINTF("memcmp(buf1, buf2, len) = %d\n\r", A_MEMCMP(buf1, buf2, len));
1020                 return 0;
1021         }
1022         else
1023         {
1024                 A_PRINTF("Error! Incorrect format.\n\r");
1025                 return -1;
1026         }
1027 }
1028
1029 /* Memory Dump */
1030 int db_cmd_memdump(char* cmd, char* param1, char* param2, char* param3)
1031 {
1032         A_UINT32            i;
1033         unsigned long       addr1, addr2, t_addr;
1034         A_UINT32            *val;
1035
1036         if (db_ascii_to_hex(param1, &addr1) != -1 && db_ascii_to_hex(param2, &addr2) != -1 && addr1 < addr2 && addr1%4 == 0)
1037         {
1038                 A_PRINTF("addr    data     data     data     data     data     data     data     data\n\r");
1039                 A_PRINTF("======  ======== ======== ======== ======== ======== ======== ======== ========");
1040
1041                 for (i = 0, t_addr = addr1; t_addr < addr2; i++, t_addr += 4)
1042                 {
1043                         if ((i%8) == 0)
1044                                 A_PRINTF("\n\r%06X  ", t_addr);
1045
1046                         val = (A_UINT32 *)t_addr;
1047                         A_PRINTF("%08X ", *val);
1048                 }
1049
1050                 A_PRINTF("\n\r");
1051                 return 0;
1052         }
1053         else
1054         {
1055                 A_PRINTF("Error! Incorrect format.\n\r");
1056                 return -1;
1057         }
1058 }
1059 void cmnos_dbg_module_install(struct dbg_api *apis)
1060 {
1061         apis->_dbg_init = zfDebugInit;
1062         apis->_dbg_task = zfDebugTask;
1063 }
1064
1065 #endif  /* SYSTEM_MODULE_DBG */
1066