TX51 pre-release
[karo-tx-redboot.git] / packages / hal / common / v2_0 / include / hal_if.h
index 2ce2b44..b554fc0 100644 (file)
 //              combination of libbsp and vectors already in use by some
 //              eCos platforms.
 // Usage:       #include <cyg/hal/hal_if.h>
-//                           
+//
 //####DESCRIPTIONEND####
 //
 //=============================================================================
 
-#include <cyg/infra/cyg_type.h>         // types & externC
+#include <cyg/infra/cyg_type.h>                        // types & externC
 #include <cyg/hal/dbg-threads-api.h>
 #include <cyg/hal/dbg-thread-syscall.h>
 
 // and eCos share facilities, e.g. the network hardware.
 #if defined (CYGPKG_NET) || defined (CYGPKG_NET_LWIP)
 #include <cyg/hal/hal_intr.h>
-#include <cyg/hal/drv_api.h>            // cyg_drv_dsr_lock(), etc
-#define _ENTER_MONITOR()                        \
-    cyg_uint32 ints;                            \
-    HAL_DISABLE_INTERRUPTS(ints);               \
-    cyg_drv_dsr_lock()
-
-#define _EXIT_MONITOR()                         \
-    cyg_drv_dsr_unlock();                       \
-    HAL_RESTORE_INTERRUPTS(ints)
+#include <cyg/hal/drv_api.h>                   // cyg_drv_dsr_lock(), etc
+#define _ENTER_MONITOR()                                               \
+       cyg_uint32 ints;                                                        \
+       HAL_DISABLE_INTERRUPTS(ints);                           \
+       cyg_drv_dsr_lock()
+
+#define _EXIT_MONITOR()                                                        \
+       cyg_drv_dsr_unlock();                                           \
+       HAL_RESTORE_INTERRUPTS(ints)
 #else // !CYGPKG_NET && !CYGPKG_NET_LWIP
 #define _ENTER_MONITOR() CYG_EMPTY_STATEMENT
 #define _EXIT_MONITOR()  CYG_EMPTY_STATEMENT
