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