//
// Get info about the flash
//
// Override this function to return differnt values
//
public virtual FlashConsts.FlashInfo getFlashInfo()
{
Core.Memory.MemoryRegion boot_region = this.target.getMemoryMap().getBootMemory();
FlashConsts.FlashInfo info = new FlashConsts.FlashInfo
{
rom_start = boot_region != null ? boot_region.start : 0,
erase_weight = FlashConsts.DEFAULT_CHIP_ERASE_WEIGHT,
crc_supported = (bool)this.flash_algo["analyzer_supported"]
};
return(info);
}
//
// Get info about the page that contains this address
//
// Override this function if variable page sizes are supported
//
public virtual FlashConsts.PageInfo getPageInfo(UInt32 addr)
{
Core.Memory.MemoryRegion region = this.target.getMemoryMap().getRegionForAddress(addr);
if (region == null)
{
return(null);
}
FlashConsts.PageInfo info = new FlashConsts.PageInfo
{
erase_weight = FlashConsts.DEFAULT_PAGE_ERASE_WEIGHT,
program_weight = FlashConsts.DEFAULT_PAGE_PROGRAM_WEIGHT,
size = region.blocksize
};
info.base_addr = addr - addr % info.size;
return(info);
}
// Set a hardware or software breakpoint at a specific location in memory.
//
// @retval True Breakpoint was set.
// @retval False Breakpoint could not be set.
public virtual bool set_breakpoint(UInt32 addr, EBreakpointType type = EBreakpointType.BREAKPOINT_AUTO)
{
Trace.TraceInformation("set bkpt type {0} at 0x{1:x}", type, addr);
// Clear Thumb bit in case it is set.
addr = (UInt32)(addr & ~1);
var in_hw_bkpt_range = addr < 0x20000000;
var fbp_available = this._fpb != null && this._fpb.available_breakpoints() > 0;
var fbp_below_min = this._fpb == null || this._fpb.available_breakpoints() <= MIN_HW_BREAKPOINTS;
// Check for an existing breakpoint at this address.
Provider.Breakpoint bp = this.find_breakpoint(addr);
if (bp != null)
{
return(true);
}
bool is_flash;
bool is_ram;
if (this._core.memory_map == null)
{
// No memory map - fallback to hardware breakpoints.
type = EBreakpointType.BREAKPOINT_HW;
is_flash = false;
is_ram = false;
}
else
{
// Look up the memory type for the requested address.
Core.Memory.MemoryRegion region = this._core.memory_map.getRegionForAddress(addr);
if (region != null)
{
is_flash = region.isFlash;
is_ram = region.isRam;
}
else
{
// No memory region - fallback to hardware breakpoints.
type = EBreakpointType.BREAKPOINT_HW;
is_flash = false;
is_ram = false;
}
}
// Determine best type to use if auto.
if (type == EBreakpointType.BREAKPOINT_AUTO)
{
// Use sw breaks for:
// 1. Addresses outside the supported FPBv1 range of 0-0x1fffffff
// 2. RAM regions by default.
// 3. Number of remaining hw breaks are at or less than the minimum we want to keep.
//
// Otherwise use hw.
if ((!in_hw_bkpt_range) || is_ram || fbp_below_min)
{
type = EBreakpointType.BREAKPOINT_SW;
}
else
{
type = EBreakpointType.BREAKPOINT_HW;
}
Trace.TraceInformation("using type {0} for auto bp", type);
}
// Revert to sw bp if out of hardware breakpoint range.
if (type == EBreakpointType.BREAKPOINT_HW && !in_hw_bkpt_range)
{
if (is_ram)
{
Trace.TraceInformation("using sw bp instead because of unsupported addr");
type = EBreakpointType.BREAKPOINT_SW;
}
else
{
Trace.TraceInformation("could not fallback to software breakpoint");
return(false);
}
}
// Revert to hw bp if region is flash.
if (is_flash)
{
if (in_hw_bkpt_range && fbp_available)
{
Trace.TraceInformation("using hw bp instead because addr is flash");
type = EBreakpointType.BREAKPOINT_HW;
}
else
{
Trace.TraceInformation("could not fallback to hardware breakpoint");
return(false);
}
}
// Set the bp.
try
{
var provider = this._providers[type];
bp = provider.set_breakpoint(addr);
}
catch (KeyNotFoundException)
{
throw new Exception(String.Format("Unknown breakpoint type {0}", type));
}
if (bp == null)
{
return(false);
}
// Save the bp.
this._breakpoints[addr] = bp;
return(true);
}
