Using JTAG with Blackfin Processors Using JTAG with Linux Traditional non-Linux or non-OS (Operating System) embedded software development often requires hardware debuggers connected through a JTAG (Joint Test Action Group - low level interface to cpu) interface. This is necessary for development of drivers, and possibly applications, because they’re linked into the same memory space as the kernel. If a driver or application crashes, the kernel and system may crash as a result. Debugging target systems with the Linux kernel is different because its architecture is significantly different from other embeddable RTOSes. All Linux applications run in their own address space which is different than the link time or compile time addresses. This has the advantage that the software is more reliable and fault tolerant. However, conventional hardware debuggers rely on decoding physical memory addresses, making them incompatible with debugging user applications based in a virtual or non-link time memory address environment. Furthermore, Linux lets you develop multi-threaded applications, which hardware debuggers generally don’t support. Linux provides a software debugging agent that makes it possible for you to debug user applications known as gdb. However, the major constraint of using gdb is that the Bootloader and Linux kernel must already be running on the target. In the case of board bring up, a software debug agent such as gdb isn’t available. However, the bootloader and kernel start run where link time and run time addresses are the same, allowing them to be debugged with conventional hardware debuggers. This is the primary function of the JTAG (Joint Test Action Group - low level interface to cpu) debugger throughout the Linux software development phase. You use the hardware debugger to debug the Bootloader, kernel start, and drivers and gdb to debug applications once the kernel is running. You can also use a hardware debugger to examine registers and view memory while the kernel and applications are running, if you know the physical addresses. JTAG (Joint Test Action Group - low level interface to cpu) is not used for developing Linux applications. Using JTAG with non-Linux applications When developing non-Linux applications (things like U-Boot, micromonitor, stand_alone_applications, µC/OS-II, etc) where the link time address is the same as the run time address, JTAG (Joint Test Action Group - low level interface to cpu) debuggers are an excellent way to debug the system. Available JTAG solutions Here is a list of JTAG (Joint Test Action Group - low level interface to cpu) devices that are known to work with Blackfin processors. There may be others, but we know these are OK. If you wish to purchase one, see the buy stuff page for more information. For more information about JTAG (Joint Test Action Group - low level interface to cpu) in general, see the Blackfin JTAG document. ADI ICE 100B - via high speed USB (Universal Serial Bus) gnICE - via low speed USB (Universal Serial Bus) gnICE+ - via high speed USB (Universal Serial Bus) ICEbear - via low speed USB (Universal Serial Bus) PEEDI - via ethernet JTAGBLUE - via parallel port Unsupported Devices These devices are specifically known to not be supported by any open source software. If you need to use open source development tools, do not purchase these. ADI USB ICE - the low and high speed USB (Universal Serial Bus) models the USB (Universal Serial Bus) connector on all EZ-Kit boards