]> git.kernelconcepts.de Git - karo-tx-redboot.git/commitdiff
TX51 pre-release
authorlothar <lothar>
Thu, 14 Jan 2010 17:07:36 +0000 (17:07 +0000)
committerlothar <lothar>
Thu, 14 Jan 2010 17:07:36 +0000 (17:07 +0000)
12 files changed:
packages/hal/arm/mx25/karo/v1_0/include/karo_tx25.h
packages/hal/arm/mx25/karo/v1_0/include/pkgconf/mlt_arm_tx25_romram.h
packages/hal/arm/mx25/karo/v1_0/include/plf_mmap.h
packages/hal/arm/mx25/karo/v1_0/src/redboot_cmds.c
packages/hal/arm/mx25/karo/v1_0/src/tx25_misc.c
packages/hal/arm/mx25/var/v2_0/include/hal_mm.h
packages/hal/arm/mx25/var/v2_0/include/hal_soc.h
packages/hal/arm/mx25/var/v2_0/src/soc_diag.c
packages/hal/arm/mx25/var/v2_0/src/soc_misc.c
packages/hal/common/v2_0/include/hal_if.h
packages/hal/common/v2_0/src/hal_stub.c
packages/hal/common/v2_0/src/thread-packets.c

index a2fc9bf4a6578f6190b41b2c1f07c2321ce37954..b443ed70b54329b7efe5c676fd016b887a2213bb 100644 (file)
 
 #include CYGHWR_MEMORY_LAYOUT_H
 
 
 #include CYGHWR_MEMORY_LAYOUT_H
 
-#define SZ_1K                  0x00000400
-#define SZ_2K                  0x00000800
-#define SZ_4K                  0x00001000
-#define SZ_8K                  0x00002000
-#define SZ_16K                 0x00004000
-#define SZ_32K                 0x00008000
-#define SZ_64K                 0x00010000
-#define SZ_128K                0x00020000
-#define SZ_256K                0x00040000
-#define SZ_512K                0x00080000
-#define SZ_1M                  0x00100000
-#define SZ_2M                  0x00200000
-#define SZ_4M                  0x00400000
-#define SZ_8M                  0x00800000
-#define SZ_16M                 0x01000000
-#define SZ_32M                 0x02000000
-#define SZ_64M                 0x04000000
-#define SZ_128M                0x08000000
-#define SZ_256M                0x10000000
-#define SZ_512M                0x20000000
-#define SZ_1G                  0x40000000
-
-#define RAM_BANK0_BASE         CSD0_BASE_ADDR
-#define RAM_BANK1_BASE         CSD1_BASE_ADDR
-#if SDRAM_SIZE > SZ_32M
-#define RAM_BANK0_SIZE         (SDRAM_SIZE / 2)
-#define RAM_BANK1_SIZE         (SDRAM_SIZE / 2)
-#else
-#define RAM_BANK0_SIZE         SDRAM_SIZE
-#endif
-#define TX25_SDRAM_SIZE                SDRAM_SIZE
+#define SZ_1K                          0x00000400
+#define SZ_2K                          0x00000800
+#define SZ_4K                          0x00001000
+#define SZ_8K                          0x00002000
+#define SZ_16K                         0x00004000
+#define SZ_32K                         0x00008000
+#define SZ_64K                         0x00010000
+#define SZ_128K                                0x00020000
+#define SZ_256K                                0x00040000
+#define SZ_512K                                0x00080000
+#define SZ_1M                          0x00100000
+#define SZ_2M                          0x00200000
+#define SZ_4M                          0x00400000
+#define SZ_8M                          0x00800000
+#define SZ_16M                         0x01000000
+#define SZ_32M                         0x02000000
+#define SZ_64M                         0x04000000
+#define SZ_128M                                0x08000000
+#define SZ_256M                                0x10000000
+#define SZ_512M                                0x20000000
+#define SZ_1G                          0x40000000
 
 #define TX25_LED_MASK          (1 << 7)
 #define TX25_LED_REG_ADDR      (GPIO2_BASE_ADDR + GPIO_DR)
 
 #define TX25_LED_MASK          (1 << 7)
 #define TX25_LED_REG_ADDR      (GPIO2_BASE_ADDR + GPIO_DR)
 })
 
 #define TURN_LED_ON(n)                                                 \
 })
 
 #define TURN_LED_ON(n)                                                 \
-    CYG_MACRO_START                                                            \
+       CYG_MACRO_START                                                         \
        CYG_WORD32 __val;                                                       \
        HAL_READ_UINT32(TX25_LED_REG_ADDR, __val);      \
        __val |= TX25_LED_MASK;                                         \
        HAL_WRITE_UINT32(TX25_LED_REG_ADDR, __val);     \
        CYG_WORD32 __val;                                                       \
        HAL_READ_UINT32(TX25_LED_REG_ADDR, __val);      \
        __val |= TX25_LED_MASK;                                         \
        HAL_WRITE_UINT32(TX25_LED_REG_ADDR, __val);     \
-    CYG_MACRO_END
+       CYG_MACRO_END
 
 #define TURN_LED_OFF(n)                                                        \
 
 #define TURN_LED_OFF(n)                                                        \
-    CYG_MACRO_START                                                            \
+       CYG_MACRO_START                                                         \
        CYG_WORD32 __val;                                                       \
        HAL_READ_UINT32(TX25_LED_REG_ADDR, __val);      \
        __val &= ~TX25_LED_MASK;                                        \
        HAL_WRITE_UINT32(TX25_LED_REG_ADDR, __val);     \
        CYG_WORD32 __val;                                                       \
        HAL_READ_UINT32(TX25_LED_REG_ADDR, __val);      \
        __val &= ~TX25_LED_MASK;                                        \
        HAL_WRITE_UINT32(TX25_LED_REG_ADDR, __val);     \
-    CYG_MACRO_END
+       CYG_MACRO_END
 
 #define BOARD_DEBUG_LED(n)                                             \
 
 #define BOARD_DEBUG_LED(n)                                             \
-    CYG_MACRO_START                                                            \
+       CYG_MACRO_START                                                         \
        if (n >= 0 && n < LED_MAX_NUM) {                        \
                if (LED_IS_ON(n))                                               \
                        TURN_LED_OFF(n);                                        \
                else                                                                    \
                        TURN_LED_ON(n);                                         \
        }                                                                                       \
        if (n >= 0 && n < LED_MAX_NUM) {                        \
                if (LED_IS_ON(n))                                               \
                        TURN_LED_OFF(n);                                        \
                else                                                                    \
                        TURN_LED_ON(n);                                         \
        }                                                                                       \
-    CYG_MACRO_END
+       CYG_MACRO_END
 
 #define BLINK_LED(l, n)                                                        \
 
 #define BLINK_LED(l, n)                                                        \
-    CYG_MACRO_START                                                            \
+       CYG_MACRO_START                                                         \
        int _i;                                                                         \
        for (_i = 0; _i < (n); _i++) {                          \
                BOARD_DEBUG_LED(l);                                             \
        int _i;                                                                         \
        for (_i = 0; _i < (n); _i++) {                          \
                BOARD_DEBUG_LED(l);                                             \
                HAL_DELAY_US(300000);                                   \
        }                                                                                       \
        HAL_DELAY_US(1000000);                                          \
                HAL_DELAY_US(300000);                                   \
        }                                                                                       \
        HAL_DELAY_US(1000000);                                          \
-    CYG_MACRO_END
+       CYG_MACRO_END
 
 #if !defined(__ASSEMBLER__)
 enum {
 
 #if !defined(__ASSEMBLER__)
 enum {
index 664f5b619f886751d6b2880e8ae4d4ea792ab212..24a15a9efbe675bf1aea1cdd7675d23c9a04b6c5 100644 (file)
 #define SDRAM_BASE_ADDR                        CSD0_BASE_ADDR
 #define SDRAM_SIZE                             CYGNUM_HAL_ARM_TX25_SDRAM_SIZE
 
 #define SDRAM_BASE_ADDR                        CSD0_BASE_ADDR
 #define SDRAM_SIZE                             CYGNUM_HAL_ARM_TX25_SDRAM_SIZE
 
+#define SZ_32M                                 0x02000000
+#define RAM_BANK0_BASE                 CSD0_BASE_ADDR
+#define RAM_BANK1_BASE                 CSD1_BASE_ADDR
+#if SDRAM_SIZE > SZ_32M
+#define RAM_BANK0_SIZE                 (SDRAM_SIZE / 2)
+#define RAM_BANK1_SIZE                 (SDRAM_SIZE / 2)
+#else
+#define RAM_BANK0_SIZE                 SDRAM_SIZE
+#endif
+#define TX25_SDRAM_SIZE                        SDRAM_SIZE
+
 #define REDBOOT_IMAGE_SIZE             0x00040000
 
 #ifndef REDBOOT_BOTTOM
 #define REDBOOT_IMAGE_SIZE             0x00040000
 
 #ifndef REDBOOT_BOTTOM
index e81d8331dd3f28be90742236f5a0b0c4cbd38153..b703569e7f1907697e04e8a8672958a3f101ee45 100644 (file)
 //===========================================================================
 
 #include <cyg/hal/hal_misc.h>
 //===========================================================================
 
 #include <cyg/hal/hal_misc.h>
+#include CYGHWR_MEMORY_LAYOUT_H
 
 // Get the pagesize for a particular virtual address:
 
 // This does not depend on the vaddr.
 
 // Get the pagesize for a particular virtual address:
 
 // This does not depend on the vaddr.
-#define HAL_MM_PAGESIZE(vaddr, pagesize) CYG_MACRO_START        \
-        (pagesize) = SZ_1M;                                         \
-CYG_MACRO_END
+#define HAL_MM_PAGESIZE(vaddr, pagesize)               \
+       CYG_MACRO_START                                                         \
+       (pagesize) = SZ_1M;                                                     \
+       CYG_MACRO_END
 
 // Get the physical address from a virtual address:
 
 
 // Get the physical address from a virtual address:
 
-#define HAL_VIRT_TO_PHYS_ADDRESS( vaddr, paddr ) CYG_MACRO_START           \
-        cyg_uint32 _v_ = (cyg_uint32)(vaddr);                                  \
-        if ( _v_ < 128 * SZ_1M )         /* SDRAM */                           \
-                _v_ += SDRAM_BASE_ADDR;                                             \
-        else                             /* Rest of it */                      \
-                /* no change */ ;                                                  \
-                (paddr) = _v_;                                                         \
-CYG_MACRO_END
+#define HAL_VIRT_TO_PHYS_ADDRESS(vaddr, paddr)                 \
+       CYG_MACRO_START                                                                         \
+       cyg_uint32 _v_ = (cyg_uint32)(vaddr);                           \
+       if (_v_ < 128 * SZ_1M)           /* SDRAM */            \
+               _v_ += SDRAM_BASE_ADDR;                                                 \
+       else                                                     /* Rest of it */       \
+               /* no change */ ;                                                               \
+       (paddr) = _v_;                                                                          \
+       CYG_MACRO_END
 
 /*
  * translate the virtual address of ram space to physical address
  * It is dependent on the implementation of hal_mmu_init
  */
 
 /*
  * translate the virtual address of ram space to physical address
  * It is dependent on the implementation of hal_mmu_init
  */
+#if 1
+/*
+ * translate the virtual address of ram space to physical address
+ * It is dependent on the implementation of hal_mmu_init
+ */
+#ifndef RAM_BANK0_SIZE
+#warning using SDRAM_SIZE for RAM_BANK0_SIZE
+#define RAM_BANK0_SIZE         SDRAM_SIZE
+#endif
+
+static unsigned long __inline__ hal_virt_to_phy(unsigned long virt)
+{
+       /* SDRAM mappings:
+          80000000 -> 80000000
+          90000000 -> 80000000 + (SDRAM_SIZE / 2)
+        */
+       if (virt < 0x08000000) {
+               return virt | (virt < RAM_BANK0_SIZE ? CSD0_BASE_ADDR : CSD1_BASE_ADDR);
+       }
+       if ((virt & 0xF0000000) == CSD0_BASE_ADDR) {
+               virt &= ~0x08000000;
+               if (virt >= CSD0_BASE_ADDR + RAM_BANK0_SIZE) {
+                       virt = virt - CSD0_BASE_ADDR + CSD1_BASE_ADDR - RAM_BANK0_SIZE;
+               }
+       }
+       return virt;
+}
+
+/*
+ * remap the physical address of ram space to uncacheable virtual address space
+ * It is dependent on the implementation of hal_mmu_init
+ */
+static unsigned long __inline__ hal_ioremap_nocache(unsigned long phy)
+{
+       /* 0x88000000~0x88FFFFFF is uncacheable memory space which is mapped to SDRAM */
+       if ((phy & 0xF0000000) == CSD0_BASE_ADDR) {
+               phy |= 0x08000000;
+       }
+       if ((phy & 0xF0000000) == CSD1_BASE_ADDR) {
+               phy = (phy - CSD1_BASE_ADDR + CSD0_BASE_ADDR + RAM_BANK0_SIZE) | 0x08000000;
+       }
+       return phy;
+}
+#else
 static unsigned long __inline__ hal_virt_to_phy(unsigned long virt)
 {
 static unsigned long __inline__ hal_virt_to_phy(unsigned long virt)
 {
-        if(virt < 0x08000000) {
-                return virt|0x80000000;
-        }
-        if((virt & 0xF0000000) == 0x80000000) {
-                return virt&(~0x08000000);
-        }
-        return virt;
+       if (virt < 0x08000000) {
+               return virt|0x80000000;
+       }
+       if((virt & 0xF0000000) == 0x80000000) {
+               return virt&(~0x08000000);
+       }
+       return virt;
 }
 
 /*
 }
 
 /*
@@ -82,12 +129,13 @@ static unsigned long __inline__ hal_virt_to_phy(unsigned long virt)
  */
 static unsigned long __inline__ hal_ioremap_nocache(unsigned long phy)
 {
  */
 static unsigned long __inline__ hal_ioremap_nocache(unsigned long phy)
 {
-        /* 0x88000000~0x87FFFFFF is uncacheable meory space which is mapped to SDRAM*/
-        if((phy & 0xF0000000) == 0x80000000) {
-                phy |= 0x08000000;
-        }
-        return phy;
+       /* 0x88000000~0x87FFFFFF is uncacheable meory space which is mapped to SDRAM*/
+       if ((phy & 0xF0000000) == 0x80000000) {
+               phy |= 0x08000000;
+       }
+       return phy;
 }
 }
+#endif
 
 //---------------------------------------------------------------------------
 #endif // CYGONCE_HAL_BOARD_PLATFORM_PLF_MMAP_H
 
 //---------------------------------------------------------------------------
 #endif // CYGONCE_HAL_BOARD_PLATFORM_PLF_MMAP_H
index 8eff72c1f1fcb55b9d033bd0974b9c1992748f45..457f331c974c61d8a2b2e3de6512b1871dd8d859 100644 (file)
@@ -62,16 +62,16 @@ static void runImg(int argc, char *argv[]);
 static void do_mem(int argc, char *argv[]);
 
 RedBoot_cmd("mem",
 static void do_mem(int argc, char *argv[]);
 
 RedBoot_cmd("mem",
-           "Set a memory location",
-           "[-h|-b] [-n] [-a <address>] <data>",
-           do_mem
-    );
+                       "Set a memory location",
+                       "[-h|-b] [-n] [-a <address>] <data>",
+                       do_mem
+       );
 
 RedBoot_cmd("run",
 
 RedBoot_cmd("run",
-           "Run an image at a location with MMU off",
-           "[<virtual addr>]",
-           runImg
-          );
+                       "Run an image at a location with MMU off",
+                       "[<virtual addr>]",
+                       runImg
+       );
 
 static void do_mem(int argc, char *argv[])
 {
 
 static void do_mem(int argc, char *argv[])
 {
@@ -113,7 +113,7 @@ static void do_mem(int argc, char *argv[])
                        diag_printf("  Set 0x%08lX to 0x%02X\n", address, value);
                } else {
                        diag_printf("  Set 0x%08lX to 0x%02X (result 0x%02X)\n",
                        diag_printf("  Set 0x%08lX to 0x%02X\n", address, value);
                } else {
                        diag_printf("  Set 0x%08lX to 0x%02X (result 0x%02X)\n",
-                                   address, value, (int)*(cyg_uint8*)address );
+                                               address, value, (int)*(cyg_uint8*)address );
                }
        } else if (mem_half_word) {
                if (address & 1) {
                }
        } else if (mem_half_word) {
                if (address & 1) {
@@ -125,7 +125,7 @@ static void do_mem(int argc, char *argv[])
                                diag_printf("  Set 0x%08lX to 0x%04X\n", address, value);
                        } else {
                                diag_printf("  Set 0x%08lX to 0x%04X (result 0x%04X)\n",
                                diag_printf("  Set 0x%08lX to 0x%04X\n", address, value);
                        } else {
                                diag_printf("  Set 0x%08lX to 0x%04X (result 0x%04X)\n",
-                                           address, value, (int)*(cyg_uint16*)address);
+                                                       address, value, (int)*(cyg_uint16*)address);
                        }
                }
        } else {
                        }
                }
        } else {
@@ -137,7 +137,7 @@ static void do_mem(int argc, char *argv[])
                                diag_printf("  Set 0x%08lX to 0x%08X\n", address, value);
                        } else {
                                diag_printf("  Set 0x%08lX to 0x%08X (result 0x%08X)\n",
                                diag_printf("  Set 0x%08lX to 0x%08X\n", address, value);
                        } else {
                                diag_printf("  Set 0x%08lX to 0x%08X (result 0x%08X)\n",
-                                           address, value, (int)*(cyg_uint32*)address);
+                                                       address, value, (int)*(cyg_uint32*)address);
                        }
                }
        }
                        }
                }
        }
@@ -145,18 +145,18 @@ static void do_mem(int argc, char *argv[])
 
 void launchRunImg(unsigned long addr)
 {
 
 void launchRunImg(unsigned long addr)
 {
-    asm volatile ("mov r12, r0;");
-    HAL_MMU_OFF();
-    asm volatile (
-                 "mov r0, #0;"
-                 "mov r1, r12;"
-                "mov r11, #0;"
-                "mov r12, #0;"
-                "mrs r10, cpsr;"
-                "bic r10, r10, #0xF0000000;"
-                "msr cpsr_f, r10;"
-                "mov pc, r1"
-                );
+       asm volatile ("mov r12, r0;");
+       HAL_MMU_OFF();
+       asm volatile (
+               "mov r0, #0;"
+               "mov r1, r12;"
+               "mov r11, #0;"
+               "mov r12, #0;"
+               "mrs r10, cpsr;"
+               "bic r10, r10, #0xF0000000;"
+               "msr cpsr_f, r10;"
+               "mov pc, r1"
+               );
 }
 
 static void runImg(int argc,char *argv[])
 }
 
 static void runImg(int argc,char *argv[])
@@ -170,7 +170,7 @@ static void runImg(int argc,char *argv[])
                virt_addr = entry_address;
 
        if (!scan_opts(argc, argv, 1, 0, 0, &virt_addr,
                virt_addr = entry_address;
 
        if (!scan_opts(argc, argv, 1, 0, 0, &virt_addr,
-                      OPTION_ARG_TYPE_NUM, "virtual address"))
+                                       OPTION_ARG_TYPE_NUM, "virtual address"))
                return;
 
        if (entry_address != 0xFFFFFFFF)
                return;
 
        if (entry_address != 0xFFFFFFFF)
@@ -186,10 +186,10 @@ static void runImg(int argc,char *argv[])
 #if defined(CYGSEM_REDBOOT_FLASH_CONFIG) && defined(CYG_HAL_STARTUP_ROMRAM)
 
 RedBoot_cmd("romupdate",
 #if defined(CYGSEM_REDBOOT_FLASH_CONFIG) && defined(CYG_HAL_STARTUP_ROMRAM)
 
 RedBoot_cmd("romupdate",
-           "Update Redboot with currently running image",
-           "",
-           romupdate
-          );
+                       "Update Redboot with currently running image",
+                       "",
+                       romupdate
+       );
 
 #ifdef CYGPKG_IO_FLASH
 void romupdate(int argc, char *argv[])
 
 #ifdef CYGPKG_IO_FLASH
 void romupdate(int argc, char *argv[])
@@ -203,14 +203,14 @@ void romupdate(int argc, char *argv[])
        // Erase area to be programmed
        if ((stat = flash_erase(base_addr, CYGBLD_REDBOOT_MIN_IMAGE_SIZE, &err_addr)) != 0) {
                diag_printf("Can't erase region at %p: %s\n",
        // Erase area to be programmed
        if ((stat = flash_erase(base_addr, CYGBLD_REDBOOT_MIN_IMAGE_SIZE, &err_addr)) != 0) {
                diag_printf("Can't erase region at %p: %s\n",
-                           err_addr, flash_errmsg(stat));
+                                       err_addr, flash_errmsg(stat));
                return;
        }
        // Now program it
        if ((stat = flash_program(base_addr, ram_end,
                                  CYGBLD_REDBOOT_MIN_IMAGE_SIZE, &err_addr)) != 0) {
                diag_printf("Can't program region at %p: %s\n",
                return;
        }
        // Now program it
        if ((stat = flash_program(base_addr, ram_end,
                                  CYGBLD_REDBOOT_MIN_IMAGE_SIZE, &err_addr)) != 0) {
                diag_printf("Can't program region at %p: %s\n",
-                           err_addr, flash_errmsg(stat));
+                                       err_addr, flash_errmsg(stat));
        }
 }
 #endif //CYGPKG_IO_FLASH
        }
 }
 #endif //CYGPKG_IO_FLASH
index 013788198e97f88e667c710eb6dbf3a7fb860f74..21ca7665814cf1f4f5d00861f43516813f6d19b3 100644 (file)
@@ -107,10 +107,10 @@ static void dump_reg(unsigned long addr)
 #endif
 
 #define SD_SZ          (RAM_BANK0_SIZE >> 20)
 #endif
 
 #define SD_SZ          (RAM_BANK0_SIZE >> 20)
-#define SD_B0          0x800
-#define SD_B1          (0x800 + SD_SZ)
-#define SD_B2          (0x880 + SD_SZ)
 #ifdef RAM_BANK1_SIZE
 #ifdef RAM_BANK1_SIZE
+#define SD_B0          0x800
+#define SD_B1          (SD_B0 + SD_SZ)
+#define SD_B2          (SD_B0 + 0x80 + SD_SZ)
 #define SD_HI          (0x900 + ((RAM_BANK1_SIZE >> 20) - 1))
 #endif
 
 #define SD_HI          (0x900 + ((RAM_BANK1_SIZE >> 20) - 1))
 #endif
 
