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