USBDM_API.h

Go to the documentation of this file.

 
#ifndef _USBDM_API_H_
#define _USBDM_API_H_
 
#if !defined(CPP_DLL_LOCAL)
   #ifdef _WIN32
      #define CPP_DLL_EXPORT __declspec(dllexport)
      #define CPP_DLL_IMPORT __declspec(dllimport)
      #define CPP_DLL_LOCAL
   #else
      #define CPP_DLL_EXPORT __attribute__ ((visibility ("default")))
      #define CPP_DLL_IMPORT __attribute__ ((visibility ("default")))
      #define CPP_DLL_LOCAL  __attribute__ ((visibility ("hidden")))
   #endif
#endif
 
//==================================================
#if defined __cplusplus
#define EXTERN_C  extern "C"
#else
#ifndef EXTERN_C
#define EXTERN_C
#endif
#endif
 
#if defined(WIN32)
   #if !defined (WINAPI)
      #ifdef __GNUC__
         #define WINAPI __attribute__((__stdcall__))
      #else
         #define WINAPI
      #endif
   #endif
#endif
 
#ifdef WIN32
   #ifdef USBDM_DLL_EXPORTS
      #define USBDM_API      EXTERN_C CPP_DLL_EXPORT WINAPI
      #define OSBDM_API_JM60 EXTERN_C CPP_DLL_EXPORT WINAPI
   #else
      #define USBDM_API      EXTERN_C CPP_DLL_IMPORT WINAPI
      #define OSBDM_API_JM60 EXTERN_C CPP_DLL_IMPORT WINAPI
   #endif
#else
   #ifdef USBDM_DLL_EXPORTS
      #define USBDM_API      EXTERN_C CPP_DLL_EXPORT
      #define OSBDM_API_JM60 EXTERN_C CPP_DLL_EXPORT
   #else
      #define USBDM_API      EXTERN_C CPP_DLL_IMPORT
      #define OSBDM_API_JM60 EXTERN_C CPP_DLL_IMPORT
   #endif
#endif
 
//==================================================
 
#include "USBDM_ErrorMessages.h"
#include <stdint.h>
#include <stdio.h>
 