@@ -98,81 +98,81 @@ typedef int (*bsp_handler_t)(int __irq_nr, void *__regs);
 // of this table.
 
 typedef enum {
-    /*
-     * For serial ports, the control function may be used to set and get the
-     * current baud rate. Usage:
-     * 
-     *   err = (*__control)(COMMCTL_SETBAUD, int bits_per_second);
-     *     err => Zero if successful, -1 if error.
-     *
-     *   baud = (*__control)(COMMCTL_GETBAUD);
-     *     baud => -1 if error, current baud otherwise.
-     */
-    __COMMCTL_SETBAUD=0,
-    __COMMCTL_GETBAUD,
-
-    /*
-     * Install and remove debugger interrupt handlers. These are the receiver
-     * interrupt routines which are used to change control from a running
-     * program to the debugger stub.
-     */
-    __COMMCTL_INSTALL_DBG_ISR,
-    __COMMCTL_REMOVE_DBG_ISR,
-
-    /*
-     * Disable comm port interrupt. Returns TRUE if interrupt was enabled,
-     * FALSE otherwise.
-     */
-    __COMMCTL_IRQ_DISABLE,
-
-    /*
-     * Enable comm port interrupt.
-     */
-    __COMMCTL_IRQ_ENABLE,
-
-    /*
-     * Returns the number of the interrupt vector used by the debug
-     * interrupt handler.
-     */
-    __COMMCTL_DBG_ISR_VECTOR,
-
-    /*
-     * Returns the current timeout value and sets a new timeout.
-     * Timeout resolution is in milliseconds.
-     *   old_timeout = (*__control)(__COMMCTL_SET_TIMEOUT, 
-     *                              cyg_int32 new_timeout);
-     */
-    __COMMCTL_SET_TIMEOUT,
-
-    /*
-     * Forces driver to send all characters which may be buffered in
-     * the driver. This only flushes the driver buffers, not necessarily
-     * any hardware FIFO, etc.
-     */
-    __COMMCTL_FLUSH_OUTPUT,
-
-    /*
-     * Forces driver to enable or disable flushes when a newline is
-     * seen in the output stream. Flushing at line boundaries occurs
-     * in the driver, not necessarily any hardware FIFO, etc. Line
-     * buffering is optional and may only be available in some drivers.
-     */
-    __COMMCTL_ENABLE_LINE_FLUSH,
-    __COMMCTL_DISABLE_LINE_FLUSH,
+       /*
+        * For serial ports, the control function may be used to set and get the
+        * current baud rate. Usage:
+        *
+        *   err = (*__control)(COMMCTL_SETBAUD, int bits_per_second);
+        *     err => Zero if successful, -1 if error.
+        *
+        *   baud = (*__control)(COMMCTL_GETBAUD);
+        *     baud => -1 if error, current baud otherwise.
+        */
+       __COMMCTL_SETBAUD=0,
+       __COMMCTL_GETBAUD,
+
+       /*
+        * Install and remove debugger interrupt handlers. These are the receiver
+        * interrupt routines which are used to change control from a running
+        * program to the debugger stub.
+        */
+       __COMMCTL_INSTALL_DBG_ISR,
+       __COMMCTL_REMOVE_DBG_ISR,
+
+       /*
+        * Disable comm port interrupt. Returns TRUE if interrupt was enabled,
+        * FALSE otherwise.
+        */
+       __COMMCTL_IRQ_DISABLE,
+
+       /*
+        * Enable comm port interrupt.
+        */
+       __COMMCTL_IRQ_ENABLE,
+
+       /*
+        * Returns the number of the interrupt vector used by the debug
+        * interrupt handler.
+        */
+       __COMMCTL_DBG_ISR_VECTOR,
+
+       /*
+        * Returns the current timeout value and sets a new timeout.
+        * Timeout resolution is in milliseconds.
+        *   old_timeout = (*__control)(__COMMCTL_SET_TIMEOUT,
+        *                              cyg_int32 new_timeout);
+        */
+       __COMMCTL_SET_TIMEOUT,
+
+       /*
+        * Forces driver to send all characters which may be buffered in
+        * the driver. This only flushes the driver buffers, not necessarily
+        * any hardware FIFO, etc.
+        */
+       __COMMCTL_FLUSH_OUTPUT,
+
+       /*
+        * Forces driver to enable or disable flushes when a newline is
+        * seen in the output stream. Flushing at line boundaries occurs
+        * in the driver, not necessarily any hardware FIFO, etc. Line
+        * buffering is optional and may only be available in some drivers.
+        */
+       __COMMCTL_ENABLE_LINE_FLUSH,
+       __COMMCTL_DISABLE_LINE_FLUSH,
 
 } __comm_control_cmd_t;
 
 
-#define CYGNUM_COMM_IF_CH_DATA                    0
-#define CYGNUM_COMM_IF_WRITE                      1
-#define CYGNUM_COMM_IF_READ                       2
-#define CYGNUM_COMM_IF_PUTC                       3
-#define CYGNUM_COMM_IF_GETC                       4
-#define CYGNUM_COMM_IF_CONTROL                    5
-#define CYGNUM_COMM_IF_DBG_ISR                    6
-#define CYGNUM_COMM_IF_GETC_TIMEOUT               7
+#define CYGNUM_COMM_IF_CH_DATA                                   0
+#define CYGNUM_COMM_IF_WRITE                                     1
+#define CYGNUM_COMM_IF_READ                                              2
+#define CYGNUM_COMM_IF_PUTC                                              3
+#define CYGNUM_COMM_IF_GETC                                              4
+#define CYGNUM_COMM_IF_CONTROL                                   5
+#define CYGNUM_COMM_IF_DBG_ISR                                   6
+#define CYGNUM_COMM_IF_GETC_TIMEOUT                              7
 
-#define CYGNUM_COMM_IF_TABLE_SIZE                 8
+#define CYGNUM_COMM_IF_TABLE_SIZE                                8
 
 typedef volatile CYG_ADDRWORD hal_virtual_comm_table_t[CYGNUM_COMM_IF_TABLE_SIZE];
 
