Windows LiveWindows Live™
 
 
一只鱼 的个人资料EE小站照片日志列表更多 工具 帮助

日志
    11月19日

    PowerPC处理器MPC8313E初体验


    最近终于开始实质性的玩PowerPC MPC8313E了，这种感觉就像2006年我第一次玩S3C2410一样——很晕。但是我不像当年那样摸黑调试Vivi了，我入手干的第一件事情就是研究工具链。很遗憾，目前PowerPC开发的成本相当高。一开始我就寻找有没有便宜的硬件和软件工具，事实上我找到了——Wiggler+OCDRemote+GDB，请看我的这篇文章http://xianzilu.spaces.live.com/blog/cns!4201FDC93932DDAF!602.entry，有缘人自己体会如何使用最新的OCDRemote，但是，我觉得Macraigor今后应该不会让Wiggler支持的新PowerPC器件（例如MPC8313E），要OOXX掉OCDRemote中的限制我也尝试了下，太难，毕竟我不熟悉X86的汇编，希望有高手能够努力下。目前，Wiggler+OCDRemote+GDB理论上可以支持国内比较流行的MPC5200B和MPC860这样的老器件，我没有尝试过，大家有兴趣可以试下。BDI2000之类的东西，一般人是不会有钱尝试的，也就算了，我现在找到的最便宜的调试解决方案是Freescale的USBTAP+Codewarrior，USBTAP绝对是垄断，需要5000RMB左右，没办法，贵也得买。Codewarrior就好说了，在Freescale官方下载个评估版，然后Google下“CodeWarrior License制作教程”，就搞定了。开发板更困难了，我在考虑以后是不是做一个，嘿嘿，等我有时间吧；现在的开发板都贵得要命，大家自己想办法了。如果个人要玩VXWorks，对不起，你一定是在开玩笑。哦，还有编译器，这是免费的，到Freescale官方下载你要玩的CPU的BSP，运行里面的脚本，就会给你制作一个。

    这篇文章是绝对的菜鸟文，用于记录我在玩8313过程中遇到的问题和解决方案。首先展示下我焊的那块8313板后面的好几十个0402的104电容，焊这些东西耗费了我一天时间……

    先给一个参照物，这是一支笔

    然后是我手焊的0402电容……

    开始正文，PowerPC的启动比较奇怪（当然我是带着ARM的眼光看的），CPU内核需要从外部存储设备加载配置字，用这些配置字初始化PLL，并决定从哪个地址启动。PLL初始化之后就不能更改，看来PowerPC根本没有打算往低功耗方面发展。在8313上，Flash内没有内容时，可以用配置字b1100启动，CPU速度是333M，DDR内存时钟MCK是166M；用这个配置可以烧写Flash。我很疑惑的是b1100这个配置字令CPU处于PCI从模式，理论上需要有PCI_CLK，CPU才能启动。但是在我们的板上，PCI_CLK接地，而PCI_SYNC_IN用一个22欧电阻接到了PCI_SYNC_OUT上（当然这是抄官方开发板的），所有晶振都没有焊呢，不知道怎么搞得，就能产生很准确的66M时钟，我真很汗。

    焊好电源、CPU、DDR之后，测试了下DDR，速度还是不错的，120MB的内存两秒就扫描完了，ARM可做不到这点。进一步研究了下，发现Freescale晃点我，开发板上用的是DDR2 667的内存芯片，但是MPC8313 DDR控制器的最高速度只有166M即DDR 333的水平……估计MPC8313也就用了DDR2芯片的ODT功能，要是外接电阻的话，DDR一代的芯片也可以用。

    经过很长时间的资料搜索和摸索，终于知道怎么用CodeWarrior（Windows版）调试U-Boot了。跟过去一样，还是虚拟机下用Samba共享U-Boot的程序目录，然后用CodeWarrior打开。编译器刚才已经提到了，用Freescale自己的BSP来做一个，调试的具体操作可以看CodeWarrior（Linux版）的文档。我还是把这部分贴出来，CodeWarrior Linux版有550M，下载需要好久，给大家提供个方便吧。 需要注意的是，不可以直接将U-Boot加载到内存里进行调试，要先烧写；简单点说就严格按照下面这篇教学里说的做。可能你会需要一个U-Boot在DDR里的执行入口（文中描述的Now running in RAM - U-boot at: XXXX），这个入口U-Boot 1.3.4默认是不打印的，打印这个信息的代码在board.c中的board_init_f()函数末尾部分，默认是个DEBUG宏，把它改成printf就可以了。等以后我彻底研究明白了再上来写为什么要先烧写才能调试。

     

     

    Tutorial: Debugging the U-Boot Universal Boot Loader

    This section shows you how to use the CodeWarrior debugger to debug the U-Boot universal boot loader. U-Boot resides in flash memory on target systems and boots an embedded Linux image developed for those systems.

    Note: The Linux Application Edition of this product does not support debugging the U-Boot bootstrap firmware.

    The topics in this section are:

    Preparing to Debug U-Boot

    To prepare to debug U-Boot on a target system, you first install on the host Linux computer the Board Support Package (BSP) for the particular target system you want to debug. Then you configure the BSP U-Boot package to place debugger symbolic information in the U-Boot binary executable file. Finally, you create a new CodeWarrior project that you will use to debug U-Boot on the target system.

    Note: The first part of this procedure must be performed on a Linux host.

    To prepare to debug U-Boot on a target system:

    1. On the host computer, where CodeWarrior Development Studio is installed, install the board support package (BSP) for your target system.

      2. You can obtain BSPs for Freescale Power Architecture target systems from this web page: 

      http://www.freescale.com/codewarrior/downloads
    2. Use the tools included with the BSP to build an ELF-format U-Boot image file that includes debugger symbolic information.
      1. Make these changes to the file u-boot/config.mk:
      • DBGFLAGS = -g2 -gdwarf-2
      • AFLAGS_DEBUG = -Wa,-gdwarf2
      • OPTFLAGS = -O1

        Note: If you are using a Linux Target Image Builder (LTIB) BSP, you may need to change the optimization flag of the CFLAGS argument in this file:

        LTIBInstallDir/config/platform/board_name/.config

      1. If the version of U-Boot included with the BSP modifies any of these registers during startup, comment the appropriate lines in the file u-boot/cpu/mpc85xx/start.S file so that U-Boot will not modify the registers:
      • DBCR0
      • IAC1
      • IAC2
      • DAC1
      • DAC2
      1. In the file u-boot/lib_ppc/board.c, change the token debug to the token printf in the statement that includes this string:
        2. Now running in ram
      2. Rebuild U-Boot.

    You now have an ELF-format U-Boot binary executable file that contains debugger symbolic information. In addition, you have a U-Boot raw binary (.bin) file that you can write to flash memory on the target board.

    Note: It is best to leave the ELF-format U-Boot binary file in this location, so that when you create a CodeWarrior project with the file, the CodeWarrior IDE can find all of the source U-Boot source code files needed to debug the binary file.

    Note: The following procedure must be performed using the Professional Edition of this CodeWarrior product.

    1. Start the CodeWarrior IDE.
    2. Use the CodeWarrior Flash Programmer to write the raw binary U-Boot file (not the ELF-format file) to the flash memory of that target system.

      3. Refer to the "Flashing U-Boot" section of the target system's BSP User's Guide for instructions that show how to flash U-Boot to the system. This document is typically located in the help/software folder of the BSP.

      Warning: Do not write the ELF-format U-Boot file to flash memory; you must use the raw binary U-Boot file.

    3. From the CodeWarrior menu bar, select File > Open.

      4. The standard Open dialog box appears.

    4. Navigate to and select (highlight) the ELF-format U-Boot file containing debugger symbolic information (one of the files you created in the previous step).
    5. Click Open.
    6. The Choose Debugger dialog box (Figure 3.72) appears.
      7. Figure 3.72 Choose Debugger Dialog Box


    7. Select one of these remote connections:
    8. CodeWarrior Ethernet TAP - if you are using an Ethernet TAP run-control device.
    9. CodeWarrior USB TAP - if you are using a USB TAP run-control device.

      10. Note: You must use a JTAG run-control device to debug U-Boot. The CodeWarrior USB TAP and the CodeWarrior Ethernet TAP are each JTAG devices.

      The CodeWarrior IDE creates a CodeWarrior project containing the source files used to build the U-boot binary file. The CodeWarrior project file is located in the same directory as the ELF-format U-Boot file.

      Note: For the IDE to create complete a U-Boot project file, all source files used to build the ELF format U-Boot file must be available. While the IDE is building the new CodeWarrior project, if it cannot find a U-Boot source code file, it displays a dialog box with which you can navigate to and select the file. For each source code file that cannot be found, the IDE logs a message to the Project Creator Log window.

      Once project creation is complete, the IDE displays the project in a project window. (See Figure 3.73.)

      Figure 3.73 CodeWarrior Project Window


    You now have CodeWarrior project with which you can debug the U-Boot bootstrap firmware.

    Note: While debugging U-Boot on 86xx, if address translations has not been enabled and you set a breakpoint in a part of code after the address translation is done, this breakpoint will not be hit. Breakpoints can be used until enable address translation is done. You can use step into to debug through the address translation section (breakpoints / step over / run to cursor cannot be used). After the translation is enabled, you can start using again the hardware breakpoints. A breakpoint set in the c) part of code while debugging in the a) part of code will not be hit.

    During a typical U-Boot start-up sequence, the target processor starts executing U-Boot in flash memory. U-Boot then enables the Memory Management Unit (MMU), and relocates itself to RAM.

    CodeWarrior build target settings required to debug U-Boot in flash memory differ from the settings required to debug U-Boot in RAM. Therefore, you must use individual CodeWarrior debug sessions to debug the flash memory and RAM sections:

    Debugging U-Boot in Flash Memory Before the MMU is Enabled

    To debug U-Boot in flash memory before the target board's memory management unit (MMU) is enabled:

    1. Start the CodeWarrior IDE.
    2. Open the CodeWarrior U-Boot project you created in section "Preparing to Debug U-Boot".
    3. From the CodeWarrior menu bar, select Edit > Debug Settings.

      4. The Target Settings window (Figure 3.74) appears.

      Figure 3.74 Target Settings Window


    4. From the Target Settings Panels list, select Debugger Settings

      5. The Debugger Settings panel (Figure 3.75) appears.

      Figure 3.75 Debugger Settings Panel


    5. Check the Stop on Application Launch checkbox.
    6. Select the Program entry point option button.
    7. From the Target Settings Panels list, select Remote Debugging.

      8. The Remote Debugging settings panel (Figure 3.76) appears.

      Figure 3.76 Remote Debugging Settings Panel


    8. From the Connection list box, select one of these remote connections:
    9. CodeWarrior Ethernet TAP
    10. CodeWarrior USB TAP
    11. Click the Edit Connection button.
    12. When the IDE displays a dialog box asking if you want to continue, click OK.

      13. The Edit Connection dialog box (Figure 3.77) appears, displaying the configuration for the selected remote connection.

      Figure 3.77 Edit Connection Dialog Box


    13. Check the Reset Target on Launch checkbox.
    14. Click OK.

      15. The Edit Connection dialog box disappears.

    15. From the Target Settings Panels list, select Debugger PIC Settings.

      16. The Debugger PIC Settings settings panel (Figure 3.78) appears.

      Figure 3.78 Debugger PIC Settings Panel


    16. Check the Alternate Load Address checkbox.

      17. Note: An alternate load address causes the debugger to assume that all sections have been relocated to RAM. If you specify no alternate load address, the debugger can display source code only for sections in flash memory. If you specify an alternate load address, the debugger can display source code only for sections in RAM.

    17. In the Alternate Load Address text box, type the hexadecimal form of the memory address at which the U-Boot image was written to flash memory.
    18. From the Target Settings Panels list, select EPPC Debugger Settings.

      19. The EPPC Debugger Settings settings panel (Figure 3.79) appears.

      Figure 3.79 EPPC Debugger Settings Panel


    19. From the Processor Family list box, select the family of the target processor.
    20. From the Target Processor list box, select the target processor.
    21. From the Target OS list box, select Bareboard.
    22. Check the Use Target Initialization File checkbox.
    23. Click Browse to display a dialog box with which you can navigate to and select the target initialization file for the target system.
    24. In the Program Download Options area, clear all the checkboxes in the Initial Launch and Successive Runs sections.
    25. Click the Save button.
    26. Close the Target Settings window.

      27. The Target Settings window disappears. The CodeWarrior IDE saves your changes to target settings.

    27. On the host computer running the CodeWarrior IDE, start a terminal emulator program such as minicom.
    28. Configure the terminal emulator as shown in Table 3.24.
      29. Table 3.24 Terminal Emulator Configuration Settings?
      bits per second
      115200
      data bits
      8
      parity
      none
      stop bits
      1
      hardware flow control
      none
      software flow control
      none
    29. Power on or reset the target system.

      30. The system resets.The terminal emulator displays U-Boot status messages.

      Note: If U-Boot asks for the MAC address of the board's Ethernet interface, enter a valid MAC address, such as 00:01:03:00:01:04.

      U-Boot finishes initialization and displays this message (where N is the number of seconds left before autoboot starts): 

      Hit any key to stop autoboot: N
    30. Stop the autoboot process by pressing any key on the keyboard.

      31. The U-Boot command prompt appears: 

      -->
    31. From the CodeWarrior menu bar, select Debug > Attach To Process.

      32. The CodeWarrior debugger connects to the target system and displays a debugger window.

    32. From the CodeWarrior menu bar, select Debug > Stop.

      33. The debugger halts U-Boot execution and displays disassembled code in the Source pane of the debugger window (See Figure 3.80).

      Figure 3.80 Attach To Process - Debugger Window


    33. Select Debug > EPPC > Hard Reset.

      34. The debugger sends a hard reset signal to the board. The debugger window displays the __start section. You can debug from this point up to the first blr instruction in start.S.

    Debugging U-Boot in Flash Memory After the MMU is Enabled

    To debug U-Boot in flash memory after the target board's memory management unit (MMU) is enabled:

    1. Start the CodeWarrior IDE.
    2. Open the CodeWarrior U-Boot project you created in section "Preparing to Debug U-Boot".
    3. From the CodeWarrior menu bar, select Edit > Debug Settings.

      4. The Target Settings window (Figure 3.74) appears.

      Figure 3.81 Target Settings Window


    4. From the Target Settings Panels list, select Debugger Settings

      5. The Debugger Settings panel (Figure 3.75) appears.

      Figure 3.82 Debugger Settings Panel


    5. Check the Stop on Application Launch checkbox.
    6. Select the Program entry point option button.
    7. From the Target Settings Panels list, select Remote Debugging.

      8. The Remote Debugging settings panel (Figure 3.76) appears.

      Figure 3.83 Remote Debugging Settings Panel


    8. From the Connection list box, select one of these remote connections:
    9. CodeWarrior Ethernet TAP
    10. CodeWarrior USB TAP
    11. Click the Edit Connection button.
    12. When the IDE displays a dialog box asking if you want to continue, click OK.

      13. The Edit Connection dialog box (Figure 3.77) appears, displaying the configuration for the selected remote connection.

      Figure 3.84 Edit Connection Dialog Box


    13. Check the Reset Target on Launch checkbox.
    14. Click OK.

      15. The Edit Connection dialog box disappears.

    15. From the Target Settings Panels list, select Debugger PIC Settings.

      16. The Debugger PIC Settings settings panel (Figure 3.78) appears.

      Figure 3.85 Debugger PIC Settings Panel


    16. Clear the Alternate Load Address checkbox.

      17. Note: An alternate load address causes the debugger to assume that all sections have been relocated to RAM. If you specify no alternate load address, the debugger can display source code only for sections in flash memory. If you specify an alternate load address, the debugger can display source code only for sections in RAM.

    17. From the Target Settings Panels list, select EPPC Debugger Settings.

      18. The EPPC Debugger Settings settings panel (Figure 3.79) appears.

      Figure 3.86 EPPC Debugger Settings Panel


    18. From the Processor Family list box, select the family of the target processor.
    19. From the Target Processor list box, select the target processor.
    20. From the Target OS list box, select Bareboard.
    21. Check the Use Target Initialization File checkbox.
    22. Click Browse to display a dialog box with which you can navigate to and select the target initialization file for the target system.
    23. In the Program Download Options area, clear all the checkboxes in the Initial Launch and Successive Runs sections.
    24. Click the Save button.
    25. Close the Target Settings window.

      26. The Target Settings window disappears. The CodeWarrior IDE saves your changes to target settings.

    26. On the host computer running the CodeWarrior IDE, start a terminal emulator program such as minicom.
    27. Configure the terminal emulator as shown in Table 3.24.
      28. Table 3.25 Terminal Emulator Configuration Settings?
      bits per second
      115200
      data bits
      8
      parity
      none
      stop bits
      1
      hardware flow control
      none
      software flow control
      none
    28. Power on or reset the target system.

      29. The system resets.The terminal emulator displays U-Boot status messages.

      Note: If U-Boot asks for the MAC address of the board's Ethernet interface, enter a valid MAC address, such as 00:01:03:00:01:04.

      U-Boot finishes initialization and displays this message (where N is the number of seconds left before autoboot starts): 

      Hit any key to stop autoboot: N
    29. Stop the autoboot process by pressing any key on the keyboard.

      30. The U-Boot command prompt appears: 

      -->
    30. From the CodeWarrior menu bar, select Debug > Attach To Process.

      31. The CodeWarrior debugger connects to the target system and displays a debugger window.

    31. From the CodeWarrior menu bar, select Debug > Stop.

      32. The debugger halts U-Boot execution and displays disassembled code in the Source pane of the debugger window (See Figure 3.80).

      Figure 3.87 Attach To Process - Debugger Window


    32. Select Debug > EPPC > Hard Reset.

      33. The debugger sends a hard reset signal to the board. The debugger window displays the __start section. You can debug from this point up to the first blr instruction in start.S.

    33. Select Window > Symbolics Window.

      34. The Symbolics Window (Figure 3.88) appears.

    34. In the Executables list, select u-boot.
    35. In the Files list, select board.c.
    36. In the Functions list, select board_init_f.
    37. The IDE displays the source code of the board_init_f() function in the Source pane (as shown in Figure 3.88).
      38. Figure 3.88 Symbolics Window - Flash Board Initialization Function


    38. In the Source pane, right-click the first line of the board_init_f() function with a tick mark in the breakpoint column on the left side of the window.

      39. A contextual menu appears, as shown in Figure 3.89.

      Figure 3.89 Debugger Window - Contextual Menu


    39. From the contextual menu, select Set Hardware Breakpoint.

      40. The IDE sets the hardware breakpoint on the selected line of code. A blue diamond symbol appears over the tick mark in the breakpoint column, indicating that a hardware breakpoint is set.

    40. Close the Symbolics Window.
    41. From the CodeWarrior menu bar, select Debug > EPPC > Hard Reset.

      42. The debugger resets the target system and halts U-Boot execution at the start of U-Boot.

    42. Select Project > Run.

      43. The debugger starts U-Boot execution. When execution reaches the hardware breakpoint, the debugger halts execution. A debugger window (Figure 3.90) appears, showing the source code of the board_init_f() function.

      Figure 3.90 Debugger Window - Stopped At Hardware Breakpoint


      Note: In this debugger window, the blue arrow indicates that the program counter (PC) is at the line of code on which you set the hardware breakpoint.

    You may now use the features of the CodeWarrior debugger to step through the source code and debug U-Boot in flash memory.

    Debugging U-Boot in RAM

    To debug U-Boot in RAM:

    1. On the host computer, start a terminal emulator program such as minicom.
    2. Configure the terminal emulator as shown in Table 3.26.
      3. Table 3.26 Terminal Emulator Configuration Settings?
      bits per second
      115200
      data bits
      8
      parity
      none
      stop bits
      1
      hardware flow control
      none
      software flow control
      none
    3. Reset or power on the target system.

      4. The system resets.The terminal emulator displays U-Boot status messages (as shown in Figure 3.91).

    4. If U-Boot asks for the MAC address of the board's Ethernet interface, enter a valid MAC address, such as 00:01:03:00:01:04.

      5. U-Boot finishes initialization and displays this message (where N is the number of seconds left before autoboot starts): 

      Hit any key to stop autoboot: N
    5. Press a key on your keyboard to stop the autoboot process.

      6. The U-Boot command prompt appears (as shown in Figure 3.91): 

      -->
      Figure 3.91 U-Boot Startup Messages


    6. Write down the memory address from this U-Boot startup message (as shown in Figure 3.91):
      7. Now running in RAM - U-Boot at: address
    7. Start the CodeWarrior IDE.
    8. Open the CodeWarrior U-Boot project you created in section "Preparing to Debug U-Boot".
    9. From the CodeWarrior menu bar, select Edit > Debug Settings.

      10. The Target Settings window (Figure 3.92) appears.

      Figure 3.92 Target Settings Window


    10. From the Target Settings Panels list, select Debugger Settings

      11. The Debugger Settings panel (Figure 3.93) appears.

      Figure 3.93 Debugger Settings Panel


    11. Check the Stop on Application Launch checkbox.
    12. Select the Program entry point option button.
    13. From the Target Settings Panels list, select Remote Debugging.

      14. The Remote Debugging settings panel (Figure 3.94) appears.

      Figure 3.94 Remote Debugging Settings Panel


    14. From the Connection list box, select one of these remote connections:
    15. CodeWarrior Ethernet TAP
    16. CodeWarrior USB TAP
    17. Click the Edit Connection button.
    18. When the IDE displays a dialog box asking if you want to continue, click OK.

      19. The Edit Connection dialog box (Figure 3.95) appears, displaying the configuration for the selected remote connection.

      Figure 3.95 Edit Connection Dialog Box


    19. Check the Reset Target on Launch checkbox.
    20. Click OK.

      21. The Edit Connection dialog box disappears.

    21. From the Target Settings Panels list, select Debugger PIC Settings.

      22. The Debugger PIC Settings settings panel (Figure 3.96) appears.

      Figure 3.96 Debugger PIC Settings Panel


    22. Check the Alternate Load Address checkbox.
    23. In the Alternate Load Address text box, enter the memory address you wrote down earlier, from the U-Boot startup messages displayed in the terminal emulator.

      24. Use the format: 0xFFFFFFFF

      Note: An alternate load address causes the debugger to assume that all sections have been relocated to RAM. If you specify no alternate load address, the debugger can display source code only for sections in flash memory. If you specify an alternate load address, the debugger can display source code only for sections in RAM.

    24. From the Target Settings Panels list, select EPPC Debugger Settings.

      25. The EPPC Debugger Settings settings panel (Figure 3.79) appears.

      Figure 3.97 EPPC Debugger Settings Panel


    25. From the Processor Family list box, select the family of the target processor.
    26. From the Target Processor list box, select the target processor.
    27. From the Target OS list box, select Bareboard.
    28. Check the Use Target Initialization File checkbox.
    29. Click Browse to display a dialog box with which you can navigate to and select the target initialization file for the target system.
    30. In the Program Download Options area, clear all the checkboxes in the Initial Launch and Successive Runs sections.
    31. Click the Save button.
    32. Close the Target Settings window.

      33. The Target Settings window disappears. The CodeWarrior IDE saves your changes to target settings.

    33. From the CodeWarrior menu bar, select Debug > Attach To Process.

      34. The CodeWarrior debugger connects to the target system and displays a debugger window.

    34. From the CodeWarrior menu bar, select Debug > Stop.

      35. The debugger halts U-Boot execution and displays disassembled code in the Source pane of the debugger window (See Figure 3.98).

      Figure 3.98 Attach To Process - Debugger Window


    35. Select Window > Symbolics Window.

      36. The Symbolics Window (Figure 3.99) appears.

    36. In the Executables list, select u-boot.
    37. In the Files list, select board.c.
    38. In the Functions list, select board_init_r.
    39. The IDE displays the source code of the board_init_r() function in the Source pane (as shown in Figure 3.88).
      40. Figure 3.99 Symbolics Window - RAM Board Initialization Function


    40. In the Source pane, right-click the first line of the board_init_r() function with a tick mark in the breakpoint column.

      41. A contextual menu appears, as shown in Figure 3.89.

      Figure 3.100 Debugger Window - Contextual Menu


    41. From the contextual menu, select Set Hardware Breakpoint.

      42. The IDE sets the hardware breakpoint on the selected line of code. A blue triangle appears over the tick mark in the breakpoint column, indicating that a hardware breakpoint is set.

    42. Close the Symbolics Window.
    43. From the CodeWarrior menu bar, select Debug > EPPC > Hard Reset.

      44. The debugger resets the target system and halts U-Boot execution at the start of U-Boot.

    44. Select Project > Run.
    45. The debugger starts U-Boot execution. When execution reaches the hardware breakpoint, the debugger halts execution. A debugger window (Figure 3.90) appears, showing the source code of the board_init_f() function.
      46. Figure 3.101 Debugger Window - Stopped At Hardware Breakpoint


      Note: In this debugger window, the blue arrow indicates that the program counter (PC) is at the line of code on which you set the hardware breakpoint.

    You may now use the features of the CodeWarrior debugger to step through the source code and debug U-Boot in RAM.

    15:11 | 添加评论 | 阅读评论 (4) | 固定链接 | 查看引用通告 (1) | 写入日志 | PowerPC Linux