#if defined __cplusplus
    extern "C" {
#else
#undef bool
#define bool char 
#endif
 
#define USBDM_API_VERSION (0x40A06)  // V4.10.6 (in hex xx.xx.xx)
 
typedef enum  {
   BDM_CAP_NONE         = (0),
   BDM_CAP_ALL          = (0xFFFF),
   BDM_CAP_HCS12        = (1<<0),   
   BDM_CAP_RS08         = (1<<1),   
   BDM_CAP_VDDCONTROL   = (1<<2),   
   BDM_CAP_VDDSENSE     = (1<<3),   
   BDM_CAP_CFVx         = (1<<4),   
   BDM_CAP_HCS08        = (1<<5),   
   BDM_CAP_CFV1         = (1<<6),   
   BDM_CAP_JTAG         = (1<<7),   
   BDM_CAP_DSC          = (1<<8),   
   BDM_CAP_ARM_JTAG     = (1<<9),   
   BDM_CAP_RST          = (1<<10),  
   BDM_CAP_PST          = (1<<11),  
   BDM_CAP_CDC          = (1<<12),  
   BDM_CAP_ARM_SWD      = (1<<13),  
   BDM_CAP_S12Z         = (1<<14),  
} HardwareCapabilities_t;
 
//==========================================================================================
// Targets and visible capabilities supported - related to above but not exactly!
// e.g. CAP_HCS12 => CAP_BDM+CAP_RST_IO
//      CAP_RS08  => CAP_BDM+CAP_FLASH(+CAP_RST_IO)
//      CAP_HCS08 => CAP_BDM(+CAP_RST_IO)
//      CAP_CFVx  => CAP_JTAG_HW+CAP_CFVx_HW+CAP_RST_IO
//      CAP_DSC   => CAP_JTAG_HW+CAP_RST_IO + s/w routines
//      CAP_JTAG  => CAP_JTAG_HW+CAP_RST_IO
//      CAP_ARM   => CAP_JTAG_HW+CAP_RST_IO
//      CAP_RST   => CAP_RST_IO
// TARGET_CAPABILITY
//
#define CAP_HCS12       (1<<0)      
#define CAP_RS08        (1<<1)      
#define CAP_VDDCONTROL  (1<<2)      
#define CAP_VDDSENSE    (1<<3)      
#define CAP_CFVx        (1<<4)          
#define CAP_HCS08       (1<<5)          
#define CAP_CFV1        (1<<6)          
#define CAP_JTAG        (1<<7)          
#define CAP_DSC         (1<<8)      
#define CAP_ARM_JTAG    (1<<9)      
#define CAP_RST         (1<<10)     
#define CAP_PST         (1<<11)     
#define CAP_CDC         (1<<12)     
#define CAP_ARM_SWD     (1<<13)     
 
//===================================================================================
typedef enum {
   T_HC12      = 0,       
   T_HCS12     = T_HC12,  
   T_HCS08     = 1,       
   T_RS08      = 2,       
   T_CFV1      = 3,       
   T_CFVx      = 4,       
   T_JTAG      = 5,       
   T_EZFLASH   = 6,       
   T_MC56F80xx = 7,       
   T_ARM_JTAG  = 8,       
   T_ARM_SWD   = 9,       
   T_ARM       = 10,      
   T_S12Z      = 11,      
   T_LAST      = T_S12Z,
   T_ILLEGAL   = 0xFE,    
   T_OFF       = 0xFF,    
   T_NONE      = 0xFF,
} TargetType_t;
 
typedef enum {
   // One of the following
   MS_Byte     = 1,        // Byte (8-bit) access
   MS_Word     = 2,        // Word (16-bit) access
   MS_Long     = 4,        // Long (32-bit) access
   // One of the following
   MS_None     = 0<<4,     // Memory space unused/undifferentiated
   MS_Program  = 1<<4,     // Program memory space (e.g. P: on DSC)
   MS_Data     = 2<<4,     // Data memory space (e.g. X: on DSC)
   MS_Global   = 3<<4,     // HCS12 Global addresses (Using BDMPPR register)
   // Fast memory access for HCS08/HCS12 (stopped target, regs. are modified
   MS_Fast     = 1<<7,
   // Masks for above
   MS_SIZE     = 0x7<<0,   // Size
   MS_SPACE    = 0x7<<4,   // Memory space
 
   // For convenience (DSC)
   MS_PWord    = MS_Word+MS_Program,
   MS_PLong    = MS_Long+MS_Program,
   MS_XByte    = MS_Byte+MS_Data,
   MS_XWord    = MS_Word+MS_Data,
   MS_XLong    = MS_Long+MS_Data,
} MemorySpace_t;
 
typedef enum {
   WAIT  = 0,   
   ACKN  = 1,   
} AcknMode_t;
 
typedef enum {
   SPEED_NO_INFO        = 0,   
   SPEED_SYNC           = 1,   
   SPEED_GUESSED        = 2,   
   SPEED_USER_SUPPLIED  = 3    
} SpeedMode_t;
 
typedef enum {
   RSTO_ACTIVE=0,     
   RSTO_INACTIVE=1    
} ResetState_t;
 
typedef enum {
   NO_RESET_ACTIVITY    = 0,   
   RESET_INACTIVE       = NO_RESET_ACTIVITY,
   RESET_DETECTED       = 1    
} ResetMode_t;
 
typedef enum {
   TARGET_RUNNING    = 0,   
   TARGET_HALTED     = 1    
} TargetRunState_t;
 
typedef enum  {
   BDM_TARGET_VDD_NONE      = 0,   
   BDM_TARGET_VDD_EXT       = 1,   
   BDM_TARGET_VDD_INT       = 2,   
   BDM_TARGET_VDD_ERR       = 3,   
} TargetVddState_t;
 
typedef enum  {
   AUTOCONNECT_NEVER   = 0,  
   AUTOCONNECT_STATUS  = 1,  
   AUTOCONNECT_ALWAYS  = 2,  
} AutoConnect_t;
 
//====================================================================================
 
typedef enum  {
   BDM_TARGET_VDD_OFF       = 0,     
   BDM_TARGET_VDD_3V3       = 1,     
   BDM_TARGET_VDD_5V        = 2,     
   BDM_TARGET_VDD_ENABLE    = 0x10,  
   BDM_TARGET_VDD_DISABLE   = 0x11,  
} TargetVddSelect_t;
 
typedef enum  {
   BDM_TARGET_VPP_OFF       = 0,   
   BDM_TARGET_VPP_STANDBY   = 1,   
   BDM_TARGET_VPP_ON        = 2,   
   BDM_TARGET_VPP_ERROR     = 3,   
} TargetVppSelect_t;
 
typedef enum {
   CS_DEFAULT           = 0xFF,  
   CS_ALT_CLK           =  0,    
   CS_NORMAL_CLK        =  1,    
} ClkSwValues_t;
 
typedef enum { /* type of reset action required */
   RESET_MODE_MASK       = (3<<0),  
   RESET_SPECIAL         = (0<<0),  
   RESET_NORMAL          = (1<<0),  
 
   RESET_METHOD_MASK     = (7<<2),  
   RESET_ALL             = (0<<2),  
   RESET_HARDWARE        = (1<<2),  
   RESET_SOFTWARE        = (2<<2),  
   RESET_POWER           = (3<<2),  
   RESET_VENDOR          = (4<<2),  
   RESET_DEFAULT         = (7<<2),  
} TargetMode_t;
 
//=======================================================================
//
// regNo Parameter values for USBDM_ReadReg()
//
//=======================================================================
 
typedef enum {
   HCS12_RegPC    = 3,    
   HCS12_RegD     = 4,    
   HCS12_RegX     = 5,    
   HCS12_RegY     = 6,    
   HCS12_RegSP    = 7,    
   HCS12_RegCCR   = 0x80, 
} HCS12_Registers_t;
 
typedef enum {
   S12Z_RegD0   = 0x0, 
   S12Z_RegD1   = 0x1, 
   S12Z_RegD2   = 0x2, 
   S12Z_RegD3   = 0x3, 
   S12Z_RegD4   = 0x4, 
   S12Z_RegD5   = 0x5, 
   S12Z_RegD6   = 0x6, 
   S12Z_RegD7   = 0x7, 
   S12Z_RegX    = 0x8, 
   S12Z_RegY    = 0x9, 
   S12Z_RegSP   = 0xA, 
   S12Z_RegPC   = 0xB, 
   S12Z_RegCCR  = 0xC, 
} S12Z_Registers_t;
 
typedef enum {
   HCS08_RegPC  = 0xB,  
   HCS08_RegSP  = 0xF,  
   HCS08_RegHX  = 0xC,  
   HCS08_RegA   = 8,    
   HCS08_RegCCR = 9,    
} HCS08_Registers_t;
 
typedef enum {
   RS08_RegCCR_PC  = 0xB, 
   RS08_RegSPC     = 0xF, 
   RS08_RegA       = 8,   
} RS08_Registers_t;
 
typedef enum {
   CFV1_RegD0     = 0,  
   CFV1_RegD1     = 1,  
   CFV1_RegD2     = 2,  
   CFV1_RegD3     = 3,  
   CFV1_RegD4     = 4,  
   CFV1_RegD5     = 5,  
   CFV1_RegD6     = 6,  
   CFV1_RegD7     = 7,  
   CFV1_RegA0     = 8,  
   CFV1_RegA1     = 9,  
   CFV1_RegA2     = 10, 
   CFV1_RegA3     = 11, 
   CFV1_RegA4     = 12, 
   CFV1_RegA5     = 13, 
   CFV1_RegA6     = 14, 
   CFV1_RegA7     = 15, 
   CFV1_RegSP     = CFV1_RegA7,
   CFV1_PSTBASE   = 16, 
   // The following are used internally by the BDM and only available
   // externally from firmware version 4.10.6
   // Takes advantage of the similarity b/w READ_Rn and READ_DREG
   CFV1_RegOTHER_A7  = 0xC0|0,  
   CFV1_RegVBR       = 0xC0|1,  
   CFV1_RegCPUCR     = 0xC0|2,  
   CFV1_RegMACSR     = 0xC0|4,  
   CFV1_RegMASK      = 0xC0|5,  
   CFV1_RegACC       = 0xC0|6,  
   CFV1_RegSR        = 0xC0|14, 
   CFV1_RegPC        = 0xC0|15, 
} CFV1_Registers_t;
 
typedef enum {
   CFVx_RegD0  = 0,  
   CFVx_RegD1  = 1,  
   CFVx_RegD2  = 2,  
   CFVx_RegD3  = 3,  
   CFVx_RegD4  = 4,  
   CFVx_RegD5  = 5,  
   CFVx_RegD6  = 6,  
   CFVx_RegD7  = 7,  
   CFVx_RegA0  = 8,  
   CFVx_RegA1  = 9,  
   CFVx_RegA2  = 10, 
   CFVx_RegA3  = 11, 
   CFVx_RegA4  = 12, 
   CFVx_RegA5  = 13, 
   CFVx_RegA6  = 14, 
   CFVx_RegA7  = 15, 
   CFVx_RegSP  = CFVx_RegA7,
} CFVx_Registers_t;
 
typedef enum {
   ARM_RegR0     = 0,    
   ARM_RegR1     = 1,    
   ARM_RegR2     = 2,    
   ARM_RegR3     = 3,    
   ARM_RegR4     = 4,    
   ARM_RegR5     = 5,    
   ARM_RegR6     = 6,    
   ARM_RegR7     = 7,    
   ARM_RegR8     = 8,    
   ARM_RegR9     = 9,    
   ARM_RegR10    = 10,   
   ARM_RegR11    = 11,   
   ARM_RegR12    = 12,   
   ARM_RegSP     = 13,   
   ARM_RegLR     = 14,   
   ARM_RegPC     = 15,   
   ARM_RegxPSR   = 16,   
   ARM_RegMSP    = 17,   
   ARM_RegPSP    = 18,   
   ARM_RegMISC   = 20,   
   //
   ARM_RegFPSCR  = 0x21, 
   ARM_RegFPS0   = 0x40, 
 
} ARM_Registers_t;
 
typedef enum {
   ARM_RegIndexFirstCore  = 0,                          
   ARM_RegIndexLastCore   = ARM_RegIndexFirstCore+19,   
   ARM_RegIndexFirstFloat = 20,                         
   ARM_RegIndexLastFloat  = ARM_RegIndexFirstFloat+32,  
} ARM_RegisterIndex_t;
 
typedef enum {
   CFV1_RegIndexFirstCore  = 0,                          
   CFV1_RegIndexLastCore   = CFV1_RegIndexFirstCore+17,  
} CFV1_RegisterIndex_t;
 
typedef enum {
   CFVx_RegIndexFirstCore  = 0,                          
   CFVx_RegIndexLastCore   = CFV1_RegIndexFirstCore+17,  
} CFVx_RegisterIndex_t;
 
typedef enum {
   // Core registers
   DSC_RegX0,
   DSC_FirstCoreRegister = DSC_RegX0,          // 0
   DSC_RegY0,
   DSC_RegY1,
   DSC_RegA0,
   DSC_RegA1,
   DSC_RegA2,
   DSC_RegB0,
   DSC_RegB1,
   DSC_RegB2,
   DSC_RegC0,
   DSC_RegC1,                                  // 10
   DSC_RegC2,
   DSC_RegD0,
   DSC_RegD1,
   DSC_RegD2,
   DSC_RegOMR,
   DSC_RegSR,
   DSC_RegLA,
   DSC_RegLA2, /* read only */
   DSC_RegLC,
   DSC_RegLC2, /* read only */                 //  20
   DSC_RegHWS0,
   DSC_RegHWS1,
   DSC_RegSP,
   DSC_RegN3,
   DSC_RegM01,
   DSC_RegN,
   DSC_RegR0,
   DSC_RegR1,
   DSC_RegR2,
   DSC_RegR3,                                  // 30
   DSC_RegR4,
   DSC_RegR5,
   DSC_RegsHM01,
   DSC_RegsHN,
   DSC_RegsHR0,
   DSC_RegsHR1,
   DSC_RegPC,
   DSC_LastCoreRegister = DSC_RegPC,           // 37
   // JTAG registers
   DSC_RegIDCODE,                              // JTAG Core IDCODE
   // ONCE registers
   DSC_RegOCR,                                 // ONCE Control register
   DSC_FirstONCERegister = DSC_RegOCR,         // 39
   DSC_RegOSCNTR,                              // ONCE Instruction Step Counter
   DSC_RegOSR,                                 // ONCE Status register
   DSC_RegOPDBR,                               // ONCE Program Data Bus Register
   DSC_RegOBASE,                               // ONCE Peripheral Base Address regitsre
   DSC_RegOTXRXSR,                             // ONCE Tx & Rx Status & Control register
   DSC_RegOTX,                                 // ONCE Transmit register (32-bit)
   DSC_RegOTX1,                                // ONCE Transmit register (16-bit)
   DSC_RegORX,                                 // ONCE Receive register (32-bit)
   DSC_RegORX1,                                // ONCE Receive register (16-bit)
   DSC_RegOTBCR,                               // ONCE Trace buffer control register
   DSC_RegOTBPR,                               // ONCE Trace Buffer Pointer register
   DSC_RegOTB,                                 // Trace Buffer Register Stages
   DSC_RegOB0CR,                               // Breakpoint Unit 0 Control register
   DSC_RegOB0AR1,                              // Breakpoint Unit 0 Address register 1
   DSC_RegOB0AR2,                              // Breakpoint Unit 0 Address register 2
   DSC_RegOB0MSK,                              // Breakpoint Unit 0 Mask register
   DSC_RegOB0CNTR,                             // Breakpoint Unit 0 Counter
   DSC_LastONCERegister = DSC_RegOB0CNTR,      // 58
 
   DSC_GdiStatus = 0x1001,                     // Used by stand-alone programmer - dummied
   DSC_UnknownReg = 0xFFFFFF,
} DSC_Registers_t;
 
//=======================================================================
//
// regNo Parameter values for USBDM_ReadCReg()
//
//=======================================================================
 
typedef enum {
   CFV1_CRegOTHER_A7  = 0,  
   CFV1_CRegVBR       = 1,  
   CFV1_CRegCPUCR     = 2,  
   CFV1_CRegMACSR     = 4,  
   CFV1_CRegMASK      = 5,  
   CFV1_CRegACC       = 6,  
   CFV1_CRegSR        = 14, 
   CFV1_CRegPC        = 15, 
} CFV1_CRegisters_t;
 
typedef enum {
   CFVx_CRegD0        = 0x80, 
   CFVx_CRegD1,
   CFVx_CRegD2,
   CFVx_CRegD3,
   CFVx_CRegD4,
   CFVx_CRegD5,
   CFVx_CRegD6,
   CFVx_CRegD7,
   CFVx_CRegA0,               
   CFVx_CRegA1,
   CFVx_CRegA2,
   CFVx_CRegA3,
   CFVx_CRegA4,
   CFVx_CRegA5,
   CFVx_CRegA6,
   CFVx_CRegUSER_SP,
   CFVx_CRegOTHER_SP  = 0x800, 
   CFVx_CRegVBR       = 0x801, 
   CFVx_CRegSR        = 0x80E, 
   CFVx_CRegPC        = 0x80F, 
   CFV1_CRegFLASHBAR  = 0xC04, 
   CFV1_CRegRAMBAR    = 0xC05, 
   // May be others
} CFVx_CRegisters_t;
 
typedef enum {
   // AP#0 - Common ARM AHB-AP
   ARM_CRegAHB_AP_CSW      = 0x00000000U,   
   ARM_CRegAHB_AP_TAR      = 0x00000004U,   
   ARM_CRegAHB_AP_DRW      = 0x0000000CU,   
 
   ARM_CRegAHB_AP_CFG      = 0x000000F4U,   
   ARM_CRegAHB_AP_Base     = 0x000000F8U,   
   ARM_CRegAHB_AP_Id       = 0x000000FCU,   
 
   // AP#1 - Kinetis MDM-AP registers
   ARM_CRegMDM_AP_Status   = 0x01000000U,   
   ARM_CRegMDM_AP_Control  = 0x01000004U,   
   ARM_CRegMDM_AP_Ident    = 0x010000FCU,   
} ARM_CRegisters_t;
 
//=======================================================================
//
// regNo Parameter values for USBDM_ReadDReg()
//
//=======================================================================
 
typedef enum {
   // 8-bit accesses using READ_BD_BYTE
   HCS12_DRegBDMSTS = (int)0xFF01, 
   HCS12_DRegCCR    = (int)0xFF06, 
   HCS12_DRegBDMINR = (int)0xFF07, 
   // Others may be device dependent
} HCS12_DRegisters_t;
 
typedef enum {
   HCS08_DRegBKPT = 0x0, 
} HCS08_DRegisters_t;
 
typedef enum {
   RS08_DRegBKPT = 0x0, 
} RS08_DRegisters_t;
 
typedef enum {
   CFV1_DRegCSR        = 0x00,   
   CFV1_DRegXCSR       = 0x01,   
   CFV1_DRegCSR2       = 0x02,   
   CFV1_DRegCSR3       = 0x03,   
   CFV1_DRegBAAR       = 0x05,   
   CFV1_DRegAATR       = 0x06,   
   CFV1_DRegTDR        = 0x07,   
   CFV1_DRegPBR0       = 0x08,   
   CFV1_DRegPBMR       = 0x09,   
   CFV1_DRegABHR       = 0x0C,   
   CFV1_DRegABLR       = 0x0D,   
   CFV1_DRegDBR        = 0x0E,   
   CFV1_DRegBDMR       = 0x0F,   
   CFV1_DRegPBR1       = 0x18,   
   CFV1_DRegPBR2       = 0x1A,   
   CFV1_DRegPBR3       = 0x1B,   
 
   CFV1_ByteRegs       = 0x1000, 
   CFV1_DRegXCSRbyte   = CFV1_ByteRegs+CFV1_DRegXCSR, 
   CFV1_DRegCSR2byte   = CFV1_ByteRegs+CFV1_DRegCSR2, 
   CFV1_DRegCSR3byte   = CFV1_ByteRegs+CFV1_DRegCSR3, 
} CFV1_DRegisters_t;
 
typedef enum {
   CFVx_DRegCSR    = 0x00, 
   CFVx_DRegBAAR   = 0x05, 
   CFVx_DRegAATR   = 0x06, 
   CFVx_DRegTDR    = 0x07, 
   CFVx_DRegPBR0   = 0x08, 
   CFVx_DRegPBMR   = 0x09, 
   CFVx_DRegABHR   = 0x0C, 
   CFVx_DRegABLR   = 0x0D, 
   CFVx_DRegDBR    = 0x0E, 
   CFVx_DRegBDMR   = 0x0F, 
   CFVx_DRegPBR1   = 0x18, 
   CFVx_DRegPBR2   = 0x1A, 
   CFVx_DRegPBR3   = 0x1B, 
} CFVx_DRegisters_t;
 
typedef enum {
   ARM_DRegIDCODE  = 0,    
   ARM_DRegABORT   = 0,    
   ARM_DRegSTATUS  = 1,    
   ARM_DRegCONTROL = 1,    
   ARM_DRegRESEND  = 2,    
   ARM_DRegSELECT  = 2,    
   ARM_DRegRDBUFF  = 3,    
 
   ARM_DRegAPReg0  = 4,    
   ARM_DRegAPReg1  = 5,    
   ARM_DRegAPReg2  = 6,    
   ARM_DRegAPReg3  = 7,    
} ARM_DRegisters_t;
 
//=======================================================================
//
//=======================================================================
 
 
typedef struct {
   TargetType_t         target_type;       
   AcknMode_t           ackn_state;        
   SpeedMode_t          connection_state;  
   ResetState_t         reset_state;       
   ResetMode_t          reset_recent;      
   TargetRunState_t     halt_state;        
   TargetVddState_t     power_state;       
   TargetVppSelect_t    flash_state;       
} USBDMStatus_t;
 
//=======================================================================
//
//  JTAG Interface
//
//=======================================================================
 
typedef enum {
   JTAG_STAY_SHIFT       = 0,     
   JTAG_EXIT_IDLE        = 1,     
   JTAG_EXIT_SHIFT_DR    = 2,     
   JTAG_EXIT_SHIFT_IR    = 3,     
   JTAG_EXIT_ACTION_MASK = 0x3,   
 
   JTAG_WRITE_0          = 0x00,  
   JTAG_WRITE_1          = 0x80,  
   JTAG_WRITE_MASK       = 0x80,  
 
   JTAG_SHIFT_DR         = 0,     
   JTAG_SHIFT_IR         = 1,     
} JTAG_ExitActions_t;
 
 
typedef enum {
   PIN_BKGD_OFFS      = (0),
   PIN_BKGD           = (3<<PIN_BKGD_OFFS),  
   PIN_BKGD_NC        = (0<<PIN_BKGD_OFFS),  
   PIN_BKGD_3STATE    = (1<<PIN_BKGD_OFFS),  
   PIN_BKGD_LOW       = (2<<PIN_BKGD_OFFS),  
   PIN_BKGD_HIGH      = (3<<PIN_BKGD_OFFS),  
 
   PIN_RESET_OFFS     = (2),
   PIN_RESET          = (3<<PIN_RESET_OFFS), 
   PIN_RESET_NC       = (0<<PIN_RESET_OFFS), 
   PIN_RESET_3STATE   = (1<<PIN_RESET_OFFS), 
   PIN_RESET_LOW      = (2<<PIN_RESET_OFFS), 
   PIN_RESET_HIGH     = (3<<PIN_RESET_OFFS), 
 
   PIN_TA_OFFS        = (4),
   PIN_TA             = (3<<PIN_TA_OFFS),    
   PIN_TA_NC          = (0<<PIN_TA_OFFS),    
   PIN_TA_3STATE      = (1<<PIN_TA_OFFS),    
   PIN_TA_LOW         = (2<<PIN_TA_OFFS),    
 
   PIN_DE_OFFS        = (4),
   PIN_DE             = (3<<PIN_DE_OFFS),    
   PIN_DE_NC          = (0<<PIN_DE_OFFS),    
   PIN_DE_3STATE      = (1<<PIN_DE_OFFS),    
   PIN_DE_LOW         = (2<<PIN_DE_OFFS),    
 
   PIN_TRST_OFFS      = (6),
   PIN_TRST           = (3<<PIN_TRST_OFFS),  
   PIN_TRST_NC        = (0<<PIN_TRST_OFFS),  
   PIN_TRST_3STATE    = (1<<PIN_TRST_OFFS),  
   PIN_TRST_LOW       = (2<<PIN_TRST_OFFS),  
 
   PIN_BKPT_OFFS      = (8),
   PIN_BKPT           = (3<<PIN_BKPT_OFFS),  
   PIN_BKPT_NC        = (0<<PIN_BKPT_OFFS),  
   PIN_BKPT_3STATE    = (1<<PIN_BKPT_OFFS),  
   PIN_BKPT_LOW       = (2<<PIN_BKPT_OFFS),  
 
   PIN_SWD_OFFS       = (10),
   PIN_SWD            = (3<<PIN_SWD_OFFS),   
   PIN_SWD_NC         = (0<<PIN_SWD_OFFS),   
   PIN_SWD_3STATE     = (1<<PIN_SWD_OFFS),   
   PIN_SWD_LOW        = (2<<PIN_SWD_OFFS),   
   PIN_SWD_HIGH       = (3<<PIN_SWD_OFFS),   
 
   PIN_SWCLK_OFFS     = (12),
   PIN_SWCLK          = (3<<PIN_SWCLK_OFFS),   
   PIN_SWCLK_NC       = (0<<PIN_SWCLK_OFFS),   
   PIN_SWCLK_3STATE   = (1<<PIN_SWCLK_OFFS),   
   PIN_SWCLK_LOW      = (2<<PIN_SWCLK_OFFS),   
   PIN_SWCLK_HIGH     = (3<<PIN_SWCLK_OFFS),   
 
   PIN_NOCHANGE       = 0,    
   PIN_RELEASE        = -1,   
} PinLevelMasks_t ;
 
typedef struct {
   // Options passed to the BDM
   int  targetVdd;                
   int  cycleVddOnReset;          
   int  cycleVddOnConnect;        
   int  leaveTargetPowered;       
   int  autoReconnect;            
   int  guessSpeed;               
   int  useAltBDMClock;           
   int  useResetSignal;           
   int  maskInterrupts;           
   int  reserved1[2];             
 
   // Options used internally by DLL
   int  manuallyCycleVdd;         
   int  derivative_type;          
   int  interfaceSpeed;           
   int  miscOptions;              
   int  usePSTSignals;            
   int  reserved2[2];             
} BDM_Options_t;
 
typedef struct {
   // Options passed to the BDM
   unsigned           size;                       
   TargetType_t       targetType;                 
   TargetVddSelect_t  targetVdd;                  
   bool               cycleVddOnReset;            
   bool               cycleVddOnConnect;          
   bool               leaveTargetPowered;         
   AutoConnect_t      autoReconnect;              
   bool               guessSpeed;                 
   ClkSwValues_t      bdmClockSource;             
   bool               useResetSignal;             
   bool               maskInterrupts;             
   unsigned           interfaceFrequency;         
   bool               usePSTSignals;              
   unsigned           powerOffDuration;           
   unsigned           powerOnRecoveryInterval;    
   unsigned           resetDuration;              
   unsigned           resetReleaseInterval;       
   unsigned           resetRecoveryInterval;      
   unsigned           hcs08sbdfrAddress;          
} USBDM_ExtendedOptions_t;
 
typedef struct {
   unsigned char bdmSoftwareVersion; 
   unsigned char bdmHardwareVersion; 
   unsigned char icpSoftwareVersion; 
   unsigned char icpHardwareVersion; 
} USBDM_Version_t;
 
typedef struct {
   unsigned                size;                 
   int                     BDMsoftwareVersion;   
   int                     BDMhardwareVersion;   
   int                     ICPsoftwareVersion;   
   int                     ICPhardwareVersion;   
   HardwareCapabilities_t  capabilities;         
   unsigned                commandBufferSize;    
   unsigned                jtagBufferSize;       
} USBDM_bdmInformation_t;
 
// The following functions are available when in BDM mode
//====================================================================
//
USBDM_API
USBDM_ErrorCode USBDM_Init(void);
USBDM_API
USBDM_ErrorCode USBDM_Exit(void);
 
USBDM_API
unsigned int USBDM_DLLVersion(void);
 
USBDM_API
const char *USBDM_DLLVersionString(void);
 
USBDM_API
const char *USBDM_GetErrorString(USBDM_ErrorCode errorCode);
 
//=============================================================================
//=============================================================================
//=============================================================================
// USBDM Device handling
 
USBDM_API
USBDM_ErrorCode  USBDM_FindDevices(unsigned int *deviceCount);
 
USBDM_API
USBDM_ErrorCode  USBDM_ReleaseDevices(void);
 
USBDM_API
USBDM_ErrorCode  USBDM_GetBDMSerialNumber(const char **deviceSerialNumber);
 
USBDM_API
USBDM_ErrorCode  USBDM_GetBDMDescription(const char **deviceDescription);
 
USBDM_API
USBDM_ErrorCode  USBDM_Open(unsigned char deviceNo);
 
USBDM_API
USBDM_ErrorCode  USBDM_Close(void);
 
USBDM_API
USBDM_ErrorCode USBDM_GetVersion(USBDM_Version_t *version);
 
USBDM_API
USBDM_ErrorCode  USBDM_GetCapabilities(HardwareCapabilities_t *capabilities);
 
USBDM_API
USBDM_ErrorCode USBDM_GetBdmInformation(USBDM_bdmInformation_t *info);
 
USBDM_API
USBDM_ErrorCode  USBDM_SetOptions(BDM_Options_t *newBdmOptions);
 
USBDM_API
USBDM_ErrorCode USBDM_GetDefaultExtendedOptions(USBDM_ExtendedOptions_t *bdmOptions);
 
USBDM_API
USBDM_ErrorCode USBDM_SetExtendedOptions(const USBDM_ExtendedOptions_t *newBdmOptions);
 
USBDM_API
USBDM_ErrorCode USBDM_GetExtendedOptions(USBDM_ExtendedOptions_t *currentBdmOptions);
 
USBDM_API
USBDM_ErrorCode  USBDM_SetTargetVdd(TargetVddSelect_t targetVdd);
 
USBDM_API
USBDM_ErrorCode  USBDM_SetTargetVpp(TargetVppSelect_t targetVpp);
 
#if defined __cplusplus
USBDM_API
USBDM_ErrorCode USBDM_ControlPins(unsigned int control, unsigned int *status=0);
#else
USBDM_API
USBDM_ErrorCode USBDM_ControlPins(unsigned int control, unsigned int *status);
#endif
//=============================================================================
//=============================================================================
//=============================================================================
// Target handling
 
USBDM_API
USBDM_ErrorCode USBDM_SetTargetType(TargetType_t targetType);
 
USBDM_API
USBDM_ErrorCode  USBDM_Debug(unsigned char *usb_data);
 
USBDM_API
USBDM_ErrorCode USBDM_BDMCommand(unsigned int txSize, unsigned int rxSize, unsigned char data[]);
 
USBDM_API
USBDM_ErrorCode USBDM_GetCommandStatus(void);
 
USBDM_API
USBDM_ErrorCode  USBDM_GetBDMStatus(USBDMStatus_t *USBDMStatus);
 
USBDM_API
USBDM_ErrorCode  USBDM_Connect(void);
 
USBDM_API
USBDM_ErrorCode USBDM_BasicConnect(void);
 
USBDM_API
USBDM_ErrorCode  USBDM_SetSpeed( unsigned long frequency);
 
USBDM_API
USBDM_ErrorCode  USBDM_GetSpeed(unsigned long *frequency /* kHz */);
 
USBDM_API
USBDM_ErrorCode  USBDM_GetSpeedHz(unsigned long *frequency /* Hz */);
 
USBDM_API
USBDM_ErrorCode  USBDM_ReadStatusReg(unsigned long *BDMStatusReg);
 
USBDM_API
USBDM_ErrorCode  USBDM_WriteControlReg(unsigned int value);
 
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
// Target run control
 
USBDM_API
USBDM_ErrorCode  USBDM_TargetReset(TargetMode_t target_mode);
 
USBDM_API
USBDM_ErrorCode  USBDM_TargetStep(void);
 
USBDM_API
USBDM_ErrorCode  USBDM_TargetGo(void);
 
USBDM_API
USBDM_ErrorCode  USBDM_TargetHalt(void);
 
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
// Target register Read/Write
 
USBDM_API
USBDM_ErrorCode USBDM_WriteReg(unsigned int regNo, unsigned long regValue);
 
USBDM_API
USBDM_ErrorCode USBDM_ReadReg(unsigned int regNo, unsigned long *regValue);
 
USBDM_API
USBDM_ErrorCode USBDM_ReadMultipleRegs(unsigned char regValueBuffer[], unsigned int startRegIndex, unsigned int endRegIndex);
 
USBDM_API
USBDM_ErrorCode USBDM_WriteCReg(unsigned int regNo, unsigned long regValue);
 
USBDM_API
USBDM_ErrorCode USBDM_ReadCReg(unsigned int regNo, unsigned long *regValue);
 
USBDM_API
USBDM_ErrorCode USBDM_WriteDReg(unsigned int regNo, unsigned long regValue);
 
USBDM_API
USBDM_ErrorCode USBDM_ReadDReg(unsigned int regNo, unsigned long *regValue);
 
USBDM_API
USBDM_ErrorCode USBDM_WriteMemory( unsigned int        memorySpace,
                                   unsigned int        byteCount,
                                   unsigned int        address,
                                   unsigned const char *data);
 
USBDM_API
USBDM_ErrorCode USBDM_ReadMemory( unsigned int  memorySpace,
                                  unsigned int  byteCount,
                                  unsigned int  address,
                                  unsigned char *data);
 
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
// JTAG Entry points
//
 
USBDM_API
USBDM_ErrorCode  USBDM_JTAG_Reset(void);
 
USBDM_API
USBDM_ErrorCode  USBDM_JTAG_SelectShift(unsigned char mode);
 
USBDM_API
USBDM_ErrorCode USBDM_JTAG_Write(unsigned char       bitCount,
                                 unsigned char       exit,
                                 const unsigned char *buffer);
 
USBDM_API
USBDM_ErrorCode USBDM_JTAG_Read( unsigned char bitCount,
                                 unsigned char exit,
                                 unsigned char *buffer);
 
USBDM_API
USBDM_ErrorCode USBDM_JTAG_ReadWrite( unsigned char bitCount,
                                      unsigned char exit,
                                      const unsigned char *outBuffer,
                                      unsigned char *inBuffer);
 
USBDM_API
USBDM_ErrorCode USBDM_JTAG_ExecuteSequence(unsigned char       length,
                                           const unsigned char *sequence,
                                           unsigned char       inLength,
                                           unsigned char       *inBuffer);
 
//=====================================================================================================
// Logging
 
USBDM_API
FILE *USBDM_GetLogFile(void);
 
USBDM_API
void USBDM_SetLogFile(FILE *fp);
 
//=====================================================================================================
// ICP functions
 
USBDM_API
void USBDM_RebootToICP(void);
 
//
// The following functions are available in ICP mode only
//
 
USBDM_API
USBDM_ErrorCode  USBDM_ICP_Erase( unsigned int addr,
                                  unsigned int count);
 
USBDM_API
USBDM_ErrorCode  USBDM_ICP_Program( unsigned int  addr,
                                    unsigned int  count,
                                    unsigned char *data);
 
USBDM_API
USBDM_ErrorCode  USBDM_ICP_Verify( unsigned int  addr,
                                   unsigned int  count,
                                   unsigned char *data);
 
USBDM_API
void USBDM_ICP_Reboot( void );
 
#ifdef __cplusplus
// Only available to C++
 
class ProgressDialogue;
 
//====================================================================
USBDM_API
void USBDM_ICP_SetCallback(ProgressDialogue *icpCallBack);
 
#ifdef COMMANDLINE
void dll_initialize(HINSTANCE _hDLLInst);
void dll_uninitialize(void);
#endif // COMMANDLINE
#endif //__cplusplus
 
#if defined __cplusplus
    }
#endif
 
#endif //_USBDM_API_H_