@@ -183,104 +183,104 @@ typedef volatile CYG_ADDRWORD hal_virtual_comm_table_t[CYGNUM_COMM_IF_TABLE_SIZE
 
 typedef void* __comm_if_ch_data_t;
 typedef void (*__comm_if_write_t)(void* __ch_data, const cyg_uint8* __buf,
-                                  cyg_uint32 __len);
+                                                               cyg_uint32 __len);
 typedef int (*__comm_if_read_t)(void* __ch_data, cyg_uint8* __buf,
-                                cyg_uint32 __len);
+                                                               cyg_uint32 __len);
 typedef void (*__comm_if_putc_t)(void* __ch_data, cyg_uint8 __ch);
 typedef cyg_uint8 (*__comm_if_getc_t)(void* __ch_data);
-typedef int (*__comm_if_control_t)(void *__ch_data, 
-                                   __comm_control_cmd_t __func, ...);
-typedef int (*__comm_if_dbg_isr_t)(void *__ch_data, 
-                               int* __ctrlc, CYG_ADDRWORD __vec,
-                               CYG_ADDRWORD __data);
+typedef int (*__comm_if_control_t)(void *__ch_data,
+                                                               __comm_control_cmd_t __func, ...);
+typedef int (*__comm_if_dbg_isr_t)(void *__ch_data,
+                                                               int* __ctrlc, CYG_ADDRWORD __vec,
+                                                               CYG_ADDRWORD __data);
 typedef cyg_bool (*__comm_if_getc_timeout_t)(void *__ch_data, void *__ch);
 
-#define __call_COMM0(_n_,_rt_,_t_)                              \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t)                   \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                    \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM0(_n_,_rt_,_t_)                                                             \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t)                                  \
+{                                                                                                                              \
+       _rt_ res;                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                                        \
+       _EXIT_MONITOR();                                                                                        \
+       return res;                                                                                                     \
 }
 
-#define __call_voidCOMM(_n_,_rt_,_t_)                           \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t)                   \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                          \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM(_n_,_rt_,_t_)                                                  \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t)                                  \
+{                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                                                      \
+       _EXIT_MONITOR();                                                                                        \
 }
 
-#define __call_COMM1(_n_,_rt_,_t_,_t1_)                         \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)        \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);              \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM1(_n_,_rt_,_t_,_t1_)                                                        \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)               \
+{                                                                                                                              \
+       _rt_ res;                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);                          \
+       _EXIT_MONITOR();                                                                                        \
+       return res;                                                                                                     \
 }
 
-#define __call_voidCOMM1(_n_,_rt_,_t_,_t1_)                     \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)        \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);                    \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM1(_n_,_rt_,_t_,_t1_)                                            \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)               \
+{                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);                                        \
+       _EXIT_MONITOR();                                                                                        \
 }
 
-#define __call_COMM2(_n_,_rt_,_t_,_t1_,_t2_)                    \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)        \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);        \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM2(_n_,_rt_,_t_,_t1_,_t2_)                                   \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)               \
+{                                                                                                                              \
+       _rt_ res;                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);            \
+       _EXIT_MONITOR();                                                                                        \
+       return res;                                                                                                     \
 }
 
-#define __call_voidCOMM2(_n_,_rt_,_t_,_t1_,_t2_)                \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)        \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);              \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM2(_n_,_rt_,_t_,_t1_,_t2_)                               \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)               \
+{                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);                          \
+       _EXIT_MONITOR();                                                                                        \
 }
 
-#define __call_COMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)               \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_)        \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);              \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)                              \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_) \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];                      \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);                      \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidCOMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)           \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_)        \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);        \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)                  \
+static __inline__ _rt_                                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_) \
+{                                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];                      \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);                            \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
 #ifndef CYGACC_COMM_IF_DEFINED
@@ -317,76 +317,76 @@ __call_COMM0(IF_GETC, cyg_uint8, __comm_if_getc_t)
 // This macro has not been changed to use inline functions like the
 // others, simply because it uses variable arguments, and the change
 // would break binary compatibility.
