target_firmware/magpie_fw_dev/target/cmnos/dbg_api.c

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