@@ -140,8 +140,8 @@ void hal_mmu_init(void)
        /*                      xxx00000 */
        X_ARM_MMU_SECTION(0x000, 0xF00, 0x001, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* Boot Rom */
        X_ARM_MMU_SECTION(0x43f, 0x43f, 0x3c1, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* Internal Registers */
        /*                      xxx00000 */
        X_ARM_MMU_SECTION(0x000, 0xF00, 0x001, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* Boot Rom */
        X_ARM_MMU_SECTION(0x43f, 0x43f, 0x3c1, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* Internal Registers */
-       X_ARM_MMU_SECTION(0x800, 0x000, SD_SZ, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
-       X_ARM_MMU_SECTION(0x800, 0x800, SD_SZ, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
+       X_ARM_MMU_SECTION(0x800, 0x000, SD_SZ, ARM_UNCACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
+       X_ARM_MMU_SECTION(0x800, 0x800, SD_SZ, ARM_UNCACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
        X_ARM_MMU_SECTION(0x800, 0x880, SD_SZ, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* SDRAM */
 #ifdef RAM_BANK1_SIZE
        X_ARM_MMU_SECTION(0x900, SD_SZ, SD_SZ, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
        X_ARM_MMU_SECTION(0x800, 0x880, SD_SZ, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* SDRAM */
 #ifdef RAM_BANK1_SIZE
        X_ARM_MMU_SECTION(0x900, SD_SZ, SD_SZ, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
@@ -172,7 +172,7 @@ static void fec_gpio_init(void)
 {
        /* GPIOs to set up for TX25/Starterkit-5:
           Function       GPIO  Dir  act.  FCT
 {
        /* GPIOs to set up for TX25/Starterkit-5:
           Function       GPIO  Dir  act.  FCT
-                                     Lvl   
+                                 Lvl
           FEC_RESET      PB30  OUT  LOW   GPIO
           FEC_ENABLE     PB27  OUT  HIGH  GPIO
           OSCM26_ENABLE  PB22  OUT  HIGH  GPIO
           FEC_RESET      PB30  OUT  LOW   GPIO
           FEC_ENABLE     PB27  OUT  HIGH  GPIO
           OSCM26_ENABLE  PB22  OUT  HIGH  GPIO
@@ -233,7 +233,7 @@ static void fec_gpio_init(void)
        writel(0, IOMUXC_BASE_ADDR + 0x01D4);
        writel(0x40, IOMUXC_BASE_ADDR + 0x03CC);
 
        writel(0, IOMUXC_BASE_ADDR + 0x01D4);
        writel(0x40, IOMUXC_BASE_ADDR + 0x03CC);
 
-       /* 
+       /*
         * Set up the FEC_RESET_B and FEC_ENABLE GPIO pins.
         * Assert FEC_RESET_B, then power up the PHY by asserting
         * FEC_ENABLE, at the same time lifting FEC_RESET_B.
         * Set up the FEC_RESET_B and FEC_ENABLE GPIO pins.
         * Assert FEC_RESET_B, then power up the PHY by asserting
         * FEC_ENABLE, at the same time lifting FEC_RESET_B.
@@ -305,7 +305,7 @@ int tx25_mac_addr_program(unsigned char mac_addr[ETHER_ADDR_LEN])
 
                if ((fuse | mac_addr[i]) != mac_addr[i]) {
                        diag_printf("MAC address fuse cannot be programmed: fuse[%d]=0x%02x -> 0x%02x\n",
 
                if ((fuse | mac_addr[i]) != mac_addr[i]) {
                        diag_printf("MAC address fuse cannot be programmed: fuse[%d]=0x%02x -> 0x%02x\n",
-                                   i, fuse, mac_addr[i]);
+                                               i, fuse, mac_addr[i]);
                        return -1;
                }
                if (fuse != mac_addr[i]) {
                        return -1;
                }
                if (fuse != mac_addr[i]) {
@@ -331,7 +331,7 @@ int tx25_mac_addr_program(unsigned char mac_addr[ETHER_ADDR_LEN])
                        }
                        if (fuse_blow(0, i + ((SOC_MAC_ADDR_BASE & 0xff) >> 2), bit)) {
                                diag_printf("Failed to blow fuse bank 0 row %d bit %d\n",
                        }
                        if (fuse_blow(0, i + ((SOC_MAC_ADDR_BASE & 0xff) >> 2), bit)) {
                                diag_printf("Failed to blow fuse bank 0 row %d bit %d\n",
-                                           i, bit);
+                                                       i, bit);
                                ret = -1;
                                goto out;
                        }
                                ret = -1;
                                goto out;
                        }
index 42913243ed8fa6013794a3bac0589d9af771c71f..f24b037610be43effeb171fdfb1e9ce98a2480bf 100644 (file)
 /*
  * Translation Table Base Bit Masks
  */
 /*
  * Translation Table Base Bit Masks
  */
-#define ARM_TRANSLATION_TABLE_MASK               0xFFFFC000
+#define ARM_TRANSLATION_TABLE_MASK                              0xFFFFC000
 
 /*
  * Domain Access Control Bit Masks
  */
 
 /*
  * Domain Access Control Bit Masks
  */
-#define ARM_ACCESS_TYPE_NO_ACCESS(domain_num)    (0x0 << (domain_num)*2)
-#define ARM_ACCESS_TYPE_CLIENT(domain_num)       (0x1 << (domain_num)*2)
-#define ARM_ACCESS_TYPE_MANAGER(domain_num)      (0x3 << (domain_num)*2)
+#define ARM_ACCESS_TYPE_NO_ACCESS(domain_num)   (0x0 << ((domain_num) * 2))
+#define ARM_ACCESS_TYPE_CLIENT(domain_num)              (0x1 << ((domain_num) * 2))
+#define ARM_ACCESS_TYPE_MANAGER(domain_num)             (0x3 << ((domain_num) * 2))
 
 struct ARM_MMU_FIRST_LEVEL_FAULT {
 
 struct ARM_MMU_FIRST_LEVEL_FAULT {
-        unsigned int id : 2;
-        unsigned int sbz : 30;
+       unsigned int id : 2;
+       unsigned int sbz : 30;
 };
 
 #define ARM_MMU_FIRST_LEVEL_FAULT_ID 0x0
 
 struct ARM_MMU_FIRST_LEVEL_PAGE_TABLE {
 };
 
 #define ARM_MMU_FIRST_LEVEL_FAULT_ID 0x0
 
 struct ARM_MMU_FIRST_LEVEL_PAGE_TABLE {
-        unsigned int id : 2;
-        unsigned int imp : 2;
-        unsigned int domain : 4;
-        unsigned int sbz : 1;
-        unsigned int base_address : 23;
+       unsigned int id : 2;
+       unsigned int imp : 2;
+       unsigned int domain : 4;
+       unsigned int sbz : 1;
+       unsigned int base_address : 23;
 };
 
 #define ARM_MMU_FIRST_LEVEL_PAGE_TABLE_ID 0x1
 
 struct ARM_MMU_FIRST_LEVEL_SECTION {
 };
 
 #define ARM_MMU_FIRST_LEVEL_PAGE_TABLE_ID 0x1
 
 struct ARM_MMU_FIRST_LEVEL_SECTION {
-        unsigned int id : 2;
-        unsigned int b : 1;
-        unsigned int c : 1;
-        unsigned int imp : 1;
-        unsigned int domain : 4;
-        unsigned int sbz0 : 1;
-        unsigned int ap : 2;
-        unsigned int sbz1 : 8;
-        unsigned int base_address : 12;
+       unsigned int id : 2;
+       unsigned int b : 1;
+       unsigned int c : 1;
+       unsigned int imp : 1;
+       unsigned int domain : 4;
+       unsigned int sbz0 : 1;
+       unsigned int ap : 2;
+       unsigned int sbz1 : 8;
+       unsigned int base_address : 12;
 };
 
 #define ARM_MMU_FIRST_LEVEL_SECTION_ID 0x2
 
 struct ARM_MMU_FIRST_LEVEL_RESERVED {
 };
 
 #define ARM_MMU_FIRST_LEVEL_SECTION_ID 0x2
 
 struct ARM_MMU_FIRST_LEVEL_RESERVED {
-        unsigned int id : 2;
-        unsigned int sbz : 30;
+       unsigned int id : 2;
+       unsigned int sbz : 30;
 };
 
 #define ARM_MMU_FIRST_LEVEL_RESERVED_ID 0x3
 
 };
 
 #define ARM_MMU_FIRST_LEVEL_RESERVED_ID 0x3
 
-#define ARM_MMU_FIRST_LEVEL_DESCRIPTOR_ADDRESS(ttb_base, table_index) \
-        (unsigned long *)((unsigned long)(ttb_base) + ((table_index) << 2))
+#define ARM_MMU_FIRST_LEVEL_DESCRIPTOR_ADDRESS(ttb_base, table_index)  \
+       ((unsigned long *)(ttb_base) + (table_index))
 
 #define ARM_FIRST_LEVEL_PAGE_TABLE_SIZE 0x4000
 
 #define ARM_MMU_SECTION(ttb_base, actual_base, virtual_base,                   \
 
 #define ARM_FIRST_LEVEL_PAGE_TABLE_SIZE 0x4000
 
 #define ARM_MMU_SECTION(ttb_base, actual_base, virtual_base,                   \
-                        cacheable, bufferable, perm)                                   \
-    CYG_MACRO_START                                                                                                            \
-        register union ARM_MMU_FIRST_LEVEL_DESCRIPTOR desc;                            \
+                                               cacheable, bufferable, perm)                                    \
+       CYG_MACRO_START                                                                                                         \
+       register union ARM_MMU_FIRST_LEVEL_DESCRIPTOR desc;                                     \
                                                                                                                                                \
                                                                                                                                                \
-        desc.word = 0;                                                                                                 \
-        desc.section.id = ARM_MMU_FIRST_LEVEL_SECTION_ID;                              \
-        desc.section.domain = 0;                                                                               \
-        desc.section.c = cacheable;                                                                            \
-        desc.section.b = bufferable;                                                                   \
-        desc.section.ap = perm;                                                                                        \
-        desc.section.base_address = actual_base;                                               \
-        *ARM_MMU_FIRST_LEVEL_DESCRIPTOR_ADDRESS(ttb_base, virtual_base)        \
-                            = desc.word;                                                               \
-    CYG_MACRO_END
-
-#define X_ARM_MMU_SECTION(abase,vbase,size,cache,buff,access) {                \
-       int i; int j = abase; int k = vbase;                                                    \
-       for (i = size; i > 0 ; i--, j++, k++) {                                                 \
-        ARM_MMU_SECTION(ttb_base, j, k, cache, buff, access);          \
-       }                                                                                                                               \
-}
+       desc.word = 0;                                                                                                          \
+       desc.section.id = ARM_MMU_FIRST_LEVEL_SECTION_ID;                                       \
+       desc.section.domain = 0;                                                                                        \
+       desc.section.c = cacheable;                                                                                     \
+       desc.section.b = bufferable;                                                                            \
+       desc.section.ap = perm;                                                                                         \
+       desc.section.base_address = actual_base;                                                        \
+       *ARM_MMU_FIRST_LEVEL_DESCRIPTOR_ADDRESS(ttb_base, virtual_base) = desc.word; \
+       CYG_MACRO_END
+
+#define X_ARM_MMU_SECTION(abase,vbase,size,cache,buff,access)                  \
+       CYG_MACRO_START                                                                                                         \
+               int i; int j = abase; int k = vbase;                                                    \
+               for (i = size; i > 0 ; i--, j++, k++) {                                                 \
+                       ARM_MMU_SECTION(ttb_base, j, k, cache, buff, access);           \
+               }                                                                                                                               \
+       CYG_MACRO_END
 
 union ARM_MMU_FIRST_LEVEL_DESCRIPTOR {
 
 union ARM_MMU_FIRST_LEVEL_DESCRIPTOR {
-        unsigned long word;
-        struct ARM_MMU_FIRST_LEVEL_FAULT fault;
-        struct ARM_MMU_FIRST_LEVEL_PAGE_TABLE page_table;
-        struct ARM_MMU_FIRST_LEVEL_SECTION section;
-        struct ARM_MMU_FIRST_LEVEL_RESERVED reserved;
+       unsigned long word;
+       struct ARM_MMU_FIRST_LEVEL_FAULT fault;
+       struct ARM_MMU_FIRST_LEVEL_PAGE_TABLE page_table;
+       struct ARM_MMU_FIRST_LEVEL_SECTION section;
+       struct ARM_MMU_FIRST_LEVEL_RESERVED reserved;
 };
 
 };
 
-#define ARM_UNCACHEABLE                         0
-#define ARM_CACHEABLE                           1
-#define ARM_UNBUFFERABLE                        0
-#define ARM_BUFFERABLE                          1
+#define ARM_UNCACHEABLE                                                        0
+#define ARM_CACHEABLE                                                  1
+#define ARM_UNBUFFERABLE                                               0
+#define ARM_BUFFERABLE                                                 1
 
 
-#define ARM_ACCESS_PERM_NONE_NONE               0
-#define ARM_ACCESS_PERM_RO_NONE                 0
-#define ARM_ACCESS_PERM_RO_RO                   0
-#define ARM_ACCESS_PERM_RW_NONE                 1
-#define ARM_ACCESS_PERM_RW_RO                   2
-#define ARM_ACCESS_PERM_RW_RW                   3
+#define ARM_ACCESS_PERM_NONE_NONE                              0
+#define ARM_ACCESS_PERM_RO_NONE                                        0
+#define ARM_ACCESS_PERM_RO_RO                                  0
+#define ARM_ACCESS_PERM_RW_NONE                                        1
+#define ARM_ACCESS_PERM_RW_RO                                  2
+#define ARM_ACCESS_PERM_RW_RW                                  3
 
 /*
  * Initialization for the Domain Access Control Register
  */
 
 /*
  * Initialization for the Domain Access Control Register
  */
-#define ARM_ACCESS_DACR_DEFAULT      (          \
-        ARM_ACCESS_TYPE_MANAGER(0)    |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(1)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(2)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(3)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(4)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(5)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(6)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(7)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(8)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(9)  |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(10) |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(11) |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(12) |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(13) |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(14) |         \
-        ARM_ACCESS_TYPE_NO_ACCESS(15) )
-/*
- * translate the virtual address of ram space to physical address
- * It is dependent on the implementation of hal_mmu_init
- */
-#ifndef RAM_BANK0_SIZE
-#warning using SDRAM_SIZE for RAM_BANK0_SIZE
-#define RAM_BANK0_SIZE         SDRAM_SIZE
-#endif
-
-static unsigned long __inline__ hal_virt_to_phy(unsigned long virt)
-{
-       /* SDRAM mappings:
-          80000000 -> 80000000
-          90000000 -> 80000000 + (SDRAM_SIZE / 2)
-        */
-       if (virt < 0x08000000) {
-               return virt | (virt < RAM_BANK0_SIZE ? CSD0_BASE_ADDR : CSD1_BASE_ADDR);
-       }
-       if ((virt & 0xF0000000) == CSD0_BASE_ADDR) {
-               virt &= ~0x08000000;
-               if (virt >= CSD0_BASE_ADDR + RAM_BANK0_SIZE) {
-                       virt = virt - CSD0_BASE_ADDR + CSD1_BASE_ADDR - RAM_BANK0_SIZE;
-               }
-       }
-       return virt;
-}
-
-/*
- * remap the physical address of ram space to uncacheable virtual address space
- * It is dependent on the implementation of hal_mmu_init
- */
-static unsigned long __inline__ hal_ioremap_nocache(unsigned long phy)
-{
-       /* 0x88000000~0x88FFFFFF is uncacheable memory space which is mapped to SDRAM */
-       if ((phy & 0xF0000000) == CSD0_BASE_ADDR) {
-               phy |= 0x08000000;
-       }
-       if ((phy & 0xF0000000) == CSD1_BASE_ADDR) {
-               phy = (phy - CSD1_BASE_ADDR + CSD0_BASE_ADDR + RAM_BANK0_SIZE) | 0x08000000;
-       }
-       return phy;
-}
+#define ARM_ACCESS_DACR_DEFAULT                 (                      \
+               ARM_ACCESS_TYPE_MANAGER(0)        |                     \
+               ARM_ACCESS_TYPE_NO_ACCESS(1)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(2)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(3)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(4)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(5)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(6)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(7)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(8)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(9)  |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(10) |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(11) |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(12) |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(13) |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(14) |                 \
+               ARM_ACCESS_TYPE_NO_ACCESS(15) )
 
 // ------------------------------------------------------------------------
 #endif // ifndef CYGONCE_HAL_MM_H
 // End of hal_mm.h
 
 // ------------------------------------------------------------------------
 #endif // ifndef CYGONCE_HAL_MM_H
 // End of hal_mm.h
-
-
-
-
-
index 672f6112c3e0ba7b11168ed2a9b953d8963ea6e2..1a6944f4376e1691c1dbae3655126d3d19f946c8 100644 (file)
@@ -57,7 +57,7 @@
 #else /* __ASSEMBLER__ */
 #define UL(a)           (a##UL)
 
 #else /* __ASSEMBLER__ */
 #define UL(a)           (a##UL)
 
-extern char HAL_PLATFORM_EXTRA[];
+extern char HAL_PLATFORM_EXTRA[55];
 #define REG8_VAL(a)                     ((unsigned char)(a))
 #define REG16_VAL(a)            ((unsigned short)(a))
 #define REG32_VAL(a)            ((unsigned int)(a))
 #define REG8_VAL(a)                     ((unsigned char)(a))
 #define REG16_VAL(a)            ((unsigned short)(a))
 #define REG32_VAL(a)            ((unsigned int)(a))
index a125ccd09290fa89ab6c2a343bb56e1d2d3b5924..f2cf9b6c08dce80bfc34cf9e75a754f870f23851 100644 (file)
@@ -254,7 +254,7 @@ typedef struct {
 static channel_data_t channels[] = {
 #if CYGHWR_HAL_ARM_SOC_UART1 != 0
        {(volatile struct mxc_serial*)UART1_BASE_ADDR, 1000,
 static channel_data_t channels[] = {
 #if CYGHWR_HAL_ARM_SOC_UART1 != 0
        {(volatile struct mxc_serial*)UART1_BASE_ADDR, 1000,
-         CYGNUM_HAL_INTERRUPT_UART1, CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_BAUD},
+        CYGNUM_HAL_INTERRUPT_UART1, CYGNUM_HAL_VIRTUAL_VECTOR_CONSOLE_CHANNEL_BAUD},
 #endif
 #if CYGHWR_HAL_ARM_SOC_UART2 != 0
        {(volatile struct mxc_serial*)UART2_BASE_ADDR, 1000,
 #endif
 #if CYGHWR_HAL_ARM_SOC_UART2 != 0
        {(volatile struct mxc_serial*)UART2_BASE_ADDR, 1000,
@@ -377,7 +377,7 @@ void cyg_hal_plf_serial_putc(void *__ch_data, char c)
 }
 
 static cyg_bool cyg_hal_plf_serial_getc_nonblock(void *__ch_data,
 }
 
 static cyg_bool cyg_hal_plf_serial_getc_nonblock(void *__ch_data,
-                                                                                                cyg_uint8 *ch)
+                                                                                               cyg_uint8 *ch)
 {
        channel_data_t *chan = __ch_data;
        volatile struct mxc_serial *base = chan->base;
 {
        channel_data_t *chan = __ch_data;
        volatile struct mxc_serial *base = chan->base;
@@ -403,7 +403,7 @@ cyg_uint8 cyg_hal_plf_serial_getc(void *__ch_data)
 }
 
 static void cyg_hal_plf_serial_write(void *__ch_data, const cyg_uint8 *__buf,
 }
 
 static void cyg_hal_plf_serial_write(void *__ch_data, const cyg_uint8 *__buf,
-                                                                        cyg_uint32 __len)
+                                                                       cyg_uint32 __len)
 {
        CYGARC_HAL_SAVE_GP();
 
 {
        CYGARC_HAL_SAVE_GP();
 
@@ -425,7 +425,7 @@ static void cyg_hal_plf_serial_read(void *__ch_data, cyg_uint8 *__buf,
 }
 
 cyg_bool cyg_hal_plf_serial_getc_timeout(void *__ch_data,
 }
 
 cyg_bool cyg_hal_plf_serial_getc_timeout(void *__ch_data,
-                                                                                cyg_uint8 *ch)
+                                                                               cyg_uint8 *ch)
 {
        int delay_count;
        channel_data_t *chan = __ch_data;
 {
        int delay_count;
        channel_data_t *chan = __ch_data;
@@ -447,7 +447,7 @@ cyg_bool cyg_hal_plf_serial_getc_timeout(void *__ch_data,
 }
 
 static int cyg_hal_plf_serial_control(void *__ch_data,
 }
 
 static int cyg_hal_plf_serial_control(void *__ch_data,
-                                                                         __comm_control_cmd_t __func, ...)
+                                                                       __comm_control_cmd_t __func, ...)
 {
        static int irq_state = 0;
        channel_data_t *chan = __ch_data;
 {
        static int irq_state = 0;
        channel_data_t *chan = __ch_data;
@@ -498,7 +498,7 @@ static int cyg_hal_plf_serial_control(void *__ch_data,
 }
 
 static int cyg_hal_plf_serial_isr(void *__ch_data, int *__ctrlc,
 }
 
 static int cyg_hal_plf_serial_isr(void *__ch_data, int *__ctrlc,
-                                                                 CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
+                                                               CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
 {
        int res = 0;
        channel_data_t *chan = __ch_data;
 {
        int res = 0;
        channel_data_t *chan = __ch_data;
index 85ea66f203d793513fd141ad099ce50d6cf3ae27..13283fbc7674f1d613a1ada05d877c949441d75c 100644 (file)
 #include <pkgconf/system.h>
 #include CYGBLD_HAL_PLATFORM_H
 
 #include <pkgconf/system.h>
 #include CYGBLD_HAL_PLATFORM_H
 
-#include <cyg/infra/cyg_type.h>         // base types
-#include <cyg/infra/cyg_trac.h>         // tracing macros
-#include <cyg/infra/cyg_ass.h>          // assertion macros
+#include <cyg/infra/cyg_type.h>                        // base types
+#include <cyg/infra/cyg_trac.h>                        // tracing macros
+#include <cyg/infra/cyg_ass.h>                 // assertion macros
 
 
-#include <cyg/hal/hal_misc.h>           // Size constants
-#include <cyg/hal/hal_io.h>             // IO macros
-#include <cyg/hal/hal_arch.h>           // Register state info
+#include <cyg/hal/hal_misc.h>                  // Size constants
+#include <cyg/hal/hal_io.h>                            // IO macros
+#include <cyg/hal/hal_arch.h>                  // Register state info
 #include <cyg/hal/hal_diag.h>
 #include <cyg/hal/hal_diag.h>
-#include <cyg/hal/hal_intr.h>           // Interrupt names
-#include <cyg/hal/hal_cache.h>          // Cache control
-#include <cyg/hal/hal_soc.h>            // Hardware definitions
-#include <cyg/hal/hal_mm.h>             // MMap table definitions
+#include <cyg/hal/hal_intr.h>                  // Interrupt names
+#include <cyg/hal/hal_cache.h>                 // Cache control
+#include <cyg/hal/hal_soc.h>                   // Hardware definitions
+#include <cyg/hal/hal_mm.h>                            // MMap table definitions
 
 
-#include <cyg/infra/diag.h>             // diag_printf
+#include <cyg/infra/diag.h>                            // diag_printf
 #include <cyg/io/imx_nfc.h>
 
 // Most initialization has already been done before we get here.
 #include <cyg/io/imx_nfc.h>
 
 // Most initialization has already been done before we get here.
 
 externC void plf_hardware_init(void);
 
 
 externC void plf_hardware_init(void);
 
-#define IIM_PROD_REV_SH         3
-#define IIM_PROD_REV_LEN        5
-#define IIM_SREV_REV_SH         4
-#define IIM_SREV_REV_LEN        4
+#define IIM_PROD_REV_SH                        3
+#define IIM_PROD_REV_LEN               5
+#define IIM_SREV_REV_SH                        4
+#define IIM_SREV_REV_LEN               4
 
 
-#define PROD_SIGNATURE_MX25     0x1F
+#define PROD_SIGNATURE_MX25            0x1F
 
 
-#define PROD_SIGNATURE_SUPPORTED_1  PROD_SIGNATURE_MX25
+#define PROD_SIGNATURE_SUPPORTED_1     PROD_SIGNATURE_MX25
 
 
-#define CHIP_VERSION_NONE           0xFFFFFFFF      // invalid product ID
-#define CHIP_VERSION_UNKNOWN        0xDEADBEEF      // invalid chip rev
+#define CHIP_VERSION_NONE                      0xFFFFFFFF              // invalid product ID
+#define CHIP_VERSION_UNKNOWN           0xDEADBEEF              // invalid chip rev
 
 #define PART_NUMBER_OFFSET                     12
 #define MAJOR_NUMBER_OFFSET                    4
 
 #define PART_NUMBER_OFFSET                     12
 #define MAJOR_NUMBER_OFFSET                    4
@@ -99,91 +99,91 @@ static int find_correct_chip;
  */
 static int read_system_rev(void)
 {
  */
 static int read_system_rev(void)
 {
-    int val;
+       int val;
 
 
-    val = readl(IIM_BASE_ADDR + IIM_PREV_OFF);
+       val = readl(IIM_BASE_ADDR + IIM_PREV_OFF);
 
 
-    system_rev = 0x25 << PART_NUMBER_OFFSET; /* For MX25 Platform*/
+       system_rev = 0x25 << PART_NUMBER_OFFSET; /* For MX25 Platform*/
        /* If the IIM doesn't contain a valid product signature, return
        /* If the IIM doesn't contain a valid product signature, return
-     * the lowest revision number */
-    if ((MXC_GET_FIELD(val, IIM_PROD_REV_LEN, IIM_PROD_REV_SH) !=
-                       PROD_SIGNATURE_SUPPORTED_1)) {
+        * the lowest revision number */
+       if ((MXC_GET_FIELD(val, IIM_PROD_REV_LEN, IIM_PROD_REV_SH) !=
+                       PROD_SIGNATURE_SUPPORTED_1)) {
 #if 0
 #if 0
-        return CHIP_VERSION_NONE;
+               return CHIP_VERSION_NONE;
 #endif
 #endif
-    }
+       }
 
 
-    /* Now trying to retrieve the silicon rev from IIM's SREV register */
-    return readl(IIM_BASE_ADDR + IIM_SREV_OFF);
+       /* Now trying to retrieve the silicon rev from IIM's SREV register */
+       return readl(IIM_BASE_ADDR + IIM_SREV_OFF);
 }
 
 extern nfc_setup_func_t *nfc_setup;
 unsigned int mxc_nfc_soc_setup(unsigned int pg_sz, unsigned int io_sz,
 }
 
 extern nfc_setup_func_t *nfc_setup;
 unsigned int mxc_nfc_soc_setup(unsigned int pg_sz, unsigned int io_sz,
-                                      unsigned int is_mlc, unsigned int num_of_chips);
+                                                       unsigned int is_mlc, unsigned int num_of_chips);
 void hal_hardware_init(void)
 {
 void hal_hardware_init(void)
 {
-    int ver;
-
-    ver = read_system_rev();
-    find_correct_chip = ver;
-
-    if (ver != CHIP_VERSION_NONE) {
-        /* Valid product revision found. Check actual silicon rev from the ROM code. */
-        if (ver == 0x0) {
-            HAL_PLATFORM_EXTRA[5] = '1';
-            HAL_PLATFORM_EXTRA[7] = '0';
-            system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
-            system_rev |= 0 << MINOR_NUMBER_OFFSET; /*Minor Number*/
-        } else if (ver == 0x1) {
-            HAL_PLATFORM_EXTRA[5] = '1';
-            HAL_PLATFORM_EXTRA[7] = '1';
-            system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
-            system_rev |= 1 << MINOR_NUMBER_OFFSET; /*Minor Number*/
-        } else {
-            HAL_PLATFORM_EXTRA[5] = 'z';
-            HAL_PLATFORM_EXTRA[7] = 'z';
-            system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
-            system_rev |= 0 << MINOR_NUMBER_OFFSET; /*Minor Number*/
-            find_correct_chip = CHIP_VERSION_UNKNOWN;
-        }
-    }
-
-    // Mask all interrupts
-    writel(0xFFFFFFFF, ASIC_NIMASK);
-
-    // Make all interrupts do IRQ and not FIQ
-    // FIXME: Change this if you use FIQs.
-    writel(0, ASIC_INTTYPEH);
-    writel(0, ASIC_INTTYPEL);
-
-    // Enable caches
-    HAL_ICACHE_ENABLE();
-    HAL_DCACHE_ENABLE();
-
-    // enable EPIT and start it with 32KHz input clock
-    writel(0x00010000, EPIT_BASE_ADDR + EPITCR);
-
-    // make sure reset is complete
-    while ((readl(EPIT_BASE_ADDR + EPITCR) & 0x10000) != 0) {
-    }
-
-    writel(0x030E0002, EPIT_BASE_ADDR + EPITCR);
-    writel(0x030E0003, EPIT_BASE_ADDR + EPITCR);
-
-    writel(0, EPIT_BASE_ADDR + EPITCMPR);  // always compare with 0
-
-    if ((readw(WDOG_BASE_ADDR) & 4) != 0) {
-        // increase the WDOG timeout value to the max
-        writew(readw(WDOG_BASE_ADDR) | 0xFF00, WDOG_BASE_ADDR);
-    }
-
-    // Perform any platform specific initializations
-    plf_hardware_init();
-
-    // Set up eCos/ROM interfaces
-    hal_if_init();
-
-    nfc_setup = (nfc_setup_func_t*)mxc_nfc_soc_setup;
+       int ver;
+
+       ver = read_system_rev();
+       find_correct_chip = ver;
+
+       if (ver != CHIP_VERSION_NONE) {
+               /* Valid product revision found. Check actual silicon rev from the ROM code. */
+               if (ver == 0x0) {
+                       HAL_PLATFORM_EXTRA[5] = '1';
+                       HAL_PLATFORM_EXTRA[7] = '0';
+                       system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
+                       system_rev |= 0 << MINOR_NUMBER_OFFSET; /*Minor Number*/
+               } else if (ver == 0x1) {
+                       HAL_PLATFORM_EXTRA[5] = '1';
+                       HAL_PLATFORM_EXTRA[7] = '1';
+                       system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
+                       system_rev |= 1 << MINOR_NUMBER_OFFSET; /*Minor Number*/
+               } else {
+                       HAL_PLATFORM_EXTRA[5] = 'z';
+                       HAL_PLATFORM_EXTRA[7] = 'z';
+                       system_rev |= 1 << MAJOR_NUMBER_OFFSET; /*Major Number*/
+                       system_rev |= 0 << MINOR_NUMBER_OFFSET; /*Minor Number*/
+                       find_correct_chip = CHIP_VERSION_UNKNOWN;
+               }
+       }
+
+       // Mask all interrupts
+       writel(0xFFFFFFFF, ASIC_NIMASK);
+
+       // Make all interrupts do IRQ and not FIQ
+       // FIXME: Change this if you use FIQs.
+       writel(0, ASIC_INTTYPEH);
+       writel(0, ASIC_INTTYPEL);
+
+       // Enable caches
+       HAL_ICACHE_ENABLE();
+       HAL_DCACHE_ENABLE();
+
+       // enable EPIT and start it with 32KHz input clock
+       writel(0x00010000, EPIT_BASE_ADDR + EPITCR);
+
+       // make sure reset is complete
+       while ((readl(EPIT_BASE_ADDR + EPITCR) & 0x10000) != 0) {
+       }
+
+       writel(0x030E0002, EPIT_BASE_ADDR + EPITCR);
+       writel(0x030E0003, EPIT_BASE_ADDR + EPITCR);
+
+       writel(0, EPIT_BASE_ADDR + EPITCMPR);  // always compare with 0
+
+       if ((readw(WDOG_BASE_ADDR) & 4) != 0) {
+               // increase the WDOG timeout value to the max
+               writew(readw(WDOG_BASE_ADDR) | 0xFF00, WDOG_BASE_ADDR);
+       }
+
+       // Perform any platform specific initializations
+       plf_hardware_init();
+
+       // Set up eCos/ROM interfaces
+       hal_if_init();
+
+       nfc_setup = (nfc_setup_func_t*)mxc_nfc_soc_setup;
 }
 
 // -------------------------------------------------------------------------
 }
 
 // -------------------------------------------------------------------------
@@ -229,14 +229,14 @@ unsigned int hal_timer_count(void)
        return 0 - readl(EPIT_BASE_ADDR + EPITCNR);
 }
 
        return 0 - readl(EPIT_BASE_ADDR + EPITCNR);
 }
 
-#define WDT_MAGIC_1             0x5555
-#define WDT_MAGIC_2             0xAAAA
-#define MXC_WDT_WSR             0x2
+#define WDT_MAGIC_1                            0x5555
+#define WDT_MAGIC_2                            0xAAAA
+#define MXC_WDT_WSR                            0x2
 
 unsigned int i2c_base_addr[] = {
 
 unsigned int i2c_base_addr[] = {
-    I2C_BASE_ADDR,
-    I2C2_BASE_ADDR,
-    I2C3_BASE_ADDR
+       I2C_BASE_ADDR,
+       I2C2_BASE_ADDR,
+       I2C3_BASE_ADDR
 };
 unsigned int i2c_num = 3;
 
 };
 unsigned int i2c_num = 3;
 
@@ -246,30 +246,30 @@ static unsigned int led_on = 0;
 //
 void hal_delay_us(unsigned int usecs)
 {
 //
 void hal_delay_us(unsigned int usecs)
 {
-    /*
-     * This causes overflow.
-     * unsigned int delayCount = (usecs * 32000) / 1000000;
-     * So use the following one instead
-     */
+       /*
+        * This causes overflow.
+        * unsigned int delayCount = (usecs * 32000) / 1000000;
+        * So use the following one instead
+        */
        unsigned int delayCount = (usecs * 512) / 16000;
 
        unsigned int delayCount = (usecs * 512) / 16000;
 
-    if (delayCount == 0) {
-        return;
-    }
+       if (delayCount == 0) {
+               return;
+       }
 
 
-    // issue the service sequence instructions
-    if ((readw(WDOG_BASE_ADDR) & 4) != 0) {
-        writew(WDT_MAGIC_1, WDOG_BASE_ADDR + MXC_WDT_WSR);
-        writew(WDT_MAGIC_2, WDOG_BASE_ADDR + MXC_WDT_WSR);
-    }
+       // issue the service sequence instructions
+       if ((readw(WDOG_BASE_ADDR) & 4) != 0) {
+               writew(WDT_MAGIC_1, WDOG_BASE_ADDR + MXC_WDT_WSR);
+               writew(WDT_MAGIC_2, WDOG_BASE_ADDR + MXC_WDT_WSR);
+       }
 
 
-    writel(0x01, EPIT_BASE_ADDR + EPITSR); // clear the compare status bit
+       writel(0x01, EPIT_BASE_ADDR + EPITSR); // clear the compare status bit
 
 
-    writel(delayCount, EPIT_BASE_ADDR + EPITLR);
+       writel(delayCount, EPIT_BASE_ADDR + EPITLR);
 
 
-    while ((0x1 & readl(EPIT_BASE_ADDR + EPITSR)) == 0); // return until compare bit is set
-    if ((++led_on % 2000) == 0)
-        BOARD_DEBUG_LED(0);
+       while ((0x1 & readl(EPIT_BASE_ADDR + EPITSR)) == 0); // return until compare bit is set
+       if ((++led_on % 2000) == 0)
+               BOARD_DEBUG_LED(0);
 }
 
 // -------------------------------------------------------------------------
 }
 
 // -------------------------------------------------------------------------
@@ -279,16 +279,16 @@ void hal_delay_us(unsigned int usecs)
 int hal_IRQ_handler(void)
 {
 #ifdef HAL_EXTENDED_IRQ_HANDLER
 int hal_IRQ_handler(void)
 {
 #ifdef HAL_EXTENDED_IRQ_HANDLER
-    cyg_uint32 index;
+       cyg_uint32 index;
 
 
-    // Use platform specific IRQ handler, if defined
-    // Note: this macro should do a 'return' with the appropriate
-    // interrupt number if such an extended interrupt exists.  The
-    // assumption is that the line after the macro starts 'normal' processing.
-    HAL_EXTENDED_IRQ_HANDLER(index);
+       // Use platform specific IRQ handler, if defined
+       // Note: this macro should do a 'return' with the appropriate
+       // interrupt number if such an extended interrupt exists.  The
+       // assumption is that the line after the macro starts 'normal' processing.
+       HAL_EXTENDED_IRQ_HANDLER(index);
 #endif
 
 #endif
 
-    return CYGNUM_HAL_INTERRUPT_NONE; // This shouldn't happen!
+       return CYGNUM_HAL_INTERRUPT_NONE; // This shouldn't happen!
 }
 
 //
 }
 
 //
@@ -299,10 +299,10 @@ void hal_interrupt_mask(int vector)
 {
 //    diag_printf("6hal_interrupt_mask(vector=%d) \n", vector);
 #ifdef HAL_EXTENDED_INTERRUPT_MASK
 {
 //    diag_printf("6hal_interrupt_mask(vector=%d) \n", vector);
 #ifdef HAL_EXTENDED_INTERRUPT_MASK
-    // Use platform specific handling, if defined
-    // Note: this macro should do a 'return' for "extended" values of 'vector'
-    // Normal vectors are handled by code subsequent to the macro call.
-    HAL_EXTENDED_INTERRUPT_MASK(vector);
+       // Use platform specific handling, if defined
+       // Note: this macro should do a 'return' for "extended" values of 'vector'
+       // Normal vectors are handled by code subsequent to the macro call.
+       HAL_EXTENDED_INTERRUPT_MASK(vector);
 #endif
 }
 
 #endif
 }
 
@@ -311,10 +311,10 @@ void hal_interrupt_unmask(int vector)
 //    diag_printf("7hal_interrupt_unmask(vector=%d) \n", vector);
 
 #ifdef HAL_EXTENDED_INTERRUPT_UNMASK
 //    diag_printf("7hal_interrupt_unmask(vector=%d) \n", vector);
 
 #ifdef HAL_EXTENDED_INTERRUPT_UNMASK
-    // Use platform specific handling, if defined
-    // Note: this macro should do a 'return' for "extended" values of 'vector'
-    // Normal vectors are handled by code subsequent to the macro call.
-    HAL_EXTENDED_INTERRUPT_UNMASK(vector);
+       // Use platform specific handling, if defined
+       // Note: this macro should do a 'return' for "extended" values of 'vector'
+       // Normal vectors are handled by code subsequent to the macro call.
+       HAL_EXTENDED_INTERRUPT_UNMASK(vector);
 #endif
 }
 
 #endif
 }
 
@@ -323,10 +323,10 @@ void hal_interrupt_acknowledge(int vector)
 
 //    diag_printf("8hal_interrupt_acknowledge(vector=%d) \n", vector);
 #ifdef HAL_EXTENDED_INTERRUPT_UNMASK
 
 //    diag_printf("8hal_interrupt_acknowledge(vector=%d) \n", vector);
 #ifdef HAL_EXTENDED_INTERRUPT_UNMASK
-    // Use platform specific handling, if defined
-    // Note: this macro should do a 'return' for "extended" values of 'vector'
-    // Normal vectors are handled by code subsequent to the macro call.
-    HAL_EXTENDED_INTERRUPT_ACKNOWLEDGE(vector);
+       // Use platform specific handling, if defined
+       // Note: this macro should do a 'return' for "extended" values of 'vector'
+       // Normal vectors are handled by code subsequent to the macro call.
+       HAL_EXTENDED_INTERRUPT_ACKNOWLEDGE(vector);
 #endif
 }
 
 #endif
 }
 
@@ -334,10 +334,10 @@ void hal_interrupt_configure(int vector, int level, int up)
 {
 
 #ifdef HAL_EXTENDED_INTERRUPT_CONFIGURE
 {
 
 #ifdef HAL_EXTENDED_INTERRUPT_CONFIGURE
-    // Use platform specific handling, if defined
-    // Note: this macro should do a 'return' for "extended" values of 'vector'
-    // Normal vectors are handled by code subsequent to the macro call.
-    HAL_EXTENDED_INTERRUPT_CONFIGURE(vector, level, up);
+       // Use platform specific handling, if defined
+       // Note: this macro should do a 'return' for "extended" values of 'vector'
+       // Normal vectors are handled by code subsequent to the macro call.
+       HAL_EXTENDED_INTERRUPT_CONFIGURE(vector, level, up);
 #endif
 }
 
 #endif
 }
 
@@ -345,44 +345,44 @@ void hal_interrupt_set_level(int vector, int level)
 {
 
 #ifdef HAL_EXTENDED_INTERRUPT_SET_LEVEL
 {
 
 #ifdef HAL_EXTENDED_INTERRUPT_SET_LEVEL
-    // Use platform specific handling, if defined
-    // Note: this macro should do a 'return' for "extended" values of 'vector'
-    // Normal vectors are handled by code subsequent to the macro call.
-    HAL_EXTENDED_INTERRUPT_SET_LEVEL(vector, level);
+       // Use platform specific handling, if defined
+       // Note: this macro should do a 'return' for "extended" values of 'vector'
+       // Normal vectors are handled by code subsequent to the macro call.
+       HAL_EXTENDED_INTERRUPT_SET_LEVEL(vector, level);
 #endif
 
 #endif
 
-    // Interrupt priorities are not configurable.
+       // Interrupt priorities are not configurable.
 }
 
 unsigned int mxc_nfc_soc_setup(unsigned int pg_sz, unsigned int io_sz, unsigned int is_mlc,
                                                           unsigned int num_of_chips)
 {
 }
 
 unsigned int mxc_nfc_soc_setup(unsigned int pg_sz, unsigned int io_sz, unsigned int is_mlc,
                                                           unsigned int num_of_chips)
 {
-    unsigned int tmp ;
-    if (is_mlc) {
-        tmp = readw(NAND_REG_BASE + NAND_FLASH_CONFIG1_REG_OFF) | (1 << 8);
-    } else {
+       unsigned int tmp ;
+       if (is_mlc) {
+               tmp = readw(NAND_REG_BASE + NAND_FLASH_CONFIG1_REG_OFF) | (1 << 8);
+       } else {
                tmp = readw(NAND_REG_BASE + NAND_FLASH_CONFIG1_REG_OFF) & ~(1 << 8);
                tmp = readw(NAND_REG_BASE + NAND_FLASH_CONFIG1_REG_OFF) & ~(1 << 8);
-    }
+       }
 
 
-    writew(tmp, NAND_REG_BASE + NAND_FLASH_CONFIG1_REG_OFF);
-    tmp = readl(CCM_BASE_ADDR + CLKCTL_RCSR);
-    if (io_sz == 16) {
-        tmp |= (1 << 14);
-    } else {
+       writew(tmp, NAND_REG_BASE + NAND_FLASH_CONFIG1_REG_OFF);
+       tmp = readl(CCM_BASE_ADDR + CLKCTL_RCSR);
+       if (io_sz == 16) {
+               tmp |= (1 << 14);
+       } else {
                tmp &= ~(1 << 14);
                tmp &= ~(1 << 14);
-    }
+       }
 
 
-    tmp &= ~(3<<8);
+       tmp &= ~(3<<8);
        switch (pg_sz) {
        switch (pg_sz) {
-    case 2048:
+       case 2048:
                tmp |= (1<<8);
                break;
                tmp |= (1<<8);
                break;
-    case 4096:
+       case 4096:
                tmp |= (1<<9);
                break;
                tmp |= (1<<9);
                break;
-    }
+       }
 
 
-    writel(tmp, CCM_BASE_ADDR + CLKCTL_RCSR);
+       writel(tmp, CCM_BASE_ADDR + CLKCTL_RCSR);
        return MXC_NFC_V1_1;
 }
 
        return MXC_NFC_V1_1;
 }
 
@@ -440,12 +440,12 @@ RedBoot_init(check_reset_source, RedBoot_INIT_LAST);
 
 static void check_correct_chip(void)
 {
 
 static void check_correct_chip(void)
 {
-    if (find_correct_chip == CHIP_VERSION_UNKNOWN) {
-        diag_printf("Unrecognized chip version: 0x%x!!!\n", read_system_rev());
-        diag_printf("Assuming chip version=0x%x\n", system_rev);
-    } else if (find_correct_chip == CHIP_VERSION_NONE) {
-        diag_printf("Unrecognized chip: 0x%x!!!\n", readl(IIM_BASE_ADDR + IIM_PREV_OFF));
-    }
+       if (find_correct_chip == CHIP_VERSION_UNKNOWN) {
+               diag_printf("Unrecognized chip version: 0x%x!!!\n", read_system_rev());
+               diag_printf("Assuming chip version=0x%x\n", system_rev);
+       } else if (find_correct_chip == CHIP_VERSION_NONE) {
+               diag_printf("Unrecognized chip: 0x%x!!!\n", readl(IIM_BASE_ADDR + IIM_PREV_OFF));
+       }
 }
 
 RedBoot_init(check_correct_chip, RedBoot_INIT_LAST);
 }
 
 RedBoot_init(check_correct_chip, RedBoot_INIT_LAST);
index 2ce2b447bd5cf1350cfa287894967570ce678ffc..b554fc01e0c50ef075141521773ece699257b6fe 100644 (file)
 //              combination of libbsp and vectors already in use by some
 //              eCos platforms.
 // Usage:       #include <cyg/hal/hal_if.h>
 //              combination of libbsp and vectors already in use by some
 //              eCos platforms.
 // Usage:       #include <cyg/hal/hal_if.h>
-//                           
+//
 //####DESCRIPTIONEND####
 //
 //=============================================================================
 
 //####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>
 
 #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>
 // 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
 #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 {
 // 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;
 
 
 
 } __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];
 
 
 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,
 
 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,
 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 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);
 
 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
 }
 
 #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.
 // 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_) \
 #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_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_) \
 #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 *)
 
 __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
 
 //--------------------------------------------------------------------------
 
 #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.
 // 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).
 
 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
 
 
 // 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
 //               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
 
 // 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,
 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);
 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 {
 // 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
 
 };
 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() \
 #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
 //
 //
 // 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 *)
 #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)
 {
 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_)
 }
 #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_)
 __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 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:
 
 
 // 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
 
 
 #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) \
 #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
 // 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
 #endif
 
 #endif // CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
index 84f22f623606a5dca31365e1e521b142e66efe5c..5131d799939ddaa78cf4f265060abb22e1659964 100644 (file)
@@ -46,7 +46,7 @@
 // Purpose:     Helper functions for stub, specific to eCos HAL
 // Description: Parts of the GDB stub requirements are provided by
 //              the eCos HAL, rather than target and/or board specific
 // Purpose:     Helper functions for stub, specific to eCos HAL
 // Description: Parts of the GDB stub requirements are provided by
 //              the eCos HAL, rather than target and/or board specific
-//              code. 
+//              code.
 //
 //####DESCRIPTIONEND####
 //
 //
 //####DESCRIPTIONEND####
 //
@@ -96,7 +96,7 @@
 HAL_SavedRegisters *_hal_registers;
 target_register_t registers[HAL_STUB_REGISTERS_SIZE];
 target_register_t alt_registers[HAL_STUB_REGISTERS_SIZE] ;  // Thread or saved process state
 HAL_SavedRegisters *_hal_registers;
 target_register_t registers[HAL_STUB_REGISTERS_SIZE];
 target_register_t alt_registers[HAL_STUB_REGISTERS_SIZE] ;  // Thread or saved process state
-target_register_t * _registers = registers;                 // Pointer to current set of registers
+target_register_t *_registers = registers;                 // Pointer to current set of registers
 #ifndef CYGPKG_REDBOOT
 target_register_t orig_registers[HAL_STUB_REGISTERS_SIZE];  // Registers to get back to original state
 #endif
 #ifndef CYGPKG_REDBOOT
 target_register_t orig_registers[HAL_STUB_REGISTERS_SIZE];  // Registers to get back to original state
 #endif
@@ -114,11 +114,11 @@ static int  _hw_stop_reason;   // Reason we were stopped by hw.
 
 // Not all GDBs understand this.
 static const char * const _hw_stop_str[] = {
 
 // Not all GDBs understand this.
 static const char * const _hw_stop_str[] = {
-    "",
-    "hbreak",
-    "watch",
-    "rwatch",
-    "awatch"
+       "",
+       "hbreak",
+       "watch",
+       "rwatch",
+       "awatch"
 };
 #endif // HAL_STUB_HW_SEND_STOP_REASON_TEXT
 
 };
 #endif // HAL_STUB_HW_SEND_STOP_REASON_TEXT
 
@@ -147,10 +147,10 @@ static volatile __PFI __interruptible_control;
 #ifndef CYGARC_STUB_REGISTER_ACCESS_DEFINED
 // Return the currently-saved value corresponding to register REG of
 // the exception context.
 #ifndef CYGARC_STUB_REGISTER_ACCESS_DEFINED
 // Return the currently-saved value corresponding to register REG of
 // the exception context.
-target_register_t 
+target_register_t
 get_register (regnames_t reg)
 {
 get_register (regnames_t reg)
 {
-    return _registers[reg];
+       return _registers[reg];
 }
 #endif
 
 }
 #endif
 
@@ -159,29 +159,29 @@ get_register (regnames_t reg)
 int
 get_register_valid (regnames_t reg)
 {
 int
 get_register_valid (regnames_t reg)
 {
-    return _registers_valid[reg];
+       return _registers_valid[reg];
 }
 #endif
 
 #ifndef CYGARC_STUB_REGISTER_ACCESS_DEFINED
 // Store VALUE in the register corresponding to WHICH in the exception
 // context.
 }
 #endif
 
 #ifndef CYGARC_STUB_REGISTER_ACCESS_DEFINED
 // Store VALUE in the register corresponding to WHICH in the exception
 // context.
-void 
+void
 put_register (regnames_t which, target_register_t value)
 {
 #ifdef CYGPKG_HAL_MIPS_VR4300
 put_register (regnames_t which, target_register_t value)
 {
 #ifdef CYGPKG_HAL_MIPS_VR4300
-    // This is a rather nasty kludge to compensate for the fact that
-    // the VR4300 GDB is rather old and does not support proper 64 bit
-    // registers. The only time this really matters is when setting
-    // the PC after loading an executable. So here we detect this case
-    // and artificially sign extend it. 
-    
-    if( which == PC && (value & 0x0000000080000000ULL ) )
-    {
-        value |= 0xFFFFFFFF00000000ULL;
-    }
-#endif    
-    _registers[which] = value;
+       // This is a rather nasty kludge to compensate for the fact that
+       // the VR4300 GDB is rather old and does not support proper 64 bit
+       // registers. The only time this really matters is when setting
+       // the PC after loading an executable. So here we detect this case
+       // and artificially sign extend it.
+
+       if( which == PC && (value & 0x0000000080000000ULL ) )
+       {
+               value |= 0xFFFFFFFF00000000ULL;
+       }
+#endif
+       _registers[which] = value;
 }
 #endif // CYGARC_STUB_REGISTER_ACCESS_DEFINED
 
 }
 #endif // CYGARC_STUB_REGISTER_ACCESS_DEFINED
 
@@ -193,30 +193,30 @@ extern char ecos_bsp_console_getc(void);
 #endif
 
 // Write C to the current serial port.
 #endif
 
 // Write C to the current serial port.
-void 
+void
 putDebugChar (int c)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 putDebugChar (int c)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
-    __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
-    CYGACC_COMM_IF_PUTC(*__debug_procs, c);
+       __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
+       CYGACC_COMM_IF_PUTC(*__debug_procs, c);
 #elif defined(CYGPKG_CYGMON)
 #elif defined(CYGPKG_CYGMON)
-    ecos_bsp_console_putc(c);
+       ecos_bsp_console_putc(c);
 #else
 #else
-    HAL_STUB_PLATFORM_PUT_CHAR(c);
+       HAL_STUB_PLATFORM_PUT_CHAR(c);
 #endif
 }
 
 // Read one character from the current serial port.
 #endif
 }
 
 // Read one character from the current serial port.
-int 
+int
 getDebugChar (void)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 getDebugChar (void)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
-    __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
-    return CYGACC_COMM_IF_GETC(*__debug_procs);
+       __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
+       return CYGACC_COMM_IF_GETC(*__debug_procs);
 #elif defined(CYGPKG_CYGMON)
 #elif defined(CYGPKG_CYGMON)
-    return ecos_bsp_console_getc();
+       return ecos_bsp_console_getc();
 #else
 #else
-    return HAL_STUB_PLATFORM_GET_CHAR();
+       return HAL_STUB_PLATFORM_GET_CHAR();
 #endif
 }
 
 #endif
 }
 
@@ -225,23 +225,23 @@ void
 hal_flush_output(void)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 hal_flush_output(void)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
-    __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
-    CYGACC_COMM_IF_CONTROL(*__debug_procs, __COMMCTL_FLUSH_OUTPUT);
+       __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
+       CYGACC_COMM_IF_CONTROL(*__debug_procs, __COMMCTL_FLUSH_OUTPUT);
 #endif
 }
 
 
 // Set the baud rate for the current serial port.
 #endif
 }
 
 
 // Set the baud rate for the current serial port.