-#define CYGACC_COMM_IF_CONTROL(_t_, args...)                                                            \
- ({ int res;                                                                                            \
-    _ENTER_MONITOR();                                                                                   \
-    res = ((__comm_if_control_t)((_t_)[CYGNUM_COMM_IF_CONTROL]))(CYGACC_COMM_IF_CH_DATA(_t_), args);    \
-    _EXIT_MONITOR();                                                                                    \
-    res;})
+#define CYGACC_COMM_IF_CONTROL(_t_, args...)                                                   \
+ ({ int res;                                                                                                                   \
+        _ENTER_MONITOR();                                                                                                      \
+        res = ((__comm_if_control_t)((_t_)[CYGNUM_COMM_IF_CONTROL]))(CYGACC_COMM_IF_CH_DATA(_t_), args); \
+        _EXIT_MONITOR();                                                                                                       \
+        res;})
 #define CYGACC_COMM_IF_CONTROL_SET(_t_, _x_) \
- (_t_)[CYGNUM_COMM_IF_CONTROL]=(CYG_ADDRWORD)(_x_)
      (_t_)[CYGNUM_COMM_IF_CONTROL]=(CYG_ADDRWORD)(_x_)
 
 __call_COMM3(IF_DBG_ISR, int, __comm_if_dbg_isr_t, int *, CYG_ADDRWORD, CYG_ADDRWORD)
 #define CYGACC_COMM_IF_DBG_ISR(_t_, _c_, _v_, _d_) \
- __call_COMM_IF_DBG_ISR(_t_, _c_, _v_, _d_)
      __call_COMM_IF_DBG_ISR(_t_, _c_, _v_, _d_)
 #define CYGACC_COMM_IF_DBG_ISR_SET(_t_, _x_) \
- (_t_)[CYGNUM_COMM_IF_DBG_ISR]=(CYG_ADDRWORD)(_x_)
      (_t_)[CYGNUM_COMM_IF_DBG_ISR]=(CYG_ADDRWORD)(_x_)
 
 __call_COMM1(IF_GETC_TIMEOUT, cyg_bool, __comm_if_getc_timeout_t, void *)
-#define CYGACC_COMM_IF_GETC_TIMEOUT(_t_, _c_) \
- __call_COMM_IF_GETC_TIMEOUT(_t_, _c_)
-#define CYGACC_COMM_IF_GETC_TIMEOUT_SET(_t_, _x_) \
- (_t_)[CYGNUM_COMM_IF_GETC_TIMEOUT]=(CYG_ADDRWORD)(_x_)
+#define CYGACC_COMM_IF_GETC_TIMEOUT(_t_, _c_)  \
      __call_COMM_IF_GETC_TIMEOUT(_t_, _c_)
+#define CYGACC_COMM_IF_GETC_TIMEOUT_SET(_t_, _x_)                      \
      (_t_)[CYGNUM_COMM_IF_GETC_TIMEOUT]=(CYG_ADDRWORD)(_x_)
 
 #endif // CYGACC_COMM_IF_DEFINED
 
 //--------------------------------------------------------------------------
-// Main calling interface table. Will be assigned a location by the 
+// Main calling interface table. Will be assigned a location by the
 // linker script. Both ROM and RAM startup applications will know about
 // the location.
