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