JTAG Debugger
Introduction
A
JTAG Debugger or JTAG Debug Tool is the combination of an embedded
source-level debugger, working in concert with a JTAG Emulator or JTAG
in-circuit emulator (ICE). There are typically two types of JTAG
Debuggers to choose from, depending on your budget and needs:
The
following
paragraphs describe each approach to debugging with JTAG.
JTAG Debugging with GDB, DDD,
Insight and Eclipse for Cost Effective Embedded Development
Taking
advantage of the powerful free debuggers available, like: GDB,
DDD, Eclipse, Insight and others, the Guardian-SE
JTAG Emulator (ICE) extends the power of these GDB based tools
to give
you the
best GDB
hardware-assisted JTAG debug experience available today.
Guardian-SE and Agile-DB provide the following benefits to GDB-based
debugging:
Exceptional
Price/Performance
JTAG
Debuggers cost
a fraction of what you would pay for traditional In-Circuit
Emulators, yet provide as good
or better functionality
Works
with PowerPC,
MIPS, XScale and ARM Processors
Guardian-SE
can support multiple processor
families at one time. Keep one box on the shelf and never
waste time changing firmware just to change processors
LINUX
Debug Support
Debugging Embedded LINUX
via JTAG Debugger requires that the JTAG Debug tool understand the
MMU/Memory translation used by Embedded
LINUX
on the processor under test. Agile-DB and Guardian-SE provide support
for debugging the LINUX kernel and LINUX loadable modules with JTAG.
UBoot
JTAG Debug Support
Uboot
is a popular boot loader used to boot Embedded LINUX. As UBoot starts
up, it copies itself from FLASH to RAM memory. This behavior requires
that the JTAG debugger can load multiple copies of the debug
information for u-boot: one for FLASH based debug, and one for RAM
based debug. Unfortunately, many debuggers do not handle multiple debug
files well. Without this feature, you would not be able to debug the full
boot process in one session. Agile-DB fully supports this
important feature. This feature is also crucial for debugging
Linux loadable modules.
Target
JTAG Initialization Support
JTAG
debuggers like Agile-DB, allow you to send a target memory and register
configuration
to your target over JTAG when you perform a reset command. This allows
you to get the target into a working state so that you can begin to
test it or run code. Agile-DB provides high-level GUI access to all
target registers, CACHE status and MMU settings, making it fast and
painless to create this file. Embedded Toolsmiths also provides ready-to-run
files for popular boards and evaluation kits
Manufacturing
Test Support
JTAG
Debug tools make for
excellent platforms for manufacturing test automation. Agile-DB has
programmable buttons, a powerful macro language and extensive FLASH
device support to help you initialize and test production hardware. Agile-Utilities
(a JTAG tool specifically ddesigned for board bring up and test
automation) is also perfect for test automation where full debugging is
not required.
Crash
Proof Debug
Using
JTAG debuggers to
see what caused your target to crash is very useful. Simply run your
target, then, after the crash you can see the target status: register,
cache, mmu values, the stack, etc.. Agile-DB also allow you to "hot
plug" into a running or crashed system without disturbing it's state.
Board/Hardware
Bring Up Support
JTAG
Debuggers are great for initial
hardware bringup. Just plug in and you are ready to peek and
poke your target system or run more advanced tests and user defined
macros.
Hardware
Break Points
Hardware
break points use
the on-chip break registers in a processor to allow you to set up
conditions to stop execution. Hardware break points can be used on both
RAM and FLASH based code and if supported by the processor, for data
address breaks as well.
Flash
Programming
JTAG
debuggers typically support FLASH programming
on your target by using target RAM to store the erase and program
routines. Agile-DB also provides versions of our FLASH utilities that
do NOT require working RAM--this is useful for new systems where RAM is
not yet set up.
Target
Snap Shots While Running
This
unique JTAG Debug
feature of Agile-DB let's you grab target memory, register, and
MMU/CACHE values from your target--even while it is still running.
Although this is not done in real-time, the operation will typically
not disturb the operation of your system.
Hot
Plug into a crashed or Running Target
The
JTAG Debug feature
let's you plug into your target at any time and view target values
without disturbing the target in the process.
Auto
ID of the Target Processor or FLASH Device
When
you plug into your
system, Agile-DB can use JTAG to automatically detect the processor
under test and the FLASH device on your target.
Register
Detail
Agile-DB
provides full
bit-level detail for on-chip target registers, throw away those yellow
sticky notes in the data book, Agile-DB provides it all in one place.
Cache
Detail
See
the state of the instruction and data cache along with percent
utilization
MMU
Detail of Memory Translation.
Use
the GUI to quickly set up new TLBS, Bats etc, to try MMU what-if
scenarios.
See the current state
Powerful
ICE Commands and Macros
Automate
JTAG access to your target system, create new commands using our
powerful C-like language
Guardian-SE fully
supports open source debuggers for JTAG debug.
Supports LINUX or
Windows and UNIX Host Systems
Use the development host you want to use, don't be forced to use what
the tool demands
Best of all, Guardian-SE works with standard
builds of all GDB based tools so they drop right in to your environment
to get you going fast.
JTAG Debugging with Agile-DB
The
Agile-DB JTAG
debugger is
a powerful on-chip JTAG debugger
for the
PowerPC,
XScale, ARM
and MIPS processor families. Agile-DB provides a new kind of
drag-and-drop GUI to the Guardian-SE JTAG Emulator allowing you to see
and control your target in a clean, consistant environment.
Agile-DB's
drag anything anywhere interface was designed to provide
maximum target detail and control in a clean, easy to understand
format. With Agile-DB you will always have the debug information you
need at your fingertips, when you need it most.
These
tools were designed from the ground
up to help you get your embedded product to market fast. Our JTAG debug
products
offer the following benefits:
• Supports LINUX or Windows Host Systems
(Solaris and others using GDB)
• Supports Board Bring-up
Through
Manufacturing Test
• Works With the Tools, Kernels and
Environments you use Today and in the Future
• Products to Meet Every Budget and Need
• Optimized for Resource Constrained PCs
• Turnkey FLASH Libraries
included for All Popular Devices
• Full MMU/TLB Support--Including LINUX.
• Tested with U-Boot
and Popular Embedded
LINUX Distributions
• One System Supports All Processor
Families
• Scales to
Support Muti-Processor Debug
• Complete Help System and User
Documentation
For addition information, please visit the Agile-DB
page.
|
|