-void 
-__set_baud_rate (int baud) 
+void
+__set_baud_rate (int baud)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
-    __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
-    CYGACC_COMM_IF_CONTROL(*__debug_procs, __COMMCTL_SETBAUD, baud);
+       __call_if_debug_procs_t __debug_procs = CYGACC_CALL_IF_DEBUG_PROCS();
+       CYGACC_COMM_IF_CONTROL(*__debug_procs, __COMMCTL_SETBAUD, baud);
 #elif defined(CYGPKG_CYGMON)
 #elif defined(CYGPKG_CYGMON)
-    // FIXME!
+       // FIXME!
 #else
 #else
-    HAL_STUB_PLATFORM_SET_BAUD_RATE(baud);
+       HAL_STUB_PLATFORM_SET_BAUD_RATE(baud);
 #endif
 }
 
 #endif
 }
 
@@ -264,76 +264,76 @@ typedef cyg_uint32 t_inst;
 
 typedef struct
 {
 
 typedef struct
 {
-  t_inst *targetAddr;
-  t_inst savedInstr;
+       t_inst *targetAddr;
+       t_inst savedInstr;
 } instrBuffer;
 
 static instrBuffer break_buffer;
 
 volatile int cyg_hal_gdb_running_step = 0;
 
 } instrBuffer;
 
 static instrBuffer break_buffer;
 
 volatile int cyg_hal_gdb_running_step = 0;
 