-#define CYGNUM_CALL_IF_VERSION                    0
-#define CYGNUM_CALL_IF_available_1                1
-#define CYGNUM_CALL_IF_available_2                2
-#define CYGNUM_CALL_IF_available_3                3
-#define CYGNUM_CALL_IF_KILL_VECTOR                4
-#define CYGNUM_CALL_IF_CONSOLE_PROCS              5
-#define CYGNUM_CALL_IF_DEBUG_PROCS                6
-#define CYGNUM_CALL_IF_FLUSH_DCACHE               7
-#define CYGNUM_CALL_IF_FLUSH_ICACHE               8
-#define CYGNUM_CALL_IF_available_9                9
-#define CYGNUM_CALL_IF_available_10               10
-#define CYGNUM_CALL_IF_available_11               11
-#define CYGNUM_CALL_IF_SET_DEBUG_COMM             12
-#define CYGNUM_CALL_IF_SET_CONSOLE_COMM           13
-#define CYGNUM_CALL_IF_MONITOR_VERSION            14
-#define CYGNUM_CALL_IF_DBG_SYSCALL                15
-#define CYGNUM_CALL_IF_RESET                      16
-#define CYGNUM_CALL_IF_CONSOLE_INTERRUPT_FLAG     17
-#define CYGNUM_CALL_IF_DELAY_US                   18
-#define CYGNUM_CALL_IF_DBG_DATA                   19
-#define CYGNUM_CALL_IF_FLASH_CFG_OP               20
-#define CYGNUM_CALL_IF_MONITOR_RETURN             21
-#define CYGNUM_CALL_IF_FLASH_FIS_OP               22
-#define CYGNUM_CALL_IF_FLASH_FIS_OP2              23
-
-#define CYGNUM_CALL_IF_LAST_ENTRY                 CYGNUM_CALL_IF_FLASH_FIS_OP2
-
-#define CYGNUM_CALL_IF_INSTALL_BPT_FN             35
-
-#define CYGNUM_CALL_IF_TABLE_SIZE                 64
+#define CYGNUM_CALL_IF_VERSION                                   0
+#define CYGNUM_CALL_IF_available_1                               1
+#define CYGNUM_CALL_IF_available_2                               2
+#define CYGNUM_CALL_IF_available_3                               3
+#define CYGNUM_CALL_IF_KILL_VECTOR                               4
+#define CYGNUM_CALL_IF_CONSOLE_PROCS                     5
+#define CYGNUM_CALL_IF_DEBUG_PROCS                               6
+#define CYGNUM_CALL_IF_FLUSH_DCACHE                              7
+#define CYGNUM_CALL_IF_FLUSH_ICACHE                              8
+#define CYGNUM_CALL_IF_available_9                               9
+#define CYGNUM_CALL_IF_available_10                              10
+#define CYGNUM_CALL_IF_available_11                              11
+#define CYGNUM_CALL_IF_SET_DEBUG_COMM                    12
+#define CYGNUM_CALL_IF_SET_CONSOLE_COMM                          13
+#define CYGNUM_CALL_IF_MONITOR_VERSION                   14
+#define CYGNUM_CALL_IF_DBG_SYSCALL                               15
+#define CYGNUM_CALL_IF_RESET                                     16
+#define CYGNUM_CALL_IF_CONSOLE_INTERRUPT_FLAG    17
+#define CYGNUM_CALL_IF_DELAY_US                                          18
+#define CYGNUM_CALL_IF_DBG_DATA                                          19
+#define CYGNUM_CALL_IF_FLASH_CFG_OP                              20
+#define CYGNUM_CALL_IF_MONITOR_RETURN                    21
+#define CYGNUM_CALL_IF_FLASH_FIS_OP                              22
+#define CYGNUM_CALL_IF_FLASH_FIS_OP2                     23
+
+#define CYGNUM_CALL_IF_LAST_ENTRY                                CYGNUM_CALL_IF_FLASH_FIS_OP2
+
+#define CYGNUM_CALL_IF_INSTALL_BPT_FN                    35
+
+#define CYGNUM_CALL_IF_TABLE_SIZE                                64
 
 externC volatile CYG_ADDRWORD hal_virtual_vector_table[CYGNUM_CALL_IF_TABLE_SIZE];
 
 // Table version contains version information for both the CALL table
 // itself (the number of the last active entry in the table), and the
 // COMM table (the size of the table).
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL         CYGNUM_CALL_IF_LAST_ENTRY
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_HACK    (CYGNUM_CALL_IF_TABLE_SIZE+1)
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MAX     CYGNUM_CALL_IF_TABLE_SIZE
-#define CYGNUM_CALL_IF_TABLE_VERSION_COMM         CYGNUM_COMM_IF_TABLE_SIZE
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MASK    0x0000ffff
-#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_MASK    0xffff0000
-#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_shift   16
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL                CYGNUM_CALL_IF_LAST_ENTRY
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_HACK   (CYGNUM_CALL_IF_TABLE_SIZE+1)
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MAX    CYGNUM_CALL_IF_TABLE_SIZE
+#define CYGNUM_CALL_IF_TABLE_VERSION_COMM                CYGNUM_COMM_IF_TABLE_SIZE
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MASK   0x0000ffff
+#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_MASK   0xffff0000
+#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_shift          16
 
 
 // These are special debug/console procs IDs
