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