-void 
+void
 cyg_hal_gdb_place_break (target_register_t pc)
 {
 cyg_hal_gdb_place_break (target_register_t pc)
 {
-    cyg_hal_gdb_interrupt( pc ); // Let's hope this becomes a drop-through:
+       cyg_hal_gdb_interrupt( pc ); // Let's hope this becomes a drop-through:
 }
 
 }
 
-void 
+void
 cyg_hal_gdb_interrupt (target_register_t pc)
 {
 cyg_hal_gdb_interrupt (target_register_t pc)
 {
-    t_inst break_inst = HAL_BREAKINST;
+       t_inst break_inst = HAL_BREAKINST;
 
 
-    CYGARC_HAL_SAVE_GP();
+       CYGARC_HAL_SAVE_GP();
 
 
-    // Clear flag that we Continued instead of Stepping
-    cyg_hal_gdb_running_step = 0;
-    // and override existing break? So that a ^C takes effect...
-    if (NULL != break_buffer.targetAddr)
-        cyg_hal_gdb_remove_break( (target_register_t)break_buffer.targetAddr );
+       // Clear flag that we Continued instead of Stepping
+       cyg_hal_gdb_running_step = 0;
+       // and override existing break? So that a ^C takes effect...
+       if (NULL != break_buffer.targetAddr)
+               cyg_hal_gdb_remove_break( (target_register_t)break_buffer.targetAddr );
 
 
-    if (NULL == break_buffer.targetAddr) {
-       // Not always safe to read/write directly to program
-       // memory due to possibly unaligned instruction, use the
-       // provided memory functions instead.
-       __read_mem_safe(&break_buffer.savedInstr, (t_inst*)pc, HAL_BREAKINST_SIZE);
-       __write_mem_safe(&break_inst, (t_inst*)pc, HAL_BREAKINST_SIZE);
+       if (NULL == break_buffer.targetAddr) {
+               // Not always safe to read/write directly to program
+               // memory due to possibly unaligned instruction, use the
+               // provided memory functions instead.
+               __read_mem_safe(&break_buffer.savedInstr, (t_inst*)pc, HAL_BREAKINST_SIZE);
+               __write_mem_safe(&break_inst, (t_inst*)pc, HAL_BREAKINST_SIZE);
 
 
-       // Save the PC where we put the break, so we can remove
-       // it after the target takes the break.
-       break_buffer.targetAddr = (t_inst*)pc;
+               // Save the PC where we put the break, so we can remove
+               // it after the target takes the break.
+               break_buffer.targetAddr = (t_inst*)pc;
 
 
-        __data_cache(CACHE_FLUSH);
-        __instruction_cache(CACHE_FLUSH);
-    }
+               __data_cache(CACHE_FLUSH);
+               __instruction_cache(CACHE_FLUSH);
+       }
 
 
-    CYGARC_HAL_RESTORE_GP();
+       CYGARC_HAL_RESTORE_GP();
 }
 
 }
 
-int 
+int
 cyg_hal_gdb_remove_break (target_register_t pc)
 {
 cyg_hal_gdb_remove_break (target_register_t pc)
 {
-    if ( cyg_hal_gdb_running_step )
-        return 0;
+       if ( cyg_hal_gdb_running_step )
+               return 0;
 
 
-    if ((t_inst*)pc == break_buffer.targetAddr) {
+       if ((t_inst*)pc == break_buffer.targetAddr) {
 
 
-       __write_mem_safe(&break_buffer.savedInstr, (t_inst*)pc, HAL_BREAKINST_SIZE);
-        break_buffer.targetAddr = NULL;
+               __write_mem_safe(&break_buffer.savedInstr, (t_inst*)pc, HAL_BREAKINST_SIZE);
+               break_buffer.targetAddr = NULL;
 
 
-        __data_cache(CACHE_FLUSH);
-        __instruction_cache(CACHE_FLUSH);
-        return 1;
-    }
-    return 0;
+               __data_cache(CACHE_FLUSH);
+               __instruction_cache(CACHE_FLUSH);
+               return 1;
+       }
+       return 0;
 }
 
 }
 
-int 
+int
 cyg_hal_gdb_break_is_set (void)
 {
 cyg_hal_gdb_break_is_set (void)
 {
-    if (NULL != break_buffer.targetAddr) {
-        return 1;
-    }
-    return 0;
+       if (NULL != break_buffer.targetAddr) {
+               return 1;
+       }
+       return 0;
 }
 
 #endif // CYGPKG_HAL_ARM
 }
 
 #endif // CYGPKG_HAL_ARM
@@ -349,37 +349,37 @@ cyg_hal_gdb_break_is_set (void)
 static void
 interruptible(int state)
 {
 static void
 interruptible(int state)
 {
-    static int __interrupts_suspended = 0;
+       static int __interrupts_suspended = 0;
 
 
-    if (state) {
-        __interrupts_suspended--;
-        if (0 >= __interrupts_suspended) {
-            __interrupts_suspended = 0;
+       if (state) {
+               __interrupts_suspended--;
+               if (0 >= __interrupts_suspended) {
+                       __interrupts_suspended = 0;
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this _check_ should go away
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this _check_ should go away
-            {
-                hal_virtual_comm_table_t* __chan;
-                __chan = CYGACC_CALL_IF_DEBUG_PROCS();
-                CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_ENABLE);
-            }
-#else                
-            if (__interruptible_control)
-                __interruptible_control(1);
+                       {
+                               hal_virtual_comm_table_t* __chan;
+                               __chan = CYGACC_CALL_IF_DEBUG_PROCS();
+                               CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_ENABLE);
+                       }
+#else
+                       if (__interruptible_control)
+                               __interruptible_control(1);
 #endif
 #endif
-        }
-    } else {
-        __interrupts_suspended++;
-        if (1 == __interrupts_suspended)
+               }
+       } else {
+               __interrupts_suspended++;
+               if (1 == __interrupts_suspended)
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this _check_ should go away
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this _check_ should go away
-            {
-                hal_virtual_comm_table_t* __chan;
-                __chan = CYGACC_CALL_IF_DEBUG_PROCS();
-                CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE);
-            }
-#else                
-            if (__interruptible_control)
-                __interruptible_control(0);
+               {
+                       hal_virtual_comm_table_t* __chan;
+                       __chan = CYGACC_CALL_IF_DEBUG_PROCS();
+                       CYGACC_COMM_IF_CONTROL(*__chan, __COMMCTL_IRQ_DISABLE);
+               }
+#else
+               if (__interruptible_control)
+                       __interruptible_control(0);
 #endif
 #endif
-    }
+       }
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -394,101 +394,101 @@ int cyg_hal_gdb_break;
 static void
 return_from_stub(int exit_status)
 {
 static void
 return_from_stub(int exit_status)
 {
-    CYGACC_CALL_IF_MONITOR_RETURN(exit_status);
+       CYGACC_CALL_IF_MONITOR_RETURN(exit_status);
 }
 #endif
 
 // Called at stub *kill*
 }
 #endif
 
 // Called at stub *kill*
-static void 
+static void
 handle_exception_exit( void )
 {
 #ifdef CYGPKG_REDBOOT
 #ifdef CYGSEM_REDBOOT_BSP_SYSCALLS_GPROF
 handle_exception_exit( void )
 {
 #ifdef CYGPKG_REDBOOT
 #ifdef CYGSEM_REDBOOT_BSP_SYSCALLS_GPROF
-    {   // Reset the timer to default and cancel any callback
-       extern void sys_profile_reset(void);
-       sys_profile_reset();
-    }
+       {   // Reset the timer to default and cancel any callback
+               extern void sys_profile_reset(void);
+               sys_profile_reset();
+       }
 #endif // CYGSEM_REDBOOT_BSP_SYSCALLS_GPROF
 #endif // CYGSEM_REDBOOT_BSP_SYSCALLS_GPROF
-    set_pc((target_register_t)return_from_stub);
+       set_pc((target_register_t)return_from_stub);
 #else
 #else
-    int i;
+       int i;
 
 
-    for (i = 0; i < (sizeof(registers)/sizeof(registers[0])); i++)
-       registers[i] = orig_registers[i];
+       for (i = 0; i < (sizeof(registers)/sizeof(registers[0])); i++)
+               registers[i] = orig_registers[i];
 #endif
 }
 
 // Called at stub *entry*
 #endif
 }
 
 // Called at stub *entry*
-static void 
+static void
 handle_exception_cleanup( void )
 {
 #ifndef CYGPKG_REDBOOT
 handle_exception_cleanup( void )
 {
 #ifndef CYGPKG_REDBOOT
-    static int orig_registers_set = 0;
+       static int orig_registers_set = 0;
 #endif
 
 #endif
 
-    interruptible(0);
+       interruptible(0);
 
 
-    // Expand the HAL_SavedRegisters structure into the GDB register
-    // array format.
-    HAL_GET_GDB_REGISTERS(&registers[0], _hal_registers);
-    _registers = &registers[0];
+       // Expand the HAL_SavedRegisters structure into the GDB register
+       // array format.
+       HAL_GET_GDB_REGISTERS(&registers[0], _hal_registers);
+       _registers = &registers[0];
 
 #ifndef CYGPKG_REDBOOT
 
 #ifndef CYGPKG_REDBOOT
-    if (!orig_registers_set) {
-       int i;
-       for (i = 0; i < (sizeof(registers)/sizeof(registers[0])); i++)
-           orig_registers[i] = registers[i];
-       _registers = &orig_registers[0];
-       if (__is_breakpoint_function ())
-           __skipinst ();
-       _registers = &registers[0];
-       orig_registers_set = 1;
-    }
+       if (!orig_registers_set) {
+               int i;
+               for (i = 0; i < (sizeof(registers)/sizeof(registers[0])); i++)
+                       orig_registers[i] = registers[i];
+               _registers = &orig_registers[0];
+               if (__is_breakpoint_function ())
+                       __skipinst ();
+               _registers = &registers[0];
+               orig_registers_set = 1;
+       }
 #endif
 #endif
-       
+
 #ifdef HAL_STUB_PLATFORM_STUBS_FIXUP
 #ifdef HAL_STUB_PLATFORM_STUBS_FIXUP
-    // Some architectures may need to fix the PC in case of a partial
-    // or fully executed trap instruction. GDB only takes correct action
-    // when the PC is pointing to the breakpoint instruction it set.
-    // 
-    // Most architectures would leave PC pointing at the trap
-    // instruction itself though, and so do not need to do anything
-    // special.
-    HAL_STUB_PLATFORM_STUBS_FIXUP();
+       // Some architectures may need to fix the PC in case of a partial
+       // or fully executed trap instruction. GDB only takes correct action
+       // when the PC is pointing to the breakpoint instruction it set.
+       //
+       // Most architectures would leave PC pointing at the trap
+       // instruction itself though, and so do not need to do anything
+       // special.
+       HAL_STUB_PLATFORM_STUBS_FIXUP();
 #endif
 
 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 #endif
 
 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
-    // If we continued instead of stepping, when there was a break set
-    // ie. we were stepping within a critical region, clear the break, and
-    // that flag.  If we stopped for some other reason, this has no effect.
-    if ( cyg_hal_gdb_running_step ) {
-        cyg_hal_gdb_running_step = 0;
-        cyg_hal_gdb_remove_break(get_register (PC));
-    }
-
-    // FIXME: (there may be a better way to do this)
-    // If we hit a breakpoint set by the gdb interrupt stub, make it
-    // seem like an interrupt rather than having hit a breakpoint.
-    cyg_hal_gdb_break = cyg_hal_gdb_remove_break(get_register (PC));
+       // If we continued instead of stepping, when there was a break set
+       // ie. we were stepping within a critical region, clear the break, and
+       // that flag.  If we stopped for some other reason, this has no effect.
+       if ( cyg_hal_gdb_running_step ) {
+               cyg_hal_gdb_running_step = 0;
+               cyg_hal_gdb_remove_break(get_register (PC));
+       }
+
+       // FIXME: (there may be a better way to do this)
+       // If we hit a breakpoint set by the gdb interrupt stub, make it
+       // seem like an interrupt rather than having hit a breakpoint.
+       cyg_hal_gdb_break = cyg_hal_gdb_remove_break(get_register (PC));
 #endif
 
 #if defined(HAL_STUB_HW_WATCHPOINT) || defined(HAL_STUB_HW_BREAKPOINT)
 #endif
 
 #if defined(HAL_STUB_HW_WATCHPOINT) || defined(HAL_STUB_HW_BREAKPOINT)
-    // For HW watchpoint/breakpoint support, we need to know if we
-    // stopped because of watchpoint or hw break. We do that here
-    // before GDB has a chance to remove the watchpoints and save
-    // the information for later use in building response packets.
-    _hw_stop_reason = HAL_STUB_IS_STOPPED_BY_HARDWARE(_watch_data_addr);
-#endif    
+       // For HW watchpoint/breakpoint support, we need to know if we
+       // stopped because of watchpoint or hw break. We do that here
+       // before GDB has a chance to remove the watchpoints and save
+       // the information for later use in building response packets.
+       _hw_stop_reason = HAL_STUB_IS_STOPPED_BY_HARDWARE(_watch_data_addr);
+#endif
 }
 
 // Called at stub *exit*
 }
 
 // Called at stub *exit*
-static void 
+static void
 handle_exception_init( void )
 {
 handle_exception_init( void )
 {
-    // Compact register array again.
-    HAL_SET_GDB_REGISTERS(_hal_registers, &registers[0]);
+       // Compact register array again.
+       HAL_SET_GDB_REGISTERS(_hal_registers, &registers[0]);
 
 
-    interruptible(1);
+       interruptible(1);
 }
 
 
 }
 
 
@@ -496,71 +496,71 @@ handle_exception_init( void )
 // Initialization.
 
 // Signal handler.
 // Initialization.
 
 // Signal handler.
-int 
+int
 cyg_hal_process_signal (int signal)
 {
 cyg_hal_process_signal (int signal)
 {
-    // We don't care about the signal (atm).
-    return 0;
+       // We don't care about the signal (atm).
+       return 0;
 }
 
 // Install the standard set of trap handlers for the stub.
 }
 
 // Install the standard set of trap handlers for the stub.
-void 
+void
 __install_traps (void)
 {
 __install_traps (void)
 {
-    // Set signal handling vector so we can treat 'C<signum>' as 'c'.
-    __process_signal_vec = &cyg_hal_process_signal;
-    __process_exit_vec = &handle_exception_exit;
+       // Set signal handling vector so we can treat 'C<signum>' as 'c'.
+       __process_signal_vec = &cyg_hal_process_signal;
+       __process_exit_vec = &handle_exception_exit;
 
 
-    __cleanup_vec = &handle_exception_cleanup;
-    __init_vec    = &handle_exception_init;
+       __cleanup_vec = &handle_exception_cleanup;
+       __init_vec    = &handle_exception_init;
 
 #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this should go away
 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 
 #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this should go away
 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
-    // Control of GDB interrupts.
-    __interruptible_control = HAL_STUB_PLATFORM_INTERRUPTIBLE;
+       // Control of GDB interrupts.
+       __interruptible_control = HAL_STUB_PLATFORM_INTERRUPTIBLE;
 #endif
 #endif
 
 #endif
 #endif
 
-    // Nothing further to do, handle_exception will be called when an
-    // exception occurs.
+       // Nothing further to do, handle_exception will be called when an
+       // exception occurs.
 }
 
 // Initialize the hardware.
 }
 
 // Initialize the hardware.
-void 
-initHardware (void) 
+void
+initHardware (void)
 {
 {
-    static int initialized = 0;
+       static int initialized = 0;
 
 
-    if (initialized)
-        return;
-    initialized = 1;
+       if (initialized)
+               return;
+       initialized = 1;
 
 
-    // Get serial port initialized.
-    HAL_STUB_PLATFORM_INIT_SERIAL();
+       // Get serial port initialized.
+       HAL_STUB_PLATFORM_INIT_SERIAL();
 
 #ifdef HAL_STUB_PLATFORM_INIT
 
 #ifdef HAL_STUB_PLATFORM_INIT
-    // If the platform defines any initialization code, call it here.
-    HAL_STUB_PLATFORM_INIT();
-#endif        
+       // If the platform defines any initialization code, call it here.
+       HAL_STUB_PLATFORM_INIT();
+#endif
 
 #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this should go away
 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 
 #ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT // this should go away
 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
-    // Get interrupt handler initialized.
-    HAL_STUB_PLATFORM_INIT_BREAK_IRQ();
+       // Get interrupt handler initialized.
+       HAL_STUB_PLATFORM_INIT_BREAK_IRQ();
 #endif
 #endif // !CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 }
 
 // Reset the board.
 #endif
 #endif // !CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 }
 
 // Reset the board.
-void 
+void
 __reset (void)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
 __reset (void)
 {
 #ifdef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
-    __call_if_reset_t *__rom_reset = CYGACC_CALL_IF_RESET_GET();
-    if (__rom_reset)
-        (*__rom_reset)();
+       __call_if_reset_t *__rom_reset = CYGACC_CALL_IF_RESET_GET();
+       if (__rom_reset)
+               (*__rom_reset)();
 #else
 #else
-    HAL_PLATFORM_RESET();
+       HAL_PLATFORM_RESET();
 #endif
 }
 
 #endif
 }
 
@@ -575,203 +575,203 @@ __reset (void)
 void
 breakpoint()
 {
 void
 breakpoint()
 {
-    HAL_BREAKPOINT(_breakinst);
+       HAL_BREAKPOINT(_breakinst);
 }
 
 // This function returns the opcode for a 'trap' instruction.
 }
 
 // This function returns the opcode for a 'trap' instruction.
-unsigned long 
+unsigned long
 __break_opcode ()
 {
 __break_opcode ()
 {
-  return HAL_BREAKINST;
+       return HAL_BREAKINST;
 }
 #endif
 
 //-----------------------------------------------------------------------------
 // Write the 'T' packet in BUFFER. SIGVAL is the signal the program received.
 }
 #endif
 
 //-----------------------------------------------------------------------------
 // Write the 'T' packet in BUFFER. SIGVAL is the signal the program received.
-void 
+void
 __build_t_packet (int sigval, char *buf)
 {
 __build_t_packet (int sigval, char *buf)
 {
-    target_register_t addr;
-    char *ptr = buf;
-    target_register_t extend_val = 0;
+       target_register_t addr;
+       char *ptr = buf;
+       target_register_t extend_val = 0;
 
 
-    *ptr++ = 'T';
-    *ptr++ = __tohex (sigval >> 4);
-    *ptr++ = __tohex (sigval);
+       *ptr++ = 'T';
+       *ptr++ = __tohex (sigval >> 4);
+       *ptr++ = __tohex (sigval);
 
 #ifdef CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT
 
 #ifdef CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT
-    // Include thread ID if thread manipulation is required.
-    {
-        int id = dbg_currthread_id ();
-
-        if (id != 0) {
-           *ptr++ = 't';
-           *ptr++ = 'h';
-           *ptr++ = 'r';
-           *ptr++ = 'e';
-           *ptr++ = 'a';
-           *ptr++ = 'd';
-           *ptr++ = ':';
+       // Include thread ID if thread manipulation is required.
+       {
+               int id = dbg_currthread_id ();
+
+               if (id != 0) {
+                       *ptr++ = 't';
+                       *ptr++ = 'h';
+                       *ptr++ = 'r';
+                       *ptr++ = 'e';
+                       *ptr++ = 'a';
+                       *ptr++ = 'd';
+                       *ptr++ = ':';
 
 #if (CYG_BYTEORDER == CYG_LSBFIRST)
 
 #if (CYG_BYTEORDER == CYG_LSBFIRST)
-           // FIXME: Temporary workaround for PR 18903. Thread ID must be
-           // big-endian in the T packet.
-           {
-               unsigned char* bep = (unsigned char*)&id;
-               int be_id;
-
-               be_id = id;
-               *bep++ = (be_id >> 24) & 0xff ;
-               *bep++ = (be_id >> 16) & 0xff ;
-               *bep++ = (be_id >> 8) & 0xff ;
-               *bep++ = (be_id & 0xff) ;
-           }
+                       // FIXME: Temporary workaround for PR 18903. Thread ID must be
+                       // big-endian in the T packet.
+                       {
+                               unsigned char* bep = (unsigned char*)&id;
+                               int be_id;
+
+                               be_id = id;
+                               *bep++ = (be_id >> 24) & 0xff ;
+                               *bep++ = (be_id >> 16) & 0xff ;
+                               *bep++ = (be_id >> 8) & 0xff ;
+                               *bep++ = (be_id & 0xff) ;
+                       }
 #endif
 #endif
-           ptr = __mem2hex((char *)&id, ptr, sizeof(id), 0);
-           *ptr++ = ';';
+                       ptr = __mem2hex((char *)&id, ptr, sizeof(id), 0);
+                       *ptr++ = ';';
+               }
        }
        }
-    }
 #endif
 
 #ifdef HAL_STUB_HW_WATCHPOINT
 #endif
 
 #ifdef HAL_STUB_HW_WATCHPOINT
-    switch(_hw_stop_reason) {
-      case HAL_STUB_HW_STOP_WATCH:
-      case HAL_STUB_HW_STOP_RWATCH:
-      case HAL_STUB_HW_STOP_AWATCH:
+       switch(_hw_stop_reason) {
+       case HAL_STUB_HW_STOP_WATCH:
+       case HAL_STUB_HW_STOP_RWATCH:
+       case HAL_STUB_HW_STOP_AWATCH:
 #ifdef HAL_STUB_HW_SEND_STOP_REASON_TEXT
 #ifdef HAL_STUB_HW_SEND_STOP_REASON_TEXT
-        // Not all GDBs understand this.
-       strcpy(ptr, _hw_stop_str[_hw_stop_reason]);
-       ptr += strlen(_hw_stop_str[_hw_stop_reason]);
+               // Not all GDBs understand this.
+               strcpy(ptr, _hw_stop_str[_hw_stop_reason]);
+               ptr += strlen(_hw_stop_str[_hw_stop_reason]);
 #endif
 #endif
-       *ptr++ = ':';
-       // Send address MSB first
-       ptr += __intToHex(ptr, (target_register_t)_watch_data_addr,
-                         sizeof(_watch_data_addr) * 8);
-       *ptr++ = ';';
-       break;
-      default:
-       break;
-    }
+               *ptr++ = ':';
+               // Send address MSB first
+               ptr += __intToHex(ptr, (target_register_t)_watch_data_addr,
+                                               sizeof(_watch_data_addr) * 8);
+               *ptr++ = ';';
+               break;
+       default:
+               break;
+       }
 #endif
 
 #endif
 
-    *ptr++ = __tohex (PC >> 4);
-    *ptr++ = __tohex (PC);
-    *ptr++ = ':';
-    addr = get_register (PC);
-    if (sizeof(addr) < REGSIZE(PC))
-    {
-        // GDB is expecting REGSIZE(PC) number of bytes.
-        // We only have sizeof(addr) number.  Let's fill
-        // the appropriate number of bytes intelligently.
+       *ptr++ = __tohex (PC >> 4);
+       *ptr++ = __tohex (PC);
+       *ptr++ = ':';
+       addr = get_register (PC);
+       if (sizeof(addr) < REGSIZE(PC))
+       {
+               // GDB is expecting REGSIZE(PC) number of bytes.
+               // We only have sizeof(addr) number.  Let's fill
+               // the appropriate number of bytes intelligently.
 #ifdef CYGARC_SIGN_EXTEND_REGISTERS
 #ifdef CYGARC_SIGN_EXTEND_REGISTERS
-        {
-            unsigned long bits_in_addr = (sizeof(addr) << 3);  // ie Size in bytes * 8
-            target_register_t sign_bit_mask = (1 << (bits_in_addr - 1));
-            if ((addr & sign_bit_mask) == sign_bit_mask)
-                extend_val = ~0;
-        }
+               {
+                       unsigned long bits_in_addr = (sizeof(addr) << 3);  // ie Size in bytes * 8
+                       target_register_t sign_bit_mask = (1 << (bits_in_addr - 1));
+                       if ((addr & sign_bit_mask) == sign_bit_mask)
+                               extend_val = ~0;
+               }
 #endif
 #endif
-    }
+       }
 #if (CYG_BYTEORDER == CYG_MSBFIRST)
 #if (CYG_BYTEORDER == CYG_MSBFIRST)
-    ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(PC) - sizeof(addr), 0);
+       ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(PC) - sizeof(addr), 0);
 #endif
 #endif
-    ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
+       ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
 #if (CYG_BYTEORDER == CYG_LSBFIRST)
 #if (CYG_BYTEORDER == CYG_LSBFIRST)
-    ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(PC) - sizeof(addr), 0);
+       ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(PC) - sizeof(addr), 0);
 #endif
 #endif
-    *ptr++ = ';';
-
-    *ptr++ = __tohex (SP >> 4);
-    *ptr++ = __tohex (SP);
-    *ptr++ = ':';
-    addr = (target_register_t) get_register (SP);
-    if (sizeof(addr) < REGSIZE(SP))
-    {
-        // GDB is expecting REGSIZE(SP) number of bytes.
-        // We only have sizeof(addr) number.  Let's fill
-        // the appropriate number of bytes intelligently.
-        extend_val = 0;
+       *ptr++ = ';';
+
+       *ptr++ = __tohex (SP >> 4);
+       *ptr++ = __tohex (SP);
+       *ptr++ = ':';
+       addr = (target_register_t) get_register (SP);
+       if (sizeof(addr) < REGSIZE(SP))
+       {
+               // GDB is expecting REGSIZE(SP) number of bytes.
+               // We only have sizeof(addr) number.  Let's fill
+               // the appropriate number of bytes intelligently.
+               extend_val = 0;
 #ifdef CYGARC_SIGN_EXTEND_REGISTERS
 #ifdef CYGARC_SIGN_EXTEND_REGISTERS
-        {
-            unsigned long bits_in_addr = (sizeof(addr) << 3);  // ie Size in bytes * 8
-            target_register_t sign_bit_mask = (1 << (bits_in_addr - 1));
-            if ((addr & sign_bit_mask) == sign_bit_mask)
-                extend_val = ~0;
-        }
+               {
+                       unsigned long bits_in_addr = (sizeof(addr) << 3);  // ie Size in bytes * 8
+                       target_register_t sign_bit_mask = (1 << (bits_in_addr - 1));
+                       if ((addr & sign_bit_mask) == sign_bit_mask)
+                               extend_val = ~0;
+               }
 #endif
 #endif
-        ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(SP) - sizeof(addr), 0);
-    }
-    ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
-    *ptr++ = ';';
-
-    HAL_STUB_ARCH_T_PACKET_EXTRAS(ptr);
-    
-    *ptr++ = 0;
+               ptr = __mem2hex((char *)&extend_val, ptr, REGSIZE(SP) - sizeof(addr), 0);
+       }
+       ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
+       *ptr++ = ';';
+
+       HAL_STUB_ARCH_T_PACKET_EXTRAS(ptr);
+
+       *ptr++ = 0;
 }
 
 
 //-----------------------------------------------------------------------------
 // Cache functions.
 
 }
 
 
 //-----------------------------------------------------------------------------
 // Cache functions.
 
-// Perform the specified operation on the instruction cache. 
+// Perform the specified operation on the instruction cache.
 // Returns 1 if the cache is enabled, 0 otherwise.
 // Returns 1 if the cache is enabled, 0 otherwise.
-int 
+int
 __instruction_cache (cache_control_t request)
 {
 __instruction_cache (cache_control_t request)
 {
-    int state = 1;
-
-    switch (request) {
-    case CACHE_ENABLE:
-        HAL_ICACHE_ENABLE();
-        break;
-    case CACHE_DISABLE:
-        HAL_ICACHE_DISABLE();
-        state = 0;
-        break;
-    case CACHE_FLUSH:
-        HAL_ICACHE_SYNC();
-        break;
-    case CACHE_NOOP:
-        /* fall through */
-    default:
-        break;
-    }
+       int state = 1;
+
+       switch (request) {
+       case CACHE_ENABLE:
+               HAL_ICACHE_ENABLE();
+               break;
+       case CACHE_DISABLE:
+               HAL_ICACHE_DISABLE();
+               state = 0;
+               break;
+       case CACHE_FLUSH:
+               HAL_ICACHE_SYNC();
+               break;
+       case CACHE_NOOP:
+               /* fall through */
+       default:
+               break;
+       }
 
 #ifdef HAL_ICACHE_IS_ENABLED
 
 #ifdef HAL_ICACHE_IS_ENABLED
-    HAL_ICACHE_IS_ENABLED(state);
+       HAL_ICACHE_IS_ENABLED(state);
 #endif
 
 #endif
 
-    return state;
+       return state;
 }
 
 }
 
-// Perform the specified operation on the data cache. 
+// Perform the specified operation on the data cache.
 // Returns 1 if the cache is enabled, 0 otherwise.
 // Returns 1 if the cache is enabled, 0 otherwise.
-int 
+int
 __data_cache (cache_control_t request)
 {
 __data_cache (cache_control_t request)
 {
-    int state = 1;
-
-    switch (request) {
-    case CACHE_ENABLE:
-        HAL_DCACHE_ENABLE();
-        break;
-    case CACHE_DISABLE:
-        HAL_DCACHE_DISABLE();
-        state = 0;
-        break;
-    case CACHE_FLUSH:
-        HAL_DCACHE_SYNC();
-        break;
-    case CACHE_NOOP:
-        /* fall through */
-    default:
-        break;
-    }
+       int state = 1;
+
+       switch (request) {
+       case CACHE_ENABLE:
+               HAL_DCACHE_ENABLE();
+               break;
+       case CACHE_DISABLE:
+               HAL_DCACHE_DISABLE();
+               state = 0;
+               break;
+       case CACHE_FLUSH:
+               HAL_DCACHE_SYNC();
+               break;
+       case CACHE_NOOP:
+               /* fall through */
+       default:
+               break;
+       }
 #ifdef HAL_DCACHE_IS_ENABLED
 #ifdef HAL_DCACHE_IS_ENABLED
-    HAL_DCACHE_IS_ENABLED(state);
+       HAL_DCACHE_IS_ENABLED(state);
 #endif
 
 #endif
 
-    return state;
+       return state;
 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------
@@ -786,7 +786,7 @@ __data_cache (cache_control_t request)
 
 void* volatile __mem_fault_handler = (void *)0;
 
 
 void* volatile __mem_fault_handler = (void *)0;
 
-/* These are the "arguments" to __do_read_mem and __do_write_mem, 
+/* These are the "arguments" to __do_read_mem and __do_write_mem,
    which are passed as globals to avoid squeezing them thru
    __set_mem_fault_trap.  */
 
    which are passed as globals to avoid squeezing them thru
    __set_mem_fault_trap.  */
 
@@ -795,55 +795,55 @@ static volatile target_register_t memCount;
 static void
 __do_copy_mem (unsigned char* src, unsigned char* dst)
 {
 static void
 __do_copy_mem (unsigned char* src, unsigned char* dst)
 {
-    unsigned long *long_dst;
-    unsigned long *long_src;
-    unsigned short *short_dst;
-    unsigned short *short_src;
-
-    // Zero memCount is not really an error, but the goto is necessary to
-    // keep some compilers from reordering stuff across the 'err' label.
-    if (memCount == 0) goto err;
-
-    __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
-                                          /* when the copy loop completes.  */
-    __mem_fault_handler = &&err;
-
-    // See if it's safe to do multi-byte, aligned operations
-    while (memCount) {
-        if ((memCount >= sizeof(long)) &&
-            (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
-            (((target_register_t)src & (sizeof(long)-1)) == 0)) {
-        
-            long_dst = (unsigned long *)dst;
-            long_src = (unsigned long *)src;
-
-            *long_dst++ = *long_src++;
-            memCount -= sizeof(long);
-
-            dst = (unsigned char *)long_dst;
-            src = (unsigned char *)long_src;
-        } else if ((memCount >= sizeof(short)) &&
-                   (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
-                   (((target_register_t)src & (sizeof(short)-1)) == 0)) {
-            
-            short_dst = (unsigned short *)dst;
-            short_src = (unsigned short *)src;
-
-            *short_dst++ = *short_src++;
-            memCount -= sizeof(short);
-
-            dst = (unsigned char *)short_dst;
-            src = (unsigned char *)short_src;
-        } else {
-            *dst++ = *src++;
-            memCount--;
-        }
-    }
-
-    __mem_fault = 0;
-
- err:
-    __mem_fault_handler = (void *)0;
+       unsigned long *long_dst;
+       unsigned long *long_src;
+       unsigned short *short_dst;
+       unsigned short *short_src;
+
+       // Zero memCount is not really an error, but the goto is necessary to
+       // keep some compilers from reordering stuff across the 'err' label.
+       if (memCount == 0) goto err;
+
+       __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
+                                                                                 /* when the copy loop completes.  */
+       __mem_fault_handler = &&err;
+
+       // See if it's safe to do multi-byte, aligned operations
+       while (memCount) {
+               if ((memCount >= sizeof(long)) &&
+                       (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
+                       (((target_register_t)src & (sizeof(long)-1)) == 0)) {
+
+                       long_dst = (unsigned long *)dst;
+                       long_src = (unsigned long *)src;
+
+                       *long_dst++ = *long_src++;
+                       memCount -= sizeof(long);
+
+                       dst = (unsigned char *)long_dst;
+                       src = (unsigned char *)long_src;
+               } else if ((memCount >= sizeof(short)) &&
+                               (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
+                               (((target_register_t)src & (sizeof(short)-1)) == 0)) {
+
+                       short_dst = (unsigned short *)dst;
+                       short_src = (unsigned short *)src;
+
+                       *short_dst++ = *short_src++;
+                       memCount -= sizeof(short);
+
+                       dst = (unsigned char *)short_dst;
+                       src = (unsigned char *)short_src;
+               } else {
+                       *dst++ = *src++;
+                       memCount--;
+               }
+       }
+
+       __mem_fault = 0;
+
+err:
+       __mem_fault_handler = (void *)0;
 }
 
 /*
 }
 
 /*
@@ -854,12 +854,12 @@ __do_copy_mem (unsigned char* src, unsigned char* dst)
 int
 __read_mem_safe (void *dst, void *src, int count)
 {
 int
 __read_mem_safe (void *dst, void *src, int count)
 {
-  if( !CYG_HAL_STUB_PERMIT_DATA_READ( src, count ) )
-    return 0;
+       if( !CYG_HAL_STUB_PERMIT_DATA_READ( src, count ) )
+               return 0;
 
 
-  memCount = count;
-  __do_copy_mem((unsigned char*) src, (unsigned char*) dst);
-  return count - memCount;      // return number of bytes successfully read
+       memCount = count;
+       __do_copy_mem((unsigned char*) src, (unsigned char*) dst);
+       return count - memCount;      // return number of bytes successfully read
 }
 
 /*
 }
 
 /*
@@ -870,121 +870,121 @@ __read_mem_safe (void *dst, void *src, int count)
 int
 __write_mem_safe (void *src, void *dst, int count)
 {
 int
 __write_mem_safe (void *src, void *dst, int count)
 {
-  if( !CYG_HAL_STUB_PERMIT_DATA_READ( dst, count ) )
-    return 0;
+       if( !CYG_HAL_STUB_PERMIT_DATA_READ( dst, count ) )
+               return 0;
 
 
-  memCount = count;
-  __do_copy_mem((unsigned char*) src, (unsigned char*) dst);
-  return count - memCount;      // return number of bytes successfully written
+       memCount = count;
+       __do_copy_mem((unsigned char*) src, (unsigned char*) dst);
+       return count - memCount;      // return number of bytes successfully written
 }
 
 #ifdef TARGET_HAS_HARVARD_MEMORY
 static void
 __do_copy_from_progmem (unsigned char* src, unsigned char* dst)
 {
 }
 
 #ifdef TARGET_HAS_HARVARD_MEMORY
 static void
 __do_copy_from_progmem (unsigned char* src, unsigned char* dst)
 {
-    unsigned long *long_dst;
-    unsigned long *long_src;
-    unsigned short *short_dst;
-    unsigned short *short_src;
-
-    // Zero memCount is not really an error, but the goto is necessary to
-    // keep some compilers from reordering stuff across the 'err' label.
-    if (memCount == 0) goto err;
-
-    __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
-                                          /* when the copy loop completes.  */
-    __mem_fault_handler = &&err;
-
-    // See if it's safe to do multi-byte, aligned operations
-    while (memCount) {
-        if ((memCount >= sizeof(long)) &&
-            (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
-            (((target_register_t)src & (sizeof(long)-1)) == 0)) {
-        
-            long_dst = (unsigned long *)dst;
-            long_src = (unsigned long *)src;
-
-            *long_dst++ = __read_prog_uint32(long_src++);
-            memCount -= sizeof(long);
-
-            dst = (unsigned char *)long_dst;
-            src = (unsigned char *)long_src;
-        } else if ((memCount >= sizeof(short)) &&
-                   (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
-                   (((target_register_t)src & (sizeof(short)-1)) == 0)) {
-            
-            short_dst = (unsigned short *)dst;
-            short_src = (unsigned short *)src;
-
-            *short_dst++ = __read_prog_uint16(short_src++);
-            memCount -= sizeof(short);
-
-            dst = (unsigned char *)short_dst;
-            src = (unsigned char *)short_src;
-        } else {
-            *dst++ = __read_prog_uint8(src++);
-            memCount--;
-        }
-    }
-
-    __mem_fault = 0;
-
- err:
-    __mem_fault_handler = (void *)0;
+       unsigned long *long_dst;
+       unsigned long *long_src;
+       unsigned short *short_dst;
+       unsigned short *short_src;
+
+       // Zero memCount is not really an error, but the goto is necessary to
+       // keep some compilers from reordering stuff across the 'err' label.
+       if (memCount == 0) goto err;
+
+       __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
+                                                                                 /* when the copy loop completes.  */
+       __mem_fault_handler = &&err;
+
+       // See if it's safe to do multi-byte, aligned operations
+       while (memCount) {
+               if ((memCount >= sizeof(long)) &&
+                       (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
+                       (((target_register_t)src & (sizeof(long)-1)) == 0)) {
+
+                       long_dst = (unsigned long *)dst;
+                       long_src = (unsigned long *)src;
+
+                       *long_dst++ = __read_prog_uint32(long_src++);
+                       memCount -= sizeof(long);
+
+                       dst = (unsigned char *)long_dst;
+                       src = (unsigned char *)long_src;
+               } else if ((memCount >= sizeof(short)) &&
+                               (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
+                               (((target_register_t)src & (sizeof(short)-1)) == 0)) {
+
+                       short_dst = (unsigned short *)dst;
+                       short_src = (unsigned short *)src;
+
+                       *short_dst++ = __read_prog_uint16(short_src++);
+                       memCount -= sizeof(short);
+
+                       dst = (unsigned char *)short_dst;
+                       src = (unsigned char *)short_src;
+               } else {
+                       *dst++ = __read_prog_uint8(src++);
+                       memCount--;
+               }
+       }
+
+       __mem_fault = 0;
+
+err:
+       __mem_fault_handler = (void *)0;
 }
 
 static void
 __do_copy_to_progmem (unsigned char* src, unsigned char* dst)
 {
 }
 
 static void
 __do_copy_to_progmem (unsigned char* src, unsigned char* dst)
 {
-    unsigned long *long_dst;
-    unsigned long *long_src;
-    unsigned short *short_dst;
-    unsigned short *short_src;
-
-    // Zero memCount is not really an error, but the goto is necessary to
-    // keep some compilers from reordering stuff across the 'err' label.
-    if (memCount == 0) goto err;
-
-    __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
-                                          /* when the copy loop completes.  */
-    __mem_fault_handler = &&err;
-
-    // See if it's safe to do multi-byte, aligned operations
-    while (memCount) {
-        if ((memCount >= sizeof(long)) &&
-            (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
-            (((target_register_t)src & (sizeof(long)-1)) == 0)) {
-        
-            long_dst = (unsigned long *)dst;
-            long_src = (unsigned long *)src;
-
-            __write_prog_uint32(long_dst++, *long_src++);
-            memCount -= sizeof(long);
-
-            dst = (unsigned char *)long_dst;
-            src = (unsigned char *)long_src;
-        } else if ((memCount >= sizeof(short)) &&
-                   (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
-                   (((target_register_t)src & (sizeof(short)-1)) == 0)) {
-            
-            short_dst = (unsigned short *)dst;
-            short_src = (unsigned short *)src;
-
-            __write_prog_uint16(short_dst++, *short_src++);
-            memCount -= sizeof(short);
-
-            dst = (unsigned char *)short_dst;
-            src = (unsigned char *)short_src;
-        } else {
-            __write_prog_uint8(dst++, *src++);
-            memCount--;
-        }
-    }
-
-    __mem_fault = 0;
-
- err:
-    __mem_fault_handler = (void *)0;
+       unsigned long *long_dst;
+       unsigned long *long_src;
+       unsigned short *short_dst;
+       unsigned short *short_src;
+
+       // Zero memCount is not really an error, but the goto is necessary to
+       // keep some compilers from reordering stuff across the 'err' label.
+       if (memCount == 0)      goto err;
+
+       __mem_fault = 1;                      /* Defaults to 'fail'. Is cleared */
+                                                                                 /* when the copy loop completes.  */
+       __mem_fault_handler = &&err;
+
+       // See if it's safe to do multi-byte, aligned operations
+       while (memCount) {
+               if ((memCount >= sizeof(long)) &&
+                       (((target_register_t)dst & (sizeof(long)-1)) == 0) &&
+                       (((target_register_t)src & (sizeof(long)-1)) == 0)) {
+
+                       long_dst = (unsigned long *)dst;
+                       long_src = (unsigned long *)src;
+
+                       __write_prog_uint32(long_dst++, *long_src++);
+                       memCount -= sizeof(long);
+
+                       dst = (unsigned char *)long_dst;
+                       src = (unsigned char *)long_src;
+               } else if ((memCount >= sizeof(short)) &&
+                               (((target_register_t)dst & (sizeof(short)-1)) == 0) &&
+                               (((target_register_t)src & (sizeof(short)-1)) == 0)) {
+
+                       short_dst = (unsigned short *)dst;
+                       short_src = (unsigned short *)src;
+
+                       __write_prog_uint16(short_dst++, *short_src++);
+                       memCount -= sizeof(short);
+
+                       dst = (unsigned char *)short_dst;
+                       src = (unsigned char *)short_src;
+               } else {
+                       __write_prog_uint8(dst++, *src++);
+                       memCount--;
+               }
+       }
+
+       __mem_fault = 0;
+
+err:
+       __mem_fault_handler = (void *)0;
 }
 
 /*
 }
 
 /*
@@ -995,12 +995,12 @@ __do_copy_to_progmem (unsigned char* src, unsigned char* dst)
 int
 __read_progmem_safe (void *dst, void *src, int count)
 {
 int
 __read_progmem_safe (void *dst, void *src, int count)
 {
-  if( !CYG_HAL_STUB_PERMIT_CODE_READ( src, count ) )
-    return 0;
+       if( !CYG_HAL_STUB_PERMIT_CODE_READ( src, count ) )
+               return 0;
 
 
-  memCount = count;
-  __do_copy_from_progmem((unsigned char*) src, (unsigned char*) dst);
-  return count - memCount;      // return number of bytes successfully read
+       memCount = count;
+       __do_copy_from_progmem((unsigned char*) src, (unsigned char*) dst);
+       return count - memCount;      // return number of bytes successfully read
 }
 
 /*
 }
 
 /*
@@ -1011,36 +1011,36 @@ __read_progmem_safe (void *dst, void *src, int count)
 int
 __write_progmem_safe (void *src, void *dst, int count)
 {
 int
 __write_progmem_safe (void *src, void *dst, int count)
 {
-  if( !CYG_HAL_STUB_PERMIT_CODE_WRITE( dst, count ) )
-    return 0;
+       if( !CYG_HAL_STUB_PERMIT_CODE_WRITE( dst, count ) )
+               return 0;
 
 
-  memCount = count;
-  __do_copy_to_progmem((unsigned char*) src, (unsigned char*) dst);
-  return count - memCount;      // return number of bytes successfully written
+       memCount = count;
+       __do_copy_to_progmem((unsigned char*) src, (unsigned char*) dst);
+       return count - memCount;      // return number of bytes successfully written
 }
 #endif
 
 //-----------------------------------------------------------------------------
 // Target extras?!
 }
 #endif
 
 //-----------------------------------------------------------------------------
 // Target extras?!
-int 
+int
 __process_target_query(char * pkt, char * out, int maxOut)
 { return 0 ; }
 __process_target_query(char * pkt, char * out, int maxOut)
 { return 0 ; }
-int 
+int
 __process_target_set(char * pkt, char * out, int maxout)
 { return 0 ; }
 __process_target_set(char * pkt, char * out, int maxout)
 { return 0 ; }
-int 
+int
 __process_target_packet(char * pkt, char * out, int maxout)
 { return 0 ; }
 
 // GDB string output, making sure interrupts are disabled.
 // This function gets used by some diag output functions.
 __process_target_packet(char * pkt, char * out, int maxout)
 { return 0 ; }
 
 // GDB string output, making sure interrupts are disabled.
 // This function gets used by some diag output functions.
-void 
+void
 hal_output_gdb_string(target_register_t str, int string_len)
 {
 hal_output_gdb_string(target_register_t str, int string_len)
 {
-    unsigned long __state;
-    HAL_DISABLE_INTERRUPTS(__state);
-    __output_gdb_string(str, string_len);
-    HAL_RESTORE_INTERRUPTS(__state);
+       unsigned long __state;
+       HAL_DISABLE_INTERRUPTS(__state);
+       __output_gdb_string(str, string_len);
+       HAL_RESTORE_INTERRUPTS(__state);
 }
 
 #endif // CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 }
 
 #endif // CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
index 012360d506960d29fac9a9ab9e6abefb2a16ee82..7e7be1d7b67b11d496d5cc898d116d45b115ee8a 100644 (file)
@@ -43,9 +43,9 @@
 // Author(s):     Red Hat, nickg
 // Contributors:  Red Hat, nickg
 // Date:          1998-08-25
 // Author(s):     Red Hat, nickg
 // Contributors:  Red Hat, nickg
 // Date:          1998-08-25
-// Purpose:       
+// Purpose:
 // Description:   Provides multi-threaded debug support
 // Description:   Provides multi-threaded debug support
-// Usage:         
+// Usage:
 //
 //####DESCRIPTIONEND####
 //
 //
 //####DESCRIPTIONEND####
 //
@@ -58,8 +58,8 @@
 // #ifdef __ECOS__
 #include <pkgconf/hal.h>
 
 // #ifdef __ECOS__
 #include <pkgconf/hal.h>
 
-#if defined(CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT) \
-    && defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS)
+#if defined(CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT) && \
+       defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS)
 // #endif // __ECOS__
 
 /* FIXME: Scan this module for correct sizes of fields in packets */
 // #endif // __ECOS__
 
 /* FIXME: Scan this module for correct sizes of fields in packets */
 #endif
 
 #define DEBUG_THREADS 1
 #endif
 
 #define DEBUG_THREADS 1
-#define UNIT_TEST     0
-#define GDB_MOCKUP    0
+#define UNIT_TEST        0
+#define GDB_MOCKUP       0
 
 
 #define STUB_BUF_MAX 300 /* for range checking of packet lengths */
 
 
 #define STUB_BUF_MAX 300 /* for range checking of packet lengths */
-     
+
 #include "thread-pkts.h"
 
 #ifdef __ECOS__
 #include "thread-pkts.h"
 
 #ifdef __ECOS__
 /*
  * Export the continue and "general" (context) thread IDs from GDB.
  */
 /*
  * Export the continue and "general" (context) thread IDs from GDB.
  */
-int _gdb_cont_thread ;
-int _gdb_general_thread ;
+int _gdb_cont_thread;
+int _gdb_general_thread;
 
 #if !defined(PKT_DEBUG)
 #define PKT_DEBUG 0
 #endif
 
 #if !defined(PKT_DEBUG)
 #define PKT_DEBUG 0
 #endif
-extern void output_string(char * message) ;
+extern void output_string(char *message);
 
 #if PKT_DEBUG
 
 #if PKT_DEBUG
-void output_threadid(char * title,threadref * ref) ;
+void output_threadid(char *title, threadref *ref);
 #warning "PKT_DEBUG macros engaged"
 #warning "PKT_DEBUG macros engaged"
-#define PKT_TRACE(title,packet) \
-{ output_string(title) ; output_string(packet) ; output_string("\n") ;}
+#define PKT_TRACE(title, packet) \
+{ output_string(title); output_string(packet); output_string("\n");}
 #else
 #else
-#define PKT_TRACE(title,packet) {}
-#endif 
+#define PKT_TRACE(title, packet) {}
+#endif
 
 
 /* This is going to be irregular because the various implementations
 
 
 /* This is going to be irregular because the various implementations
@@ -122,52 +122,50 @@ void output_threadid(char * title,threadref * ref) ;
      alt_stub_registers
  */
 
      alt_stub_registers
  */
 
-extern target_register_t * _registers ;
-    /* A pointer to the current set of registers */
+extern target_register_t *_registers;
+       /* A pointer to the current set of registers */
 extern target_register_t registers[]; /* The current saved registers */
 extern target_register_t registers[]; /* The current saved registers */
-extern target_register_t alt_registers[] ;
-    /* Thread or saved process state */
+extern target_register_t alt_registers[];
+       /* Thread or saved process state */
 
 
 
 
-static void stub_copy_registers(
-                           target_register_t * dest,
-                           target_register_t *src
-                           )
+static void stub_copy_registers(target_register_t *dest,
+                                                               target_register_t *src)
 {
 {
-  target_register_t * limit ;
-  limit = dest + NUMREGS ;
+       target_register_t *limit;
+       limit = dest + NUMREGS;
 
 
-  while (dest < limit)  *dest++ = *src++ ;
+       while (dest < limit)  *dest++ = *src++;
 }
 
 #ifdef __ECOS__
 }
 
 #ifdef __ECOS__
-void __stub_copy_registers(target_register_t * dest,
-                           target_register_t *src)
+void __stub_copy_registers(target_register_t *dest,
+                                               target_register_t *src)
 {
 {
-    stub_copy_registers(dest, src);
+       stub_copy_registers(dest, src);
 }
 #endif // __ECOS__
 
 }
 #endif // __ECOS__
 
-extern int stubhex(char ch) ;
+extern int stubhex(char ch);
 
 /* ----- STUB_PACK_NAK ----------------------------------- */
 /* Pack an error response into the response packet */
 
 
 /* ----- STUB_PACK_NAK ----------------------------------- */
 /* Pack an error response into the response packet */
 
-char * stub_pack_nak(char * outbuf)
+char *stub_pack_nak(char *outbuf)
 {
 {
-  *outbuf++ = 'E' ;
-  *outbuf++ = '0' ;
-  *outbuf++ = '2' ;
-  return outbuf ;
+       *outbuf++ = 'E';
+       *outbuf++ = '0';
+       *outbuf++ = '2';
+       return outbuf;
 } /* stub_pack_nak */
 
 /* ----- STUB_PACK_ACK -------------------------- */
 /* Pack an OK achnowledgement */
 } /* stub_pack_nak */
 
 /* ----- STUB_PACK_ACK -------------------------- */
 /* Pack an OK achnowledgement */
-char * stub_pack_ack(char * outbuf)
+char *stub_pack_ack(char *outbuf)
 {
 {
-  *outbuf++ = 'O' ;
-  *outbuf++ = 'K' ;
-  return outbuf ;
+       *outbuf++ = 'O';
+       *outbuf++ = 'K';
+       return outbuf;
 } /* stub_pack_ack */
 
 /* ------- STUB_UNPACK_INT ------------------------------- */
 } /* stub_pack_ack */
 
 /* ------- STUB_UNPACK_INT ------------------------------- */
@@ -175,87 +173,93 @@ char * stub_pack_ack(char * outbuf)
 /* This is where I wish functions could return several values
    I would also advance the buffer pointer */
 
 /* This is where I wish functions could return several values
    I would also advance the buffer pointer */
 
-int stub_unpack_int(char * buff,int fieldlength)
+int stub_unpack_int(char *buff, int fieldlength)
 {
 {
-  int retval = 0 ;
-  int nibble ;
-  while (fieldlength)
-    { nibble = stubhex(*buff++) ;
-      retval |= nibble ;
-      fieldlength-- ;
-      if (fieldlength) retval = retval << 4 ;
-    }
-  return retval ;
+       int retval = 0;
+       int nibble;
+       while (fieldlength)
+       { nibble = stubhex(*buff++);
+               retval |= nibble;
+               fieldlength--;
+               if (fieldlength) retval = retval << 4;
+       }
+       return retval;
 } /* stub_unpack_int */
 
 } /* stub_unpack_int */
 
-static char * unpack_byte(char * buf, int * value)
+static char *unpack_byte(char *buf, int *value)
 {
 {
-  *value = stub_unpack_int(buf,2) ;
-  return buf + 2 ;
+       *value = stub_unpack_int(buf, 2);
+       return buf + 2;
 }
 
 }
 
-static char * unpack_int(char * buf, int * value)
+static char *unpack_int(char *buf, int *value)
 {
 {
-  *value = stub_unpack_int(buf,8) ;
-  return buf + 8 ;
+       *value = stub_unpack_int(buf, 8);
+       return buf + 8;
 }
 
 /* We are NOT depending upon extensive libraries */
 }
 
 /* We are NOT depending upon extensive libraries */
-static int ishex(char ch,int *val)
+static int ishex(char ch, int *val)
 {
 {
-  if ((ch >= 'a') && (ch <= 'f'))
-    { *val =ch - 'a' + 10 ; return 1 ; }
-  if ((ch >= 'A') && (ch <= 'F'))
-    { *val = ch - 'A' + 10 ; return 1 ;}
-  if ((ch >= '0') && (ch <= '9'))
-    { *val = ch - '0' ; return 1 ; }
-  return 0 ;
+       if ((ch >= 'a') && (ch <= 'f')) {
+               *val = ch - 'a' + 10;
+               return 1;
+       }
+       if ((ch >= 'A') && (ch <= 'F')) {
+               *val = ch - 'A' + 10;
+               return 1;
+       }
+       if ((ch >= '0') && (ch <= '9')) {
+               *val = ch - '0';
+               return 1;
+       }
+       return 0;
 } /* ishex */
 
 } /* ishex */
 
-static char * unpack_nibble(char * buf,int * val) 
+static char *unpack_nibble(char *buf, int *val)
 {
 {
-  ishex(*buf++,val) ;
-  return buf ;
+       ishex(*buf++, val);
+       return buf;
 }
 
 
 static const char hexchars[] = "0123456789abcdef";
 
 }
 
 
 static const char hexchars[] = "0123456789abcdef";
 
-static char * pack_hex_byte(char * pkt, unsigned char byte)
+static char *pack_hex_byte(char *pkt, unsigned char byte)
 {
 {
-  *pkt++ = hexchars[(byte >> 4) & 0xf] ;
-  *pkt++ = hexchars[(byte & 0xf)] ;
-  return pkt ;
+       *pkt++ = hexchars[(byte >> 4) & 0xf];
+       *pkt++ = hexchars[(byte & 0xf)];
+       return pkt;
 } /* pack_hex_byte */
 
 #ifndef __ECOS__
 /* ---- STUB_PACK_VARLEN_HEX ------------------------------------- */
 /* Format a variable length stream of hex bytes */
 
 } /* pack_hex_byte */
 
 #ifndef __ECOS__
 /* ---- STUB_PACK_VARLEN_HEX ------------------------------------- */
 /* Format a variable length stream of hex bytes */
 
-static char * pack_varlen_hex(
-                       char * pkt,
-                       unsigned int value)
+static char *pack_varlen_hex(
+       char *pkt,
+       unsigned int value)
 {
 {
-  int i ;
-  static unsigned char n[8] ;
-  if (value == 0)
-    {
-      *pkt++ = '0' ;
-      return pkt ;
-    }
-  else
-    {
-      i = 8 ;
-      while (i-- >= 0 )  /* unpack nibbles into a char array */
-        {
-          n[i] = value & 0x0f ;
-          value = value >> 4 ;
-        }
-      i = 0 ;                  /* we had decrmented it to -1 */
-      while (n[i] == 0 ) i++ ; /* drop leading zeroes */
-      while (i++ < 8) *pkt++ = hexchars[n[i]] ; /* pack the number */
-    }
-  return pkt ;
+       int i;
+       static unsigned char n[8];
+       if (value == 0)
+       {
+               *pkt++ = '0';
+               return pkt;
+       }
+       else
+       {
+               i = 8;
+               while (i-- >= 0 )  /* unpack nibbles into a char array */
+               {
+                       n[i] = value & 0x0f;
+                       value = value >> 4;
+               }
+               i = 0;                  /* we had decrmented it to -1 */
+               while (n[i] == 0 ) i++; /* drop leading zeroes */
+               while (i++ < 8) *pkt++ = hexchars[n[i]]; /* pack the number */
+       }
+       return pkt;
 } /* pack_varlen_hex */
 #endif // !__ECOS__
 
 } /* pack_varlen_hex */
 #endif // !__ECOS__
 
@@ -269,22 +273,22 @@ static char * pack_varlen_hex(
 /* This unpacks hex strings that may have been packed using sprintf(%x) */
 /* We assume some non-hex delimits them */
 
 /* This unpacks hex strings that may have been packed using sprintf(%x) */
 /* We assume some non-hex delimits them */
 
-char * unpack_varlen_hex(
-                              char * buff,    /* packet to parse */
-                              int * result)
+char *unpack_varlen_hex(
+       char *buff,    /* packet to parse */
+       int *result)
 {
 {
-  int nibble ;
-  int retval ;
-  retval = 0 ;
-
-  while (ishex(*buff,&nibble))
-    {
-      buff++ ;
-      retval = retval  << 4 ;
-      retval |= nibble & 0x0f ;
-    }
-  *result = retval ;
-  return buff ;
+       int nibble;
+       int retval;
+       retval = 0;
+
+       while (ishex(*buff, &nibble))
+       {
+               buff++;
+               retval = retval  << 4;
+               retval |= nibble & 0x0f;
+       }
+       *result = retval;
+       return buff;
 } /* stub_unpack_varlen_int */
 
 
 } /* stub_unpack_varlen_int */
 
 
@@ -293,32 +297,32 @@ char * unpack_varlen_hex(
 
 #define BUFTHREADIDSIZ 16 /* encode 64 bits in 16 chars of hex */
 
 
 #define BUFTHREADIDSIZ 16 /* encode 64 bits in 16 chars of hex */
 
-static char * unpack_threadid(char * inbuf, threadref * id)
+static char *unpack_threadid(char *inbuf, threadref *id)
 {
 {
-  char * altref ;
-  char * limit  = inbuf + BUFTHREADIDSIZ ;
-  int x,y ;
-  altref = (char *) id ;
-
-  while (inbuf < limit)
-    {
-      x = stubhex(*inbuf++) ;
-      y = stubhex(*inbuf++) ;
-      *altref++ = (x << 4) | y ;
-    }
-  return inbuf ;
+       char *altref;
+       char *limit  = inbuf + BUFTHREADIDSIZ;
+       int x, y;
+       altref = (char *)id;
+
+       while (inbuf < limit)
+       {
+               x = stubhex(*inbuf++);
+               y = stubhex(*inbuf++);
+               *altref++ = (x << 4) | y;
+       }
+       return inbuf;
 } /* unpack_threadid */
 
 
 
 /* Pack an integer use leading zeroes */
 } /* unpack_threadid */
 
 
 
 /* Pack an integer use leading zeroes */
-static char * pack_int(char * buf,int value)
+static char *pack_int(char *buf, int value)
 {
 {
-  buf = pack_hex_byte(buf,(value>> 24)& 0xff) ;
-  buf = pack_hex_byte(buf,(value >>16)& 0xff) ;
-  buf = pack_hex_byte(buf,(value >>8) & 0x0ff) ;
-  buf = pack_hex_byte(buf,(value & 0xff)) ;
-  return buf ;
+       buf = pack_hex_byte(buf, (value >> 24) & 0xff);
+       buf = pack_hex_byte(buf, (value >> 16) & 0xff);
+       buf = pack_hex_byte(buf, (value >> 8) & 0x0ff);
+       buf = pack_hex_byte(buf, value & 0xff);
+       return buf;
 } /* pack_int */
 
 
 } /* pack_int */
 
 
@@ -330,35 +334,35 @@ static char * pack_int(char * buf,int value)
    preclude filtering for # I am assuming this is a constraint.
 */
 
    preclude filtering for # I am assuming this is a constraint.
 */
 
-static char * pack_raw_string(char * pkt,char * string)
+static char *pack_raw_string(char *pkt, char *string)
 {
 {
-  char ch ;
-  while (0 != (ch = *string++)) *pkt++ = ch ;
-  return pkt ;
+       char ch;
+       while (0 != (ch = *string++)) *pkt++ = ch;
+       return pkt;
 }
 
 }
 
-static char * pack_string(
-                          char * pkt,
-                          char * string)
+static char *pack_string(
+       char *pkt,
+       char *string)
 {
 {
-  char ch ;
+       char ch;
 #ifdef __ECOS__
 #ifdef __ECOS__
-  int len = 0;
-  char *s = string;
-  while( *s++ ) len++;
+       int len = 0;
+       char *s = string;
+       while( *s++ ) len++;
 #else  // __ECOS__
 #else  // __ECOS__
-  int len ;
-  len = strlen(string) ;
+       int len;
+       len = strlen(string);
 #endif // __ECOS
 #endif // __ECOS
-  if (len > 200 ) len = 200 ; /* Bigger than most GDB packets, junk??? */
-  pkt = pack_hex_byte(pkt,len) ;
-  while (len-- > 0)
-    { 
-       ch = *string++ ;
-       if ((ch == '\0') || (ch == '#')) ch = '*' ; /* Protect encapsulation */
-       *pkt++ = ch ;
-    }
-  return pkt ;
+       if (len > 200 ) len = 200; /* Bigger than most GDB packets, junk??? */
+       pkt = pack_hex_byte(pkt, len);
+       while (len-- > 0)
+       {
+               ch = *string++;
+               if ((ch == '\0') || (ch == '#')) ch = '*'; /* Protect encapsulation */
+               *pkt++ = ch;
+       }
+       return pkt;
 } /* pack_string */
 
 
 } /* pack_string */
 
 
@@ -366,14 +370,14 @@ static char * pack_string(
 /* Convert a binary 64 bit threadid  and pack it into a xmit buffer */
 /* Return the advanced buffer pointer */
 
 /* Convert a binary 64 bit threadid  and pack it into a xmit buffer */
 /* Return the advanced buffer pointer */
 
-static char * pack_threadid(char * pkt, threadref * id)
+static char *pack_threadid(char *pkt, threadref *id)
 {
 {
-  char * limit ;
-  unsigned char * altid ;
-  altid = (unsigned char *) id ;
-  limit = pkt + BUFTHREADIDSIZ ;
-  while (pkt < limit) pkt = pack_hex_byte(pkt,*altid++) ;
-  return pkt ;
+       char *limit;
+       unsigned char *altid;
+       altid = (unsigned char *)id;
+       limit = pkt + BUFTHREADIDSIZ;
+       while (pkt < limit) pkt = pack_hex_byte(pkt, *altid++);
+       return pkt;
 } /* stub_pack_threadid */
 
 /* UNFORTUNATELY, not all of the extended debugging system has yet been
 } /* stub_pack_threadid */
 
 /* UNFORTUNATELY, not all of the extended debugging system has yet been
@@ -381,118 +385,118 @@ static char * pack_threadid(char * pkt, threadref * id)
    These routines do the conversion.
    An array of bytes is the correct treatment of an opaque identifier.
    ints have endian issues.
    These routines do the conversion.
    An array of bytes is the correct treatment of an opaque identifier.
    ints have endian issues.
- */
+*/
 
 
-static void int_to_threadref(threadref * id, int value)
+static void int_to_threadref(threadref *id, int value)
 {
 {
-  unsigned char * scan ;
-  scan = (unsigned char *) id ;
-   {
-    int i = 4 ;
-    while (i--) *scan++  = 0 ;
-  }
-  *scan++ = (value >> 24) & 0xff ;
-  *scan++ = (value >> 16) & 0xff ;
-  *scan++ = (value >> 8) & 0xff ;
-  *scan++ = (value & 0xff) ;
+       unsigned char *scan;
+       scan = (unsigned char *)id;
+       {
+               int i = 4;
+               while (i--) *scan++  = 0;
+       }
+       *scan++ = (value >> 24) & 0xff;
+       *scan++ = (value >> 16) & 0xff;
+       *scan++ = (value >> 8) & 0xff;
+       *scan++ = (value & 0xff);
 }
 
 }
 
-static int threadref_to_int(threadref * ref)
+static int threadref_to_int(threadref *ref)
 {
 {
-  int value = 0 ;
-  unsigned char * scan ;
-  int i ;
-  
-  scan = (char *) ref ;
-  scan += 4 ;
-  i = 4 ;
-  while (i-- > 0) value = (value << 8) | ((*scan++) & 0xff) ;
-  return value ;
+       int value = 0;
+       unsigned char *scan;
+       int i;
+
+       scan = (char *)ref;
+       scan += 4;
+       i = 4;
+       while (i-- > 0) value = (value << 8) | ((*scan++) & 0xff);
+       return value;
 } /* threadref_to_int */
 
 } /* threadref_to_int */
 
-void copy_threadref(threadref * dest, threadref * src)
+void copy_threadref(threadref *dest, threadref *src)
 {
 {
-  int i ;
-  unsigned char * csrc, * cdest ;
-  csrc = (unsigned char *) src ;
-  cdest = (unsigned char *) dest ;
-  i = 8 ;
-  while (i--) *cdest++ = *csrc++ ;
+       int i;
+       unsigned char *csrc, *cdest;
+       csrc = (unsigned char *)src;
+       cdest = (unsigned char *)dest;
+       i = 8;
+       while (i--) *cdest++ = *csrc++;
 }
 
 
 int threadmatch(
 }
 
 
 int threadmatch(
-                threadref * dest ,
-                threadref * src
-                )
+       threadref *dest,
+       threadref *src
+       )
 {
 {
-  unsigned char * srcp, * destp ;
-  int i , result ;
-  srcp = (char *) src ;
-  destp = (char *) dest ;
-  i = 8 ;
-  result = 1 ;
-  while (i-- > 0 ) result &= (*srcp++ == *destp++) ? 1 : 0 ;
-  return result ;
-} /* threadmatch */           
+       unsigned char *srcp, *destp;
+       int i, result;
+       srcp = (char *)src;
+       destp = (char *)dest;
+       i = 8;
+       result = 1;
+       while (i-- > 0 ) result &= (*srcp++ == *destp++) ? 1 : 0;
+       return result;
+} /* threadmatch */
 
 
 
 
 
 
-static char * Tpkt_threadtag = "thread:" ;
+static char *Tpkt_threadtag = "thread:";
 
 /* ----- STUB_PACK_TPKT_THREADID ------------------------------------ */
 /* retreive, tag and insert a thread identifier into a T packet. */
 /* Insert nothing if the thread identifier is not available */
 
 
 /* ----- STUB_PACK_TPKT_THREADID ------------------------------------ */
 /* retreive, tag and insert a thread identifier into a T packet. */
 /* Insert nothing if the thread identifier is not available */
 
-char * stub_pack_Tpkt_threadid(char * pkt)
+char *stub_pack_Tpkt_threadid(char *pkt)
 {
 {
-  static threadref thread ;
-  int fmt = 0 ; /* old format */
-  PKT_TRACE("Tpkt-id","---") ;
-  if (dbg_currthread(&thread))
-    {
-      pkt = pack_raw_string(pkt,Tpkt_threadtag) ;
-      if (fmt)
-        pkt = pack_threadid(pkt,&thread) ;
-      else
-          /* Until GDB lengthens its thread ids, we have to MASH
-             the threadid into somthing shorter. PLEASE FIX GDB */
-          pkt = pack_int(pkt,threadref_to_int(&thread)) ;
-      *pkt++ = ';'  ; /* terminate variable length int */
-      *pkt = '\0' ; /* Null terminate to allow string to be printed, no++ */
-    }
-  PKT_TRACE("packedTpkt","--") ;
-  return pkt ;
+       static threadref thread;
+       int fmt = 0; /* old format */
+       PKT_TRACE("Tpkt-id", "---");
+       if (dbg_currthread(&thread))
+       {
+               pkt = pack_raw_string(pkt, Tpkt_threadtag);
+               if (fmt)
+                       pkt = pack_threadid(pkt, &thread);
+               else
+                       /* Until GDB lengthens its thread ids, we have to MASH
+                          the threadid into somthing shorter. PLEASE FIX GDB */
+                       pkt = pack_int(pkt, threadref_to_int(&thread));
+               *pkt++ = ';' ; /* terminate variable length int */
+               *pkt = '\0'; /* Null terminate to allow string to be printed, no++ */
+       }
+       PKT_TRACE("packedTpkt", "--");
+       return pkt;
 } /* stub_pack_Tpkt_threadid */
 
 long stub_get_currthread (void)
 {
 } /* stub_pack_Tpkt_threadid */
 
 long stub_get_currthread (void)
 {
-  threadref thread ;
-  
-  if (dbg_currthread(&thread))
-    return threadref_to_int(&thread) ;
-  else
-    return 0 ;
+       threadref thread;
+
+       if (dbg_currthread(&thread))
+               return threadref_to_int(&thread);
+       else
+               return 0;
 }
 
 void stub_pkt_currthread(
 }
 
 void stub_pkt_currthread(
-                                char * inbuf,
-                                char * outbuf,
-                                int bufmax)
+       char *inbuf,
+       char *outbuf,
+       int bufmax)
 {
 {
-  threadref thread ;
-  char * base_out ;
-  base_out = outbuf ;
-  
-  if (dbg_currthread(&thread))
-    {
-      *outbuf++ = 'Q' ;
-      *outbuf++ = 'C' ; /* FIXME: Is this a reasonable code */
-      outbuf = pack_int(outbuf, threadref_to_int(&thread)) ; /* Short form */
-    }
-  else outbuf = stub_pack_nak(outbuf) ;
-  *outbuf = '\0' ; /* terminate response packet */
-  PKT_TRACE("stub_pkt_currthread(resp) ",base_out) ;
+       threadref thread;
+       char *base_out;
+       base_out = outbuf;
+
+       if (dbg_currthread(&thread))
+       {
+               *outbuf++ = 'Q';
+               *outbuf++ = 'C'; /* FIXME: Is this a reasonable code */
+               outbuf = pack_int(outbuf, threadref_to_int(&thread)); /* Short form */
+       }
+       else outbuf = stub_pack_nak(outbuf);
+       *outbuf = '\0'; /* terminate response packet */
+       PKT_TRACE("stub_pkt_currthread(resp) ", base_out);
 } /* stub_pkt_currthread */
 
 /* ----- STUB_PKT_THREAD_ALIVE --------------------------------- */
 } /* stub_pkt_currthread */
 
 /* ----- STUB_PKT_THREAD_ALIVE --------------------------------- */
@@ -500,38 +504,38 @@ void stub_pkt_currthread(
 
 static int thread_alive (int id)
 {
 
 static int thread_alive (int id)
 {
-  threadref thread ;
-  struct cygmon_thread_debug_info info ;
-
-  int_to_threadref(&thread, id) ;
-  if (dbg_threadinfo(&thread, &info) &&
-      info.context_exists)
-    return 1 ;
-  else
-    return 0 ;
+       threadref thread;
+       struct cygmon_thread_debug_info info;
+
+       int_to_threadref(&thread, id);
+       if (dbg_threadinfo(&thread, &info) &&
+               info.context_exists)
+               return 1;
+       else
+               return 0;
 }
 
 }
 
-void stub_pkt_thread_alive(char * inbuf,
-                           char * outbuf,
-                           int bufmax)
+void stub_pkt_thread_alive(char *inbuf,
+                                               char *outbuf,
+                                               int bufmax)
 {
 {
-  char * prebuf = inbuf ;
-  int result ;
-  
-  if (prebuf != (inbuf = unpack_varlen_hex(inbuf,&result)))
-    {
-      if (thread_alive(result))
-        {
-          outbuf = stub_pack_ack(outbuf) ;
-          *outbuf = '\0' ;
-          return ;
-        }
-    }
-  outbuf = stub_pack_nak(outbuf) ;
-  *outbuf = '\0' ; /* terminate the response message */
+       char *prebuf = inbuf;
+       int result;
+
+       if (prebuf != (inbuf = unpack_varlen_hex(inbuf, &result)))
+       {
+               if (thread_alive(result))
+               {
+                       outbuf = stub_pack_ack(outbuf);
+                       *outbuf = '\0';
+                       return;
+               }
+       }
+       outbuf = stub_pack_nak(outbuf);
+       *outbuf = '\0'; /* terminate the response message */
 } /* stub_pkt_thread_alive */
 
 } /* stub_pkt_thread_alive */
 
+
 
 /* ----- STUB_PKT_CHANGETHREAD ------------------------------- */
 /* Switch the display of registers to that of a saved context */
 
 /* ----- STUB_PKT_CHANGETHREAD ------------------------------- */
 /* Switch the display of registers to that of a saved context */
@@ -540,101 +544,101 @@ void stub_pkt_thread_alive(char * inbuf,
    capability. Therefore, the option to change the context back does
    call the function to change registers. Also, there is no
    forced context switch.
    capability. Therefore, the option to change the context back does
    call the function to change registers. Also, there is no
    forced context switch.
-     'p' - New format, long long threadid, no special cases
-     'c' - Old format, id for continue, 32 bit threadid max, possably less
-                       -1 means continue all threads
-     'g' - Old Format, id for general use (other than continue)
-
-     replies:
-          OK for success
-          ENN for error
-   */
+   'p' - New format, long long threadid, no special cases
+   'c' - Old format, id for continue, 32 bit threadid max, possably less
+   -1 means continue all threads
+   'g' - Old Format, id for general use (other than continue)
+
+   replies:
+   OK for success
+   ENN for error
+*/
 
 void stub_pkt_changethread(
 
 void stub_pkt_changethread(
-                           char * inbuf,
-                           char * outbuf,
-                           int bufmax)
+       char *inbuf,
+       char *outbuf,
+       int bufmax)
 {
 {
-  threadref id ;
-  int idefined = -1 ;
-  char ch ;
-  PKT_TRACE("setthread-pkt ",inbuf) ;
-
-  /* Parse the incoming packet for a thread identifier */
-  switch (ch = *inbuf++ )  /* handle various packet formats */
-    {
-    case 'p' : /* New format: mode:8,threadid:64 */
-      inbuf = unpack_nibble(inbuf,&idefined) ;
-      inbuf = unpack_threadid(inbuf,&id) ; /* even if startflag */
-      break ;  
-    case 'c' : /* old format , specify thread for continue */
-      if (inbuf[0] == '-' && inbuf[1] == '1')   /* Hc-1 */
-        _gdb_cont_thread = 0 ;
-      else
-        inbuf = unpack_varlen_hex(inbuf, &_gdb_cont_thread) ;
-
-      if (_gdb_cont_thread == 0 ||              /* revert to any old thread */
-          thread_alive(_gdb_cont_thread))       /* specified thread is alive */
-        outbuf = stub_pack_ack(outbuf) ;
-      else
-        outbuf = stub_pack_nak(outbuf) ;
-      break ;
-    case 'g' : /* old format, specify thread for general operations */
-      /* OLD format: parse a variable length hex string */
-      /* OLD format consider special thread ids */
-      {
-        inbuf = unpack_varlen_hex(inbuf, &_gdb_general_thread) ;
-        int_to_threadref(&id, _gdb_general_thread) ;
-        switch (_gdb_general_thread)
-          {
-          case  0 : /* pick a thread, any thread */
-            idefined = 2 ; /* select original interrupted context */
-            break ;
-          case -1 : /* all threads */
-            idefined = 2 ;
-            break ;
-          default :
-            idefined = 1 ; /* select the specified thread */
-            break ;
-          }
-      }
-      break ;
-    default:
-      outbuf = stub_pack_nak(outbuf) ;
-      break ;
-    } /* handle various packet formats */
-
-  switch (idefined)
-    {
-    case -1 :
-      /* Packet not supported, already NAKed, no further action */
-      break ;
-    case 0 :
-      /* Switch back to interrupted context */
-      _registers = &registers[0] ;
-      break ;
-    case 1 :
-      /* copy the saved registers into the backup registers */
-      stub_copy_registers(alt_registers,registers) ;
-      /* The OS will now update the values it has in a saved process context*/
-      if (dbg_getthreadreg(&id,NUMREGS,&alt_registers[0]))
-        {
-          /* switch the registers pointer */
-          _registers = &alt_registers[0] ;
-          outbuf = stub_pack_ack(outbuf) ; 
-        }
-      else
-          outbuf = stub_pack_nak(outbuf) ;
-      break ;
-    case 2 :
-      /* switch to interrupted context */ 
-      outbuf = stub_pack_ack(outbuf) ;
-      break ;
-    default:
-      outbuf = stub_pack_nak(outbuf) ;
-      break ;
-    }
-  *outbuf = '\0' ; /* Terminate response pkt */
+       threadref id;
+       int idefined = -1;
+       char ch;
+       PKT_TRACE("setthread-pkt ", inbuf);
+
+       /* Parse the incoming packet for a thread identifier */
+       switch (ch = *inbuf++ )  /* handle various packet formats */
+       {
+       case 'p' : /* New format: mode:8, threadid:64 */
+               inbuf = unpack_nibble(inbuf, &idefined);
+               inbuf = unpack_threadid(inbuf, &id); /* even if startflag */
+               break;
+       case 'c' : /* old format, specify thread for continue */
+               if (inbuf[0] == '-' && inbuf[1] == '1')   /* Hc-1 */
+                       _gdb_cont_thread = 0;
+               else
+                       inbuf = unpack_varlen_hex(inbuf, &_gdb_cont_thread);
+
+               if (_gdb_cont_thread == 0 ||                      /* revert to any old thread */
+                       thread_alive(_gdb_cont_thread))           /* specified thread is alive */
+                       outbuf = stub_pack_ack(outbuf);
+               else
+                       outbuf = stub_pack_nak(outbuf);
+               break;
+       case 'g' : /* old format, specify thread for general operations */
+               /* OLD format: parse a variable length hex string */
+               /* OLD format consider special thread ids */
+       {
+               inbuf = unpack_varlen_hex(inbuf, &_gdb_general_thread);
+               int_to_threadref(&id, _gdb_general_thread);
+               switch (_gdb_general_thread)
+               {
+               case  0 : /* pick a thread, any thread */
+                       idefined = 2; /* select original interrupted context */
+                       break;
+               case -1 : /* all threads */
+                       idefined = 2;
+                       break;
+               default :
+                       idefined = 1; /* select the specified thread */
+                       break;
+               }
+       }
+       break;
+       default:
+               outbuf = stub_pack_nak(outbuf);
+               break;
+       } /* handle various packet formats */
+
+       switch (idefined)
+       {
+       case -1 :
+               /* Packet not supported, already NAKed, no further action */
+               break;
+       case 0 :
+               /* Switch back to interrupted context */
+               _registers = &registers[0];
+               break;
+       case 1 :
+               /* copy the saved registers into the backup registers */
+               stub_copy_registers(alt_registers, registers);
+               /* The OS will now update the values it has in a saved process context*/
+               if (dbg_getthreadreg(&id, NUMREGS, &alt_registers[0]))
+               {
+                       /* switch the registers pointer */
+                       _registers = &alt_registers[0];
+                       outbuf = stub_pack_ack(outbuf);
+               }
+               else
+                       outbuf = stub_pack_nak(outbuf);
+               break;
+       case 2 :
+               /* switch to interrupted context */
+               outbuf = stub_pack_ack(outbuf);
+               break;
+       default:
+               outbuf = stub_pack_nak(outbuf);
+               break;
+       }
+       *outbuf = '\0'; /* Terminate response pkt */
 } /* stub_pkt_changethread */
 
 
 } /* stub_pkt_changethread */
 
 
@@ -643,64 +647,62 @@ void stub_pkt_changethread(
 /* This may be part of a multipacket transaction               */
 /* It would be hard to tell in the response packet the difference
    between the end of list and an error in threadid encoding.
 /* This may be part of a multipacket transaction               */
 /* It would be hard to tell in the response packet the difference
    between the end of list and an error in threadid encoding.
-   */
+*/
 
 
-void stub_pkt_getthreadlist(char * inbuf,
-                            char * outbuf,
-                            int bufmax)
+void stub_pkt_getthreadlist(char *inbuf,
+                                                       char *outbuf,
+                                                       int bufmax)
 {
 {
-  char * count_ptr ;
-  char * done_ptr ;
-  char * limit ;
-  int start_flag , batchsize , result , count ;
-  static threadref lastthread, nextthread ;
+       char *count_ptr;
+       char *done_ptr;
+       char *limit;
+       int start_flag = 0, batchsize, result, count;
+       static threadref lastthread, nextthread;
 
 #if PKT_DEBUG
 
 #if PKT_DEBUG
-  char * r_base = outbuf ;
-#endif  
-  PKT_TRACE("pkt_getthreadlist: ",inbuf) ;
-
-  count = 0 ;
-  inbuf = unpack_nibble(inbuf,&start_flag) ;
-  inbuf = unpack_byte(inbuf,&batchsize) ;
-  inbuf = unpack_threadid(inbuf,&lastthread) ; /* even if startflag */
-
-  /*   Start building response packet    */
-  limit = outbuf + (bufmax - BUFTHREADIDSIZ - 10) ; /* id output packing limit */
-  *outbuf++ = 'Q'  ;
-  *outbuf++ = 'M'  ;
-  
-  /* Default values for count and done fields, save ptr to repatch */
-  count_ptr = outbuf ; /* save to repatch count */
-  outbuf = pack_hex_byte(outbuf,0) ;
-  done_ptr = outbuf ;  /* Backpatched later */
-  *outbuf++ = '0' ;    /* Done = 0 by default */
-  outbuf = pack_threadid(outbuf,&lastthread) ;
-  
-  /* Loop through the threadid packing */
-  while ((outbuf < limit) && (count < batchsize))
-    {
-      result = dbg_threadlist(start_flag,&lastthread,&nextthread) ;
-      start_flag = 0 ; /* redundant but effective */
-      if (!result)
-        { *done_ptr = '1' ;   /* pack the done flag */
-          break ;
-        }
+       char *r_base = outbuf;
+#endif
+       PKT_TRACE("pkt_getthreadlist: ", inbuf);
+
+       count = 0;
+       inbuf = unpack_nibble(inbuf, &start_flag);
+       inbuf = unpack_byte(inbuf, &batchsize);
+       inbuf = unpack_threadid(inbuf, &lastthread); /* even if startflag */
+
+       /*   Start building response packet    */
+       limit = outbuf + (bufmax - BUFTHREADIDSIZ - 10); /* id output packing limit */
+       *outbuf++ = 'Q' ;
+       *outbuf++ = 'M' ;
+
+       /* Default values for count and done fields, save ptr to repatch */
+       count_ptr = outbuf; /* save to repatch count */
+       outbuf = pack_hex_byte(outbuf, 0);
+       done_ptr = outbuf;  /* Backpatched later */
+       *outbuf++ = '0';    /* Done = 0 by default */
+       outbuf = pack_threadid(outbuf, &lastthread);
+
+       /* Loop through the threadid packing */
+       while ((outbuf < limit) && (count < batchsize)) {
+               result = dbg_threadlist(start_flag, &lastthread, &nextthread);
+               start_flag = 0; /* redundant but effective */
+               if (!result) {
+                       *done_ptr = '1';   /* pack the done flag */
+                       break;
+               }
 #if 0 /* DEBUG */
 #if 0 /* DEBUG */
-      if (threadmatch(&lastthread,&nextthread))
-        {
-          output_string("FAIL: Threadlist, not incrementing\n") ;
-          *done_ptr = '1' ;
-          break ;
-        }
-#endif      
-      count++ ;
-      outbuf = pack_threadid(outbuf,&nextthread) ;
-      copy_threadref(&lastthread,&nextthread) ;
-    }
-  pack_hex_byte(count_ptr,count) ;/* backpatch, Pack the count field */
-  *outbuf = '\0' ;
-  PKT_TRACE("pkt_getthreadlist(resp) ",r_base) ;
+               if (threadmatch(&lastthread, &nextthread)) {
+                       output_string("FAIL: Threadlist, not incrementing\n");
+                       *done_ptr = '1';
+                       break;
+               }
+#endif
+               count++;
+               outbuf = pack_threadid(outbuf, &nextthread);
+               copy_threadref(&lastthread, &nextthread);
+       }
+       pack_hex_byte(count_ptr, count);/* backpatch, Pack the count field */
+       *outbuf = '\0';
+       PKT_TRACE("pkt_getthreadlist(resp) ", r_base);
 } /* pkt_getthreadlist */
 
 
 } /* pkt_getthreadlist */
 
 
@@ -710,380 +712,380 @@ void stub_pkt_getthreadlist(char * inbuf,
 /* Get the detailed information about a specific thread or process */
 
 /*
 /* Get the detailed information about a specific thread or process */
 
 /*
-Encoding:
'Q':8,'P':8,mask:16
-
- Mask Fields
-        threadid:1,        # always request threadid 
-        context_exists:2,
-        display:4,          
-        unique_name:8,
-        more_display:16
- */  
+  Encoding:
 'Q':8, 'P':8, mask:16
+
 Mask Fields
+  threadid:1,        # always request threadid
+  context_exists:2,
+  display:4,
+  unique_name:8,
+  more_display:16
+*/
 
 void stub_pkt_getthreadinfo(
 
 void stub_pkt_getthreadinfo(
-                            char * inbuf,
-                            char * outbuf,
-                            int bufmax)
+       char *inbuf,
+       char *outbuf,
+       int bufmax)
 {
 {
-  int mask ;
-  int result ;
-  threadref thread ;
-  struct cygmon_thread_debug_info info ;
-
-  info.context_exists = 0 ;
-  info.thread_display = 0 ;
-  info.unique_thread_name = 0 ;
-  info.more_display = 0 ;
-
-  /* Assume the packet identification chars have already been
-     discarded by the packet demultiples routines */
-  PKT_TRACE("PKT getthreadinfo",inbuf) ;
-  
-  inbuf = unpack_int(inbuf,&mask) ;
-  inbuf = unpack_threadid(inbuf,&thread) ;
-  
-  result = dbg_threadinfo(&thread,&info) ; /* Make system call */
-
-  if (result)
-    {
-      *outbuf++ = 'q' ;
-      *outbuf++ = 'p' ;
-      outbuf = pack_int(outbuf,mask) ;
-      outbuf = pack_threadid(outbuf,&info.thread_id) ; /* echo threadid */
-      if (mask & 2)   /* context-exists */
-        {
-          outbuf = pack_int(outbuf,2) ; /* tag */
-          outbuf = pack_hex_byte(outbuf,2) ; /* length */
-          outbuf = pack_hex_byte(outbuf,info.context_exists) ;
-        }
-      if ((mask & 4)  && info.thread_display)/* display */
-        {
-          outbuf = pack_int(outbuf,4) ; /* tag */
-          outbuf = pack_string(outbuf,info.thread_display) ;
-        }
-      if ((mask & 8) && info.unique_thread_name) /* unique_name */
-        {
-          outbuf = pack_int(outbuf,8) ;
-          outbuf = pack_string(outbuf,info.unique_thread_name) ;
-        }
-      if ((mask & 16) && info.more_display)  /* more display */
-        {
-          outbuf = pack_int(outbuf,16) ; /* tag 16 */
-          outbuf = pack_string(outbuf,info.more_display) ;
-        }
-    }
-  else
-    {
-      PKT_TRACE("FAIL: dbg_threadinfo\n", "") ;
-      outbuf = stub_pack_nak(outbuf) ;
-    }
-  *outbuf = '\0' ;
+       int mask;
+       int result;
+       threadref thread;
+       struct cygmon_thread_debug_info info;
+
+       info.context_exists = 0;
+       info.thread_display = 0;
+       info.unique_thread_name = 0;
+       info.more_display = 0;
+
+       /* Assume the packet identification chars have already been
+          discarded by the packet demultiples routines */
+       PKT_TRACE("PKT getthreadinfo", inbuf);
+
+       inbuf = unpack_int(inbuf, &mask);
+       inbuf = unpack_threadid(inbuf, &thread);
+
+       result = dbg_threadinfo(&thread, &info); /* Make system call */
+
+       if (result)
+       {
+               *outbuf++ = 'q';
+               *outbuf++ = 'p';
+               outbuf = pack_int(outbuf, mask);
+               outbuf = pack_threadid(outbuf, &info.thread_id); /* echo threadid */
+               if (mask & 2)   /* context-exists */
+               {
+                       outbuf = pack_int(outbuf, 2); /* tag */
+                       outbuf = pack_hex_byte(outbuf, 2); /* length */
+                       outbuf = pack_hex_byte(outbuf, info.context_exists);
+               }
+               if ((mask & 4)  && info.thread_display)/* display */
+               {
+                       outbuf = pack_int(outbuf, 4); /* tag */
+                       outbuf = pack_string(outbuf, info.thread_display);
+               }
+               if ((mask & 8) && info.unique_thread_name) /* unique_name */
+               {
+                       outbuf = pack_int(outbuf, 8);
+                       outbuf = pack_string(outbuf, info.unique_thread_name);
+               }
+               if ((mask & 16) && info.more_display)  /* more display */
+               {
+                       outbuf = pack_int(outbuf, 16); /* tag 16 */
+                       outbuf = pack_string(outbuf, info.more_display);
+               }
+       }
+       else
+       {
+               PKT_TRACE("FAIL: dbg_threadinfo\n", "");
+               outbuf = stub_pack_nak(outbuf);
+       }
+       *outbuf = '\0';
 } /* stub_pkt_getthreadinfo */
 
 int stub_lock_scheduler(int lock,       /* 0 to unlock, 1 to lock */
 } /* stub_pkt_getthreadinfo */
 
 int stub_lock_scheduler(int lock,       /* 0 to unlock, 1 to lock */
-                        int mode,       /* 0 for step,  1 for continue */
-                        long id)        /* current thread */
+                                               int mode,       /* 0 for step,  1 for continue */
+                                               long id)        /* current thread */
 {
 {
-  threadref thread;
+       threadref thread;
 
 
-  int_to_threadref(&thread, id) ;
-  return dbg_scheduler(&thread, lock, mode) ;
+       int_to_threadref(&thread, id);
+       return dbg_scheduler(&thread, lock, mode);
 }
 
 }
 
-\f
+
 #if GDB_MOCKUP
 /* ------ MATCHED GDB SIDE PACKET ENCODING AND PARSING ----------------- */
 
 #if GDB_MOCKUP
 /* ------ MATCHED GDB SIDE PACKET ENCODING AND PARSING ----------------- */
 
-char * pack_nibble(char * buf, int nibble)
+char *pack_nibble(char *buf, int nibble)
 {
 {
-  *buf++ =  hexchars[(nibble & 0x0f)] ;
-  return buf ;
+       *buf++ =  hexchars[(nibble & 0x0f)];
+       return buf;
 } /* pack_nibble */
 
 #if 0
 } /* pack_nibble */
 
 #if 0
-static char * unpack_short(char * buf,int * value)
+static char *unpack_short(char *buf, int *value)
 {
 {
-  *value = stub_unpack_int(buf,4) ;
-  return buf + 4 ;
+       *value = stub_unpack_int(buf, 4);
+       return buf + 4;
 }
 
 }
 
-static char * pack_short(
-                  char * buf,
-                  unsigned int value)
+static char *pack_short(
+       char *buf,
+       unsigned int value)
 {
 {
-  buf = pack_hex_byte(buf,(value >> 8) & 0xff) ;
-  buf = pack_hex_byte(buf,(value & 0xff)) ;
-  return buf ;
+       buf = pack_hex_byte(buf, (value >> 8) & 0xff);
+       buf = pack_hex_byte(buf, (value & 0xff));
+       return buf;
 } /* pack_short */
 #endif
 
 
 /* Generally, I dont bury xmit and receive calls inside packet formatters
    and parsers
 } /* pack_short */
 #endif
 
 
 /* Generally, I dont bury xmit and receive calls inside packet formatters
    and parsers
-   */
+*/
 
 
 
 
 /* ----- PACK_SETTHREAD_REQUEST ------------------------------------- */
 /*      Encoding: ??? decode gdb/remote.c
 
 
 
 
 /* ----- PACK_SETTHREAD_REQUEST ------------------------------------- */
 /*      Encoding: ??? decode gdb/remote.c
-        'Q':8,'p':8,idefined:8,threadid:32 ;
-        */
-
-char * pack_setthread_request(
-                       char * buf,
-                       char fmt,   /* c,g or, p */
-                       int idformat ,
-                       threadref *  threadid )
+               'Q':8, 'p':8, idefined:8, threadid:32;
+*/
+
+char *pack_setthread_request(
+       char *buf,
+       char fmt,   /* c, g or, p */
+       int idformat,
+       threadref * threadid )
 {
 {
-  *buf++ = fmt ;
-  
-  if (fmt == 'p')
-    {  /* pack the long form */
-      buf = pack_nibble(buf,idformat) ;
-      buf = pack_threadid(buf,threadid)  ;
-    }
-  else
-    {  /* pack the shorter form - Serious truncation */
-      /* There are reserved identifieds 0 , -1 */
-      int quickref = threadref_to_int(threadid) ;
-      buf = pack_varlen_hex(buf,quickref) ;
-    }
-  *buf++ = '\0' ; /* end_of_packet  */
-  return buf ;
+       *buf++ = fmt;
+
+       if (fmt == 'p')
+       {  /* pack the long form */
+               buf = pack_nibble(buf, idformat);
+               buf = pack_threadid(buf, threadid) ;
+       }
+       else
+       {  /* pack the shorter form - Serious truncation */
+               /* There are reserved identifieds 0, -1 */
+               int quickref = threadref_to_int(threadid);
+               buf = pack_varlen_hex(buf, quickref);
+       }
+       *buf++ = '\0'; /* end_of_packet  */
+       return buf;
 } /* pack_setthread_request */
 
 
 
 /* -------- PACK_THREADLIST-REQUEST --------------------------------- */
 } /* pack_setthread_request */
 
 
 
 /* -------- PACK_THREADLIST-REQUEST --------------------------------- */
-/*    Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32   */
+/*    Format: i'Q':8, i"L":8, initflag:8, batchsize:16, lastthreadid:32   */
 
 
 
 
-char * pack_threadlist_request(
-                               char * pkt,
-                               int startflag,
-                               int threadcount,
-                               threadref * nextthread 
-                               )
+char *pack_threadlist_request(
+       char *pkt,
+       int startflag,
+       int threadcount,
+       threadref *nextthread
+       )
 {
 {
-  *pkt++ = 'q' ;
-  *pkt++ = 'L' ;
-  pkt = pack_nibble(pkt,startflag) ;     /* initflag 1 bytes */
-  pkt = pack_hex_byte(pkt,threadcount) ;   /* threadcount 2 bytes */
-  pkt = pack_threadid(pkt,nextthread) ;        /* 64 bit thread identifier */
-  *pkt = '\0' ;
-  return pkt ;
+       *pkt++ = 'q';
+       *pkt++ = 'L';
+       pkt = pack_nibble(pkt, startflag);     /* initflag 1 bytes */
+       pkt = pack_hex_byte(pkt, threadcount);   /* threadcount 2 bytes */
+       pkt = pack_threadid(pkt, nextthread);        /* 64 bit thread identifier */
+       *pkt = '\0';
+       return pkt;
 } /* remote_threadlist_request */
 
 
 
 
 /* ---------- PARSE_THREADLIST_RESPONSE ------------------------------------ */
 } /* remote_threadlist_request */
 
 
 
 
 /* ---------- PARSE_THREADLIST_RESPONSE ------------------------------------ */
-/* Encoding:   'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
+/* Encoding:   'q':8, 'M':8, count:16, done:8, argthreadid:64, (threadid:64)* */
 
 int parse_threadlist_response(
 
 int parse_threadlist_response(
-                              char * pkt,
-                              threadref * original_echo,
-                              threadref * resultlist,
-                              int * doneflag)
+       char *pkt,
+       threadref *original_echo,
+       threadref *resultlist,
+       int *doneflag)
 {
 {
-  char * limit ;
-  int count, resultcount , done ;
-  resultcount = 0 ;
-
-  /* assume the 'q' and 'M chars have been stripped */
-  PKT_TRACE("parse-threadlist-response ",pkt) ;
-  limit = pkt + (STUB_BUF_MAX - BUFTHREADIDSIZ) ; /* done parse past here */
-  pkt = unpack_byte(pkt,&count)  ;                /* count field */
-  pkt = unpack_nibble(pkt,&done) ;
-  /* The first threadid is the argument threadid */
-  pkt = unpack_threadid(pkt,original_echo) ; /* should match query packet */
-  while ((count-- > 0) && (pkt < limit))
-    {
-      pkt = unpack_threadid(pkt,resultlist++) ;
-      resultcount++ ;
-    }
-  if (doneflag) *doneflag = done ;
-  return resultcount ; /* successvalue */
+       char *limit;
+       int count, resultcount, done;
+       resultcount = 0;
+
+       /* assume the 'q' and 'M chars have been stripped */
+       PKT_TRACE("parse-threadlist-response ", pkt);
+       limit = pkt + (STUB_BUF_MAX - BUFTHREADIDSIZ); /* done parse past here */
+       pkt = unpack_byte(pkt, &count) ;                /* count field */
+       pkt = unpack_nibble(pkt, &done);
+       /* The first threadid is the argument threadid */
+       pkt = unpack_threadid(pkt, original_echo); /* should match query packet */
+       while ((count-- > 0) && (pkt < limit))
+       {
+               pkt = unpack_threadid(pkt, resultlist++);
+               resultcount++;
+       }
+       if (doneflag) *doneflag = done;
+       return resultcount; /* successvalue */
 } /* parse_threadlist_response */
 } /* parse_threadlist_response */
+
 struct gdb_ext_thread_info
 {
 struct gdb_ext_thread_info
 {
-  threadref threadid ;
-  int active ;
-  char display[256] ;
-  char shortname[32] ;
-  char more_display[256] ;
-} ;
+       threadref threadid;
+       int active;
+       char display[256];
+       char shortname[32];
+       char more_display[256];
+};
 
 
 /* ----- PACK_THREAD_INFO_REQUEST -------------------------------- */
 
 
 
 /* ----- PACK_THREAD_INFO_REQUEST -------------------------------- */
 
-/* 
-   threadid:1,        # always request threadid
-   context_exists:2,
-   display:4,
-   unique_name:8,
-   more_display:16
- */
+/*
+  threadid:1,        # always request threadid
+  context_exists:2,
+  display:4,
+  unique_name:8,
+  more_display:16
+*/
 
 
-/* Encoding:  'Q':8,'P':8,mask:32,threadid:64 */
+/* Encoding:  'Q':8, 'P':8, mask:32, threadid:64 */
 
 
-char * pack_threadinfo_request(char * pkt,
-                                int mode,
-                                threadref * id 
-                                )
+char *pack_threadinfo_request(char *pkt,
+                                                       int mode,
+                                                       threadref *id
+       )
 {
 {
-  *pkt++ = 'Q' ;
-  *pkt++ = 'P' ;
-  pkt = pack_int(pkt,mode) ; /* mode */
-  pkt = pack_threadid(pkt,id) ; /* threadid */
-  *pkt = '\0' ; /* terminate */
-  return pkt ;
+       *pkt++ = 'Q';
+       *pkt++ = 'P';
+       pkt = pack_int(pkt, mode); /* mode */
+       pkt = pack_threadid(pkt, id); /* threadid */
+       *pkt = '\0'; /* terminate */
+       return pkt;
 } /* pack_thread_info_request */
 
 
 
 } /* pack_thread_info_request */
 
 
 
-static char * unpack_string(
-                            char * src,
-                            char * dest,
-                            int length)
+static char *unpack_string(
+       char *src,
+       char *dest,
+       int length)
 {
 {
-  while (length--) *dest++ = *src++ ;
-  *dest = '\0' ;
-  return src ;
+       while (length--) *dest++ = *src++;
+       *dest = '\0';
+       return src;
 } /* unpack_string */
 
 
 } /* unpack_string */
 
 
-void output_threadid(char * title,threadref * ref)
+void output_threadid(char *title, threadref *ref)
 {
 {
-  char hexid[20] ;
-  pack_threadid(&hexid[0],ref) ; /* Convert threead id into hex */
-  hexid[16] = 0 ;
-  output_string(title) ; 
-  output_string(&hexid[0]) ; 
-  output_string("\n") ;
+       char hexid[20];
+       pack_threadid(&hexid[0], ref); /* Convert threead id into hex */
+       hexid[16] = 0;
+       output_string(title);
+       output_string(&hexid[0]);
+       output_string("\n");
 }
 
 /* ------ REMOTE_UPK_THREAD_INFO_RESPONSE ------------------------------- */
 /* Unpack the response of a detailed thread info packet */
 }
 
 /* ------ REMOTE_UPK_THREAD_INFO_RESPONSE ------------------------------- */
 /* Unpack the response of a detailed thread info packet */
-/* Encoding:  i'Q':8,i'R':8,argmask:16,threadid:64,(tag:8,length:16,data:x)* */
+/* Encoding:  i'Q':8, i'R':8, argmask:16, threadid:64, (tag:8, length:16, data:x)* */
 
 #define TAG_THREADID 1
 #define TAG_EXISTS 2
 #define TAG_DISPLAY 4
 #define TAG_THREADNAME 8
 
 #define TAG_THREADID 1
 #define TAG_EXISTS 2
 #define TAG_DISPLAY 4
 #define TAG_THREADNAME 8
-#define TAG_MOREDISPLAY 16 
+#define TAG_MOREDISPLAY 16
 
 
 int remote_upk_thread_info_response(
 
 
 int remote_upk_thread_info_response(
-                               char * pkt,
-                               threadref * expectedref ,
-                               struct gdb_ext_thread_info * info)
+       char *pkt,
+       threadref *expectedref,
+       struct gdb_ext_thread_info *info)
 {
 {
-  int mask, length ;
-  unsigned int tag ;
-  threadref ref ;
-  char * limit = pkt + 500 ; /* plausable parsing limit */
-  int retval = 1 ;
-
-  PKT_TRACE("upk-threadinfo ",pkt) ;
-
-  /* info->threadid = 0 ; FIXME: implement zero_threadref */
-  info->active = 0 ;
-  info->display[0] = '\0' ;
-  info->shortname[0] = '\0' ;
-  info->more_display[0] = '\0' ;
-
-  /* Assume the characters indicating the packet type have been stripped */
-  pkt = unpack_int(pkt,&mask) ;  /* arg mask */
-  pkt = unpack_threadid(pkt , &ref) ;
-                      
-  if (! threadmatch(&ref,expectedref))
-    { /* This is an answer to a different request */
-      output_string("FAIL Thread mismatch\n") ;
-      output_threadid("ref ",&ref) ;
-      output_threadid("expected ",expectedref) ;
-      return 0 ;
-    }
-  copy_threadref(&info->threadid,&ref) ;
-  
-  /* Loop on tagged fields , try to bail if somthing goes wrong */
-  if (mask==0)  output_string("OOPS NO MASK \n") ;
-
-  while ((pkt < limit) && mask && *pkt)  /* packets are terminated with nulls */
-    {
-      pkt = unpack_int(pkt,&tag) ;            /* tag */
-      pkt = unpack_byte(pkt,&length) ;   /* length */
-      if (! (tag & mask))  /* tags out of synch with mask */
-        {
-          output_string("FAIL: threadinfo tag mismatch\n") ;
-          retval = 0 ;
-          break ;
-        }
-      if (tag == TAG_THREADID)
-        {
-          output_string("unpack THREADID\n") ;
-          if (length != 16)
-            {
-              output_string("FAIL: length of threadid is not 16\n") ;
-              retval = 0 ;
-              break ;
-            }
-          pkt = unpack_threadid(pkt,&ref) ;
-          mask = mask & ~ TAG_THREADID ;
-          continue ;
-        }
-      if (tag == TAG_EXISTS)
-        {
-          info->active = stub_unpack_int(pkt,length) ;
-          pkt += length ;
-          mask = mask & ~(TAG_EXISTS) ;
-          if (length > 8)
-            {
-              output_string("FAIL: 'exists' length too long\n") ;
-              retval = 0 ;
-              break ;
-            }
-          continue ;
-        }
-      if (tag == TAG_THREADNAME)
-        {
-          pkt = unpack_string(pkt,&info->shortname[0],length) ;
-          mask = mask & ~TAG_THREADNAME ;
-          continue ;
-        }
-      if (tag == TAG_DISPLAY)
-        { 
-          pkt = unpack_string(pkt,&info->display[0],length) ;
-          mask = mask & ~TAG_DISPLAY ;
-          continue ;
-        }
-      if (tag == TAG_MOREDISPLAY)
-        { 
-          pkt = unpack_string(pkt,&info->more_display[0],length) ;
-          mask = mask & ~TAG_MOREDISPLAY ;
-          continue ;
-        }
-      output_string("FAIL: unknown info tag\n") ;
-      break ; /* Not a tag we know about */
-    }
-  return retval  ;
+       int mask, length;
+       unsigned int tag;
+       threadref ref;
+       char *limit = pkt + 500; /* plausable parsing limit */
+       int retval = 1;
+
+       PKT_TRACE("upk-threadinfo ", pkt);
+
+       /* info->threadid = 0; FIXME: implement zero_threadref */
+       info->active = 0;
+       info->display[0] = '\0';
+       info->shortname[0] = '\0';
+       info->more_display[0] = '\0';
+
+       /* Assume the characters indicating the packet type have been stripped */
+       pkt = unpack_int(pkt, &mask);  /* arg mask */
+       pkt = unpack_threadid(pkt, &ref);
+
+       if (! threadmatch(&ref, expectedref))
+       { /* This is an answer to a different request */
+               output_string("FAIL Thread mismatch\n");
+               output_threadid("ref ", &ref);
+               output_threadid("expected ", expectedref);
+               return 0;
+       }
+       copy_threadref(&info->threadid, &ref);
+
+       /* Loop on tagged fields, try to bail if somthing goes wrong */
+       if (mask==0)  output_string("OOPS NO MASK \n");
+
+       while ((pkt < limit) && mask && *pkt)  /* packets are terminated with nulls */
+       {
+               pkt = unpack_int(pkt, &tag);            /* tag */
+               pkt = unpack_byte(pkt, &length);   /* length */
+               if (! (tag & mask))  /* tags out of synch with mask */
+               {
+                       output_string("FAIL: threadinfo tag mismatch\n");
+                       retval = 0;
+                       break;
+               }
+               if (tag == TAG_THREADID)
+               {
+                       output_string("unpack THREADID\n");
+                       if (length != 16)
+                       {
+                               output_string("FAIL: length of threadid is not 16\n");
+                               retval = 0;
+                               break;
+                       }
+                       pkt = unpack_threadid(pkt, &ref);
+                       mask = mask & ~ TAG_THREADID;
+                       continue;
+               }
+               if (tag == TAG_EXISTS)
+               {
+                       info->active = stub_unpack_int(pkt, length);
+                       pkt += length;
+                       mask = mask & ~(TAG_EXISTS);
+                       if (length > 8)
+                       {
+                               output_string("FAIL: 'exists' length too long\n");
+                               retval = 0;
+                               break;
+                       }
+                       continue;
+               }
+               if (tag == TAG_THREADNAME)
+               {
+                       pkt = unpack_string(pkt, &info->shortname[0], length);
+                       mask = mask & ~TAG_THREADNAME;
+                       continue;
+               }
+               if (tag == TAG_DISPLAY)
+               {
+                       pkt = unpack_string(pkt, &info->display[0], length);
+                       mask = mask & ~TAG_DISPLAY;
+                       continue;
+               }
+               if (tag == TAG_MOREDISPLAY)
+               {
+                       pkt = unpack_string(pkt, &info->more_display[0], length);
+                       mask = mask & ~TAG_MOREDISPLAY;
+                       continue;
+               }
+               output_string("FAIL: unknown info tag\n");
+               break; /* Not a tag we know about */
+       }
+       return retval ;
 } /* parse-thread_info_response */
 
 
 /* ---- REMOTE_PACK_CURRTHREAD_REQUEST ---------------------------- */
 /* This is a request to emit the T packet */
 
 } /* parse-thread_info_response */
 
 
 /* ---- REMOTE_PACK_CURRTHREAD_REQUEST ---------------------------- */
 /* This is a request to emit the T packet */
 
-/* FORMAT: 'q':8,'C' */
+/* FORMAT: 'q':8, 'C' */
 
 
-char * remote_pack_currthread_request(char * pkt )
+char *remote_pack_currthread_request(char *pkt )
 {
 {
-  *pkt++ = 'q' ;
-  *pkt++ = 'C' ;
-  *pkt = '\0' ;
-  return pkt ;
+       *pkt++ = 'q';
+       *pkt++ = 'C';
+       *pkt = '\0';
+       return pkt;
 } /* remote_pack_currthread_request */
 
 
 } /* remote_pack_currthread_request */
 
 
@@ -1092,227 +1094,227 @@ char * remote_pack_currthread_request(char * pkt )
 
 
 int remote_upk_currthread_response(
 
 
 int remote_upk_currthread_response(
-                               char * pkt,
-                               int *thr )  /* Parse a T packet */
+       char *pkt,
+       int *thr )  /* Parse a T packet */
 {
 {
-  int retval = 0 ;
-  PKT_TRACE("upk-currthreadresp ",pkt) ;
+       int retval = 0;
+       PKT_TRACE("upk-currthreadresp ", pkt);
 
 #if 0
 
 #if 0
-  {
-    static char threadtag[8] =  "thread" ;
-    int retval = 0 ;
-    int i , found ;
-    char ch ;
-    int quickid ;
-
-  /* Unpack as a t packet */
-  while (((ch = *pkt++) != ':')    /* scan for : thread */
-         && (ch != '\0'))          /* stop at end of packet */
-
-    {
-      found = 0 ;
-      i = 0 ;
-      while ((ch = *pkt++) == threadtag[i++]) ;
-      if (i == 8) /* string match "thread" */
-        {
-          pkt = unpack_varlen_hex(pkt,&quickid) ;
-          retval = 1;
-          break ;
-        }
-      retval = 0 ;
-    }
-  }
+       {
+               static char threadtag[8] =  "thread";
+               int retval = 0;
+               int i, found;
+               char ch;
+               int quickid;
+
+               /* Unpack as a t packet */
+               while (((ch = *pkt++) != ':')    /* scan for : thread */
+                       && (ch != '\0'))          /* stop at end of packet */
+
+               {
+                       found = 0;
+                       i = 0;
+                       while ((ch = *pkt++) == threadtag[i++]);
+                       if (i == 8) /* string match "thread" */
+                       {
+                               pkt = unpack_varlen_hex(pkt, &quickid);
+                               retval = 1;
+                               break;
+                       }
+                       retval = 0;
+               }
+       }
 #else
 #else
-  pkt = unpack_threadid(pkt, thr) ;
-  retval = 1 ;
-#endif  
-  return retval ;
+       pkt = unpack_threadid(pkt, thr);
+       retval = 1;
+#endif
+       return retval;
 } /* remote_upk_currthread_response */
 
 
 /* -------- REMOTE_UPK-SIMPLE_ACK --------------------------------- */
 /* Decode a response which is eother "OK" or "Enn"
 } /* remote_upk_currthread_response */
 
 
 /* -------- REMOTE_UPK-SIMPLE_ACK --------------------------------- */
 /* Decode a response which is eother "OK" or "Enn"
-   fillin error code,  fillin pkfag-1== undef, 0==nak, 1 == ack ;
+   fillin error code,  fillin pkfag-1== undef, 0==nak, 1 == ack;
    return advanced packet pointer */
 
 
    return advanced packet pointer */
 
 
-char * remote_upk_simple_ack(
-                             char * buf,
-                             int * pkflag,
-                             int * errcode)
+char *remote_upk_simple_ack(
+       char *buf,
+       int *pkflag,
+       int *errcode)
 {
 {
-  int lclerr = 0 ;
-  char ch = *buf++ ;
-  int retval = -1 ;  /* Undefined ACK , a protocol error */
-  if (ch == 'E')     /* NAK */
-    {
-      buf = unpack_byte(buf,&lclerr) ;
-      retval = 0 ;   /* transaction failed, explicitly */
-    }
-  else
-    if ((ch == 'O') && (*buf++ == 'K')) /* ACK */
-      retval = 1 ; /* transaction succeeded */
-  *pkflag = retval ;
-  *errcode = lclerr ;
-  return buf ;
+       int lclerr = 0;
+       char ch = *buf++;
+       int retval = -1;  /* Undefined ACK, a protocol error */
+       if (ch == 'E')     /* NAK */
+       {
+               buf = unpack_byte(buf, &lclerr);
+               retval = 0;   /* transaction failed, explicitly */
+       }
+       else
+               if ((ch == 'O') && (*buf++ == 'K')) /* ACK */
+                       retval = 1; /* transaction succeeded */
+       *pkflag = retval;
+       *errcode = lclerr;
+       return buf;
 } /* remote-upk_simple_ack */
 
 
 /* -------- PACK_THREADALIVE_REQUEST ------------------------------- */
 
 } /* remote-upk_simple_ack */
 
 
 /* -------- PACK_THREADALIVE_REQUEST ------------------------------- */
 
-char * pack_threadalive_request(
-                         char * buf,
-                         threadref * threadid)
+char *pack_threadalive_request(
+       char *buf,
+       threadref *threadid)
 {
 {
-  *buf++ = 'T' ;
-  buf = pack_threadid(buf,threadid) ;
-  *buf = '\0' ;
-  return buf ;
+       *buf++ = 'T';
+       buf = pack_threadid(buf, threadid);
+       *buf = '\0';
+       return buf;
 } /* pack_threadalive_request */
 } /* pack_threadalive_request */
-     
+
 #endif /* GDB_MOCKUP */
 #endif /* GDB_MOCKUP */
-\f
+
 /* ---------------------------------------------------------------------- */
 /* UNIT_TESTS SUBSECTION                                                  */
 /* ---------------------------------------------------------------------- */
 
 
 #if UNIT_TEST
 /* ---------------------------------------------------------------------- */
 /* UNIT_TESTS SUBSECTION                                                  */
 /* ---------------------------------------------------------------------- */
 
 
 #if UNIT_TEST
-extern void output_string(char * message) ;
-static char test_req[400] ;
-static char t_response[400] ;
+extern void output_string(char *message);
+static char test_req[400];
+static char t_response[400];
 
 
 
 /* ----- DISPLAY_THREAD_INFO ---------------------------------------------- */
 /*  Use local cygmon string output utiities */
 
 
 
 
 /* ----- DISPLAY_THREAD_INFO ---------------------------------------------- */
 /*  Use local cygmon string output utiities */
 
-void display_thread_info(struct gdb_ext_thread_info * info)
+void display_thread_info(struct gdb_ext_thread_info *info)
 {
 
 {
 
-  output_threadid("Threadid: ",&info->threadid) ;
-  /* short name */
-  output_string("Name: ") ; output_string(info->shortname) ; output_string("\n");
-  /* format display state */
-  output_string("State: ") ; output_string(info->display) ; output_string("\n") ;
-  /* additional data */
-  output_string("other: ");output_string(info->more_display);
-   output_string("\n\n");
+       output_threadid("Threadid: ", &info->threadid);
+       /* short name */
+       output_string("Name: "); output_string(info->shortname); output_string("\n");
+       /* format display state */
+       output_string("State: "); output_string(info->display); output_string("\n");
+       /* additional data */
+       output_string("other: ");output_string(info->more_display);
+       output_string("\n\n");
 } /* display_thread_info */
 
 
 /* --- CURRTHREAD-TEST -------------------------------------------- */
 } /* display_thread_info */
 
 
 /* --- CURRTHREAD-TEST -------------------------------------------- */
-static int currthread_test(threadref * thread)
+static int currthread_test(threadref *thread)
 {
 {
-  int result ;
-  int threadid ;
-  output_string("TEST: currthread\n") ;
-  remote_pack_currthread_request(test_req) ;
-  stub_pkt_currthread(test_req+2,t_response,STUB_BUF_MAX) ;
-  result = remote_upk_currthread_response(t_response+2, &threadid) ;
-  if (result)
-    {
-      output_string("PASS getcurthread\n") ;
-      /* FIXME: print the thread */
-    }
-  else
-    output_string("FAIL getcurrthread\n") ;
-  return result ;
+       int result;
+       int threadid;
+       output_string("TEST: currthread\n");
+       remote_pack_currthread_request(test_req);
+       stub_pkt_currthread(test_req+2, t_response, STUB_BUF_MAX);
+       result = remote_upk_currthread_response(t_response+2, &threadid);
+       if (result)
+       {
+               output_string("PASS getcurthread\n");
+               /* FIXME: print the thread */
+       }
+       else
+               output_string("FAIL getcurrthread\n");
+       return result;
 } /* currthread_test */
 
 /* ------ SETTHREAD_TEST ------------------------------------------- */
 } /* currthread_test */
 
 /* ------ SETTHREAD_TEST ------------------------------------------- */
-  /* use a known thread from previous test */
+/* use a known thread from previous test */
 
 
-static int setthread_test(threadref * thread)
+static int setthread_test(threadref *thread)
 {
 {
-  int result, errcode ;
-  output_string("TEST: setthread\n") ;
-  
-  pack_setthread_request(test_req,'p',1,thread) ;
-  stub_pkt_changethread(test_req,t_response,STUB_BUF_MAX) ;
-  remote_upk_simple_ack(t_response,&result,&errcode) ;
-  switch (result)
-    {
-    case 0 :
-      output_string("FAIL setthread\n") ;
-      break ;
-    case 1 :
-      output_string("PASS setthread\n") ;
-      break ;
-    default :
-      output_string("FAIL setthread -unrecognized response\n") ;
-      break ;
-    }
-  return result ;
+       int result, errcode;
+       output_string("TEST: setthread\n");
+
+       pack_setthread_request(test_req, 'p', 1, thread);
+       stub_pkt_changethread(test_req, t_response, STUB_BUF_MAX);
+       remote_upk_simple_ack(t_response, &result, &errcode);
+       switch (result)
+       {
+       case 0 :
+               output_string("FAIL setthread\n");
+               break;
+       case 1 :
+               output_string("PASS setthread\n");
+               break;
+       default :
+               output_string("FAIL setthread -unrecognized response\n");
+               break;
+       }
+       return result;
 } /* setthread_test */
 
 
 /* ------ THREADACTIVE_TEST ---------------------- */
 } /* setthread_test */
 
 
 /* ------ THREADACTIVE_TEST ---------------------- */
-  /* use known thread */
-  /* pack threadactive packet */
-  /* process threadactive packet */
-  /* parse threadactive response */
-  /* check results */
+/* use known thread */
+/* pack threadactive packet */
+/* process threadactive packet */
+/* parse threadactive response */
+/* check results */
 
 
 
 
-int threadactive_test(threadref * thread)
+int threadactive_test(threadref *thread)
 {
 {
-  int result ;
-  int errcode ;
-  output_string("TEST: threadactive\n") ;
-  pack_threadalive_request(test_req,thread) ;
-  stub_pkt_thread_alive(test_req+1,t_response,STUB_BUF_MAX);
-  remote_upk_simple_ack(t_response,&result,&errcode) ;
-  switch (result)
-    {
-    case 0 :
-      output_string("FAIL threadalive\n") ;
-      break ;
-    case 1 :
-      output_string("PASS threadalive\n") ;
-      break ;
-    default :
-      output_string("FAIL threadalive -unrecognized response\n") ;
-      break ;
-    }
-  return result ;
+       int result;
+       int errcode;
+       output_string("TEST: threadactive\n");
+       pack_threadalive_request(test_req, thread);
+       stub_pkt_thread_alive(test_req+1, t_response, STUB_BUF_MAX);
+       remote_upk_simple_ack(t_response, &result, &errcode);
+       switch (result)
+       {
+       case 0 :
+               output_string("FAIL threadalive\n");
+               break;
+       case 1 :
+               output_string("PASS threadalive\n");
+               break;
+       default :
+               output_string("FAIL threadalive -unrecognized response\n");
+               break;
+       }
+       return result;
 } /* threadactive_test */
 
 /* ------ REMOTE_GET_THREADINFO -------------------------------------- */
 int remote_get_threadinfo(
 } /* threadactive_test */
 
 /* ------ REMOTE_GET_THREADINFO -------------------------------------- */
 int remote_get_threadinfo(
-                           threadref * threadid,
-                           int fieldset , /* TAG mask */
-                           struct gdb_ext_thread_info * info
-                          )
+       threadref *threadid,
+       int fieldset, /* TAG mask */
+       struct gdb_ext_thread_info *info
+       )
 {
 {
-  int result ;
-  pack_threadinfo_request(test_req,fieldset,threadid) ;
-  stub_pkt_getthreadinfo(test_req+2,t_response,STUB_BUF_MAX) ;
-  result = remote_upk_thread_info_response(t_response+2,threadid,info) ;
-  return result ;
+       int result;
+       pack_threadinfo_request(test_req, fieldset, threadid);
+       stub_pkt_getthreadinfo(test_req+2, t_response, STUB_BUF_MAX);
+       result = remote_upk_thread_info_response(t_response+2, threadid, info);
+       return result;
 } /* remote_get-thrreadinfo */
 
 
 } /* remote_get-thrreadinfo */
 
 
-static struct gdb_ext_thread_info test_info ;
+static struct gdb_ext_thread_info test_info;
 
 
-static int get_and_display_threadinfo(threadref * thread)
+static int get_and_display_threadinfo(threadref *thread)
 {
 {
-  int mode ;
-  int result ;
-  /* output_string("TEST: get and display threadinfo\n") ; */
-
-  mode = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
-    | TAG_MOREDISPLAY | TAG_DISPLAY ;
-  result = remote_get_threadinfo(thread,mode,&test_info) ;
-  if (result) display_thread_info(&test_info) ;
+       int mode;
+       int result;
+       /* output_string("TEST: get and display threadinfo\n"); */
+
+       mode = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
+               | TAG_MOREDISPLAY | TAG_DISPLAY;
+       result = remote_get_threadinfo(thread, mode, &test_info);
+       if (result) display_thread_info(&test_info);
 #if 0  /* silent subtest */
 #if 0  /* silent subtest */
-  if (result)
-      output_string("PASS: get_and_display threadinfo\n") ;
-  else
-      output_string("FAIL: get_and_display threadinfo\n") ;
-#endif  
-  return result ;
+       if (result)
+               output_string("PASS: get_and_display threadinfo\n");
+       else
+               output_string("FAIL: get_and_display threadinfo\n");
+#endif
+       return result;
 } /* get-and-display-threadinfo */
 
 
 } /* get-and-display-threadinfo */
 
 
@@ -1320,92 +1322,86 @@ static int get_and_display_threadinfo(threadref * thread)
 /* ----- THREADLIST_TEST ------------------------------------------ */
 #define TESTLISTSIZE 16
 #define TLRSIZ 2
 /* ----- THREADLIST_TEST ------------------------------------------ */
 #define TESTLISTSIZE 16
 #define TLRSIZ 2
-static threadref test_threadlist[TESTLISTSIZE] ;
+static threadref test_threadlist[TESTLISTSIZE];
 
 static int threadlist_test(void)
 {
 
 static int threadlist_test(void)
 {
-  int done, i , result_count ;
-  int startflag = 1 ;
-  int result = 1 ;
-  int loopcount = 0 ;
-  static threadref nextthread ;
-  static threadref echo_nextthread ;
-
-  output_string("TEST: threadlist\n") ;
-
-  done = 0 ;
-  while (! done)
-    {
-      if (loopcount++ > 10)
-        {
-          result = 0 ;
-          output_string("FAIL: Threadlist test -infinite loop-\n") ;
-          break ;
-        }
-      pack_threadlist_request(test_req,startflag,TLRSIZ,&nextthread) ;
-      startflag = 0 ; /* clear for later iterations */
-      stub_pkt_getthreadlist(test_req+2,t_response,STUB_BUF_MAX);
-      result_count = parse_threadlist_response(t_response+2,
-                                               &echo_nextthread,
-                                               &test_threadlist[0],&done) ;
-      if (! threadmatch(&echo_nextthread,&nextthread))
-        {
-          output_string("FAIL: threadlist did not echo arg thread\n");
-          result = 0 ;
-          break ;
-        }
-      if (result_count <= 0)
-        {
-          if (done != 0)
-              { output_string("FAIL threadlist_test, failed to get list");
-                result = 0 ;
-              }
-          break ;
-        }
-      if (result_count > TLRSIZ)
-        {
-          output_string("FAIL: threadlist response longer than requested\n") ;
-          result = 0 ;
-          break ;
-        }
-      /* Setup to resume next batch of thread references , set nestthread */
-      copy_threadref(&nextthread,&test_threadlist[result_count-1]) ;
-      /* output_threadid("last-of-batch",&nextthread) ; */
-      i = 0 ;
-      while (result_count--)
-          {
-            if (0)  /* two display alternatives */
-              output_threadid("truncatedisplay",&test_threadlist[i++]) ;
-            else
-              get_and_display_threadinfo(&test_threadlist[i++]) ; 
-          }
-
-    }
-  if (!result)
-    output_string("FAIL: threadlist test\n") ;
-  else output_string("PASS: Threadlist test\n") ;
-  return result ;
+       int done, i, result_count;
+       int startflag = 1;
+       int result = 1;
+       int loopcount = 0;
+       static threadref nextthread;
+       static threadref echo_nextthread;
+
+       output_string("TEST: threadlist\n");
+
+       done = 0;
+       while (! done) {
+               if (loopcount++ > 10) {
+                       result = 0;
+                       output_string("FAIL: Threadlist test -infinite loop-\n");
+                       break;
+               }
+               pack_threadlist_request(test_req, startflag, TLRSIZ, &nextthread);
+               startflag = 0; /* clear for later iterations */
+               stub_pkt_getthreadlist(test_req+2, t_response, STUB_BUF_MAX);
+               result_count = parse_threadlist_response(t_response+2,
+                                                                                               &echo_nextthread,
+                                                                                               &test_threadlist[0], &done);
+               if (! threadmatch(&echo_nextthread, &nextthread)) {
+                       output_string("FAIL: threadlist did not echo arg thread\n");
+                       result = 0;
+                       break;
+               }
+               if (result_count <= 0) {
+                       if (done != 0)
+                       { output_string("FAIL threadlist_test, failed to get list");
+                               result = 0;
+                       }
+                       break;
+               }
+               if (result_count > TLRSIZ) {
+                       output_string("FAIL: threadlist response longer than requested\n");
+                       result = 0;
+                       break;
+               }
+               /* Setup to resume next batch of thread references, set nestthread */
+               copy_threadref(&nextthread, &test_threadlist[result_count-1]);
+               /* output_threadid("last-of-batch", &nextthread); */
+               i = 0;
+               while (result_count--) {
+                       if (0)  /* two display alternatives */
+                               output_threadid("truncatedisplay", &test_threadlist[i++]);
+                       else
+                               get_and_display_threadinfo(&test_threadlist[i++]);
+               }
+
+       }
+       if (!result)
+               output_string("FAIL: threadlist test\n");
+       else output_string("PASS: Threadlist test\n");
+       return result;
 } /* threadlist_test */
 
 
 } /* threadlist_test */
 
 
-static threadref testthread ;
+static threadref testthread;
 
 
 int test_thread_support(void)
 {
 
 
 int test_thread_support(void)
 {
-  int result = 1 ;
-  output_string("TESTING Thread support infrastructure\n") ;
-  stub_pack_Tpkt_threadid(test_req) ;
-  PKT_TRACE("packing the threadid  -> ",test_req) ;
-  result &= currthread_test(&testthread) ;
-  result &= get_and_display_threadinfo(&testthread) ;
-  result &= threadlist_test() ;
-  result &= setthread_test(&testthread) ;
-  if (result)
-    output_string("PASS: UNITTEST Thread support\n") ;
-  else
-        output_string("FAIL: UNITTEST Thread support\n") ;
-  return result ;
+       int result = 1;
+       output_string("TESTING Thread support infrastructure\n");
+       stub_pack_Tpkt_threadid(test_req);
+       PKT_TRACE("packing the threadid  -> ", test_req);
+       result &= currthread_test(&testthread);
+       result &= get_and_display_threadinfo(&testthread);
+       result &= threadlist_test();
+       result &= setthread_test(&testthread);
+       if (result)
+               output_string("PASS: UNITTEST Thread support\n");
+       else
+               output_string("FAIL: UNITTEST Thread support\n");
+       return result;
 } /* test-thread_support */
 #endif /* UNIT_TEST */
 
 } /* test-thread_support */
 #endif /* UNIT_TEST */