@@ -398,8 +398,8 @@ externC volatile CYG_ADDRWORD hal_virtual_vector_table[CYGNUM_CALL_IF_TABLE_SIZE
 //               allowing the application to temporarily disable mangling
 //               or temporarily switch in different console procs.
 #define CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT -1
-#define CYGNUM_CALL_IF_SET_COMM_ID_EMPTY         -2
-#define CYGNUM_CALL_IF_SET_COMM_ID_MANGLER       -3
+#define CYGNUM_CALL_IF_SET_COMM_ID_EMPTY                -2
+#define CYGNUM_CALL_IF_SET_COMM_ID_MANGLER              -3
 
 // The below is a (messy) attempt at adding some type safety to the
 // above array. At the same time, the accessors allow the
@@ -419,7 +419,7 @@ typedef int (__call_if_set_debug_comm_t)(int __comm_id);
 typedef int (__call_if_set_console_comm_t)(int __comm_id);
 typedef void* __call_if_dbg_data_t;
 typedef int (__call_if_dbg_syscall_t) (enum dbg_syscall_ids id,
-                                        union dbg_thread_syscall_parms  *p );
+                                                                       union dbg_thread_syscall_parms  *p);
 typedef void (__call_if_reset_t)(void);
 typedef int __call_if_console_interrupt_flag_t;
 typedef void (__call_if_delay_us_t)(cyg_int32 usecs);
@@ -448,129 +448,129 @@ typedef int (__call_if_flash_fis_op2_fn_t)(int __oper, unsigned int index, struc
 // This allows a single virtual vector interface, with widely varying functionality
 //
 struct cyg_fconfig {
-    char *key;      // Datum 'key'
-    int   keylen;   // Length of key
-    void *val;      // Pointer to data
-    int   type;     // Type of datum
-    int   offset;   // Offset within data (used by _NEXT)
+       char *key;              // Datum 'key'
+       int       keylen;       // Length of key
+       void *val;              // Pointer to data
+       int       type;         // Type of datum
+       int       offset;       // Offset within data (used by _NEXT)
 };
 typedef cyg_bool (__call_if_flash_cfg_op_fn_t)(int __oper, struct cyg_fconfig *__data);
 
 #ifndef CYGACC_CALL_IF_DEFINED
 
-#define __data_VV(_n_,_tt_)                             \
-static __inline__ _tt_                                  \
-__call_vv_##_n_(void)                                   \
-{                                                       \
-    return ((_tt_)hal_virtual_vector_table[_n_]);       \
+#define __data_VV(_n_,_tt_)                                                            \
+static __inline__ _tt_                                                                 \
+__call_vv_##_n_(void)                                                                  \
+{                                                                                                              \
+       return ((_tt_)hal_virtual_vector_table[_n_]);           \
 }
 
-#define __call_VV0(_n_,_tt_,_rt_)                                       \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(void)                                                   \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])();                    \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV0(_n_,_tt_,_rt_)                                                                              \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(void)                                                                                                  \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])();                                        \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV0(_n_,_tt_,_rt_)                                   \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(void)                                                   \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])();                          \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV0(_n_,_tt_,_rt_)                                                                  \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(void)                                                                                                  \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])();                                                      \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV1(_n_,_tt_,_rt_,_t1_)                                  \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_)                                              \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV1(_n_,_tt_,_rt_,_t1_)                                                                 \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_)                                                                                             \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                            \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV1(_n_,_tt_,_rt_,_t1_)                              \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_)                                              \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                      \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV1(_n_,_tt_,_rt_,_t1_)                                                             \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_)                                                                                             \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                                          \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV2(_n_,_tt_,_rt_,_t1_,_t2_)                             \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                   \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);           \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV2(_n_,_tt_,_rt_,_t1_,_t2_)                                                            \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                                                  \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);                       \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV2(_n_,_tt_,_rt_,_t1_,_t2_)                         \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                   \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);                 \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV2(_n_,_tt_,_rt_,_t1_,_t2_)                                                        \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                                                  \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);                                     \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                        \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                        \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);      \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                                               \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                                               \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);          \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                    \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                        \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);            \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                                   \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                                               \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);                        \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)                   \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)             \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_); \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)                                  \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)                            \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_); \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)               \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)             \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_);       \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)                              \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)                            \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_);           \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
 
-#define CYGACC_DATA_VV(t,e)              __call_vv_##e()
-#define CYGACC_CALL_VV0(t,e)             __call_vv_##e
-#define CYGACC_CALL_VV1(t,e,p1)          __call_vv_##e((p1))
-#define CYGACC_CALL_VV2(t,e,p1,p2)       __call_vv_##e((p1),(p2))
-#define CYGACC_CALL_VV3(t,e,p1,p2,p3)    __call_vv_##e((p1),(p2),(p3))
+#define CYGACC_DATA_VV(t,e)                             __call_vv_##e()
+#define CYGACC_CALL_VV0(t,e)                    __call_vv_##e
+#define CYGACC_CALL_VV1(t,e,p1)                         __call_vv_##e((p1))
+#define CYGACC_CALL_VV2(t,e,p1,p2)              __call_vv_##e((p1),(p2))
+#define CYGACC_CALL_VV3(t,e,p1,p2,p3)   __call_vv_##e((p1),(p2),(p3))
 #define CYGACC_CALL_VV4(t,e,p1,p2,p3,p4) __call_vv_##e((p1),(p2),(p3),(p4))
 
 #define CYGACC_CALL_IF_VERSION() \
@@ -666,9 +666,9 @@ __call_voidVV1(CYGNUM_CALL_IF_INSTALL_BPT_FN, __call_if_install_bpt_fn_t, void,
 //
 // Access persistent data store - kept in FLASH or EEPROM by RedBoot
 //
-#define CYGNUM_CALL_IF_FLASH_CFG_GET  (0)     // Get a particular fconfig key
-#define CYGNUM_CALL_IF_FLASH_CFG_NEXT (1)     // Enumerate keys (get the next one)
-#define CYGNUM_CALL_IF_FLASH_CFG_SET  (2)     // Update particular fconfig key
+#define CYGNUM_CALL_IF_FLASH_CFG_GET   0         // Get a particular fconfig key
+#define CYGNUM_CALL_IF_FLASH_CFG_NEXT  1         // Enumerate keys (get the next one)
+#define CYGNUM_CALL_IF_FLASH_CFG_SET   2         // Update particular fconfig key
 #define CYGACC_CALL_IF_FLASH_CFG_OP2(_o_,_d_) \
  CYGACC_CALL_VV2(__call_if_flash_cfg_op_fn_t*, CYGNUM_CALL_IF_FLASH_CFG_OP, (_o_),(_d_))
 __call_VV2(CYGNUM_CALL_IF_FLASH_CFG_OP, __call_if_flash_cfg_op_fn_t, cyg_bool, int, struct cyg_fconfig *)
@@ -676,12 +676,12 @@ __call_VV2(CYGNUM_CALL_IF_FLASH_CFG_OP, __call_if_flash_cfg_op_fn_t, cyg_bool, i
 static __inline__ cyg_bool
 __call_if_flash_cfg_op(int op, char *key, void *data, int type)
 {
-    struct cyg_fconfig info;
-    info.key = key;
-    info.val = data;
-    info.type = type;
-    info.offset = 0;
-    return CYGACC_CALL_IF_FLASH_CFG_OP2(op, &info);
+       struct cyg_fconfig info;
+       info.key = key;
+       info.val = data;
+       info.type = type;
+       info.offset = 0;
+       return CYGACC_CALL_IF_FLASH_CFG_OP2(op, &info);
 }
 #define CYGACC_CALL_IF_FLASH_CFG_OP(_o_,_k_,_d_,_t_) \
   __call_if_flash_cfg_op(_o_,_k_,_d_,_t_)
@@ -699,38 +699,37 @@ __call_voidVV1(CYGNUM_CALL_IF_MONITOR_RETURN, __call_if_monitor_return_t, void,
 __call_VV3(CYGNUM_CALL_IF_FLASH_FIS_OP, __call_if_flash_fis_op_fn_t, cyg_bool, int, char *, void *)
 #define CYGACC_CALL_IF_FLASH_FIS_OP_SET(_x_) \
  hal_virtual_vector_table[CYGNUM_CALL_IF_FLASH_FIS_OP]=(CYG_ADDRWORD)(_x_)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_FLASH_BASE  (0)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_SIZE        (1)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_MEM_BASE    (2)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_POINT (3)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_DATA_LENGTH (4)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_DESC_CKSUM  (5)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_FILE_CKSUM  (6)
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_FLASH_BASE                0
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_SIZE                      1
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_MEM_BASE          2
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_POINT       3
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_DATA_LENGTH       4
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_DESC_CKSUM                5
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_FILE_CKSUM                6
 
 #define CYGACC_CALL_IF_FLASH_FIS_OP2(_o_,_k_,_d_) \
  CYGACC_CALL_VV3(__call_if_flash_fis_op2_fn_t*, CYGNUM_CALL_IF_FLASH_FIS_OP2, (_o_),(_k_),(_d_))
 __call_VV3(CYGNUM_CALL_IF_FLASH_FIS_OP2, __call_if_flash_fis_op2_fn_t, int, int, unsigned int, struct fis_table_entry *)
 #define CYGACC_CALL_IF_FLASH_FIS_OP2_SET(_x_) \
  hal_virtual_vector_table[CYGNUM_CALL_IF_FLASH_FIS_OP2]=(CYG_ADDRWORD)(_x_)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_VERSION     (0)
-#define CYGNUM_CALL_IF_FLASH_FIS_INIT            (1)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_COUNT (2)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY       (3)
-#define CYGNUM_CALL_IF_FLASH_FIS_START_UPDATE    (4)
-#define CYGNUM_CALL_IF_FLASH_FIS_FINISH_UPDATE   (5)
-#define CYGNUM_CALL_IF_FLASH_FIS_MODIFY_ENTRY    (6)
-
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_VERSION           0
+#define CYGNUM_CALL_IF_FLASH_FIS_INIT                          1
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_COUNT       2
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY                     3
+#define CYGNUM_CALL_IF_FLASH_FIS_START_UPDATE          4
+#define CYGNUM_CALL_IF_FLASH_FIS_FINISH_UPDATE         5
+#define CYGNUM_CALL_IF_FLASH_FIS_MODIFY_ENTRY          6
 
 
 // These need to be kept uptodate with the (unadorned) masters
 // in RedBoot's flash_config.h:
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_EMPTY   0
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_BOOL    1
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_INT     2
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_STRING  3
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_SCRIPT  4
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_IP      5
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_ESA     6
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_EMPTY                     0
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_BOOL                      1
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_INT                       2
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_STRING                    3
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_SCRIPT                    4
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_IP                                5
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_ESA                       6
 
 #endif // CYGACC_CALL_IF_DEFINED
 
@@ -751,9 +750,9 @@ externC cyg_bool   hal_ctrlc_check(CYG_ADDRWORD vector, CYG_ADDRWORD data);
 #else
 
 #if defined(CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT) \
-    || defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT)
+       || defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT)
 // Then other code might invoke this macro
-#define HAL_CTRLC_CHECK(a1,a2) (0) // Nothing, no CTRLC here
+#define HAL_CTRLC_CHECK(a1,a2)                         0 // Nothing, no CTRLC here
 #endif
 
 #endif // CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT