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 a2fc9bf..b443ed7 100644 (file)
 
 #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 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_MACRO_END
+       CYG_MACRO_END
 
 #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_MACRO_END
+       CYG_MACRO_END
 
 #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);                                         \
        }                                                                                       \
-    CYG_MACRO_END
+       CYG_MACRO_END
 
 #define BLINK_LED(l, n)                                                        \
-    CYG_MACRO_START                                                            \
+       CYG_MACRO_START                                                         \
        int _i;                                                                         \
        for (_i = 0; _i < (n); _i++) {                          \
                BOARD_DEBUG_LED(l);                                             \
                HAL_DELAY_US(300000);                                   \
        }                                                                                       \
        HAL_DELAY_US(1000000);                                          \
-    CYG_MACRO_END
+       CYG_MACRO_END
 
 #if !defined(__ASSEMBLER__)
 enum {
index 664f5b6..24a15a9 100644 (file)
 #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
index e81d833..b703569 100644 (file)
 //===========================================================================
 
 #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.
-#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:
 
-#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
  */
+#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)
 {
-        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)
 {
-        /* 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
index 8eff72c..457f331 100644 (file)
@@ -62,16 +62,16 @@ static void runImg(int argc, char *argv[]);
 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",
-           "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[])
 {
@@ -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",
-                                   address, value, (int)*(cyg_uint8*)address );
+                                               address, value, (int)*(cyg_uint8*)address );
                }
        } 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",
-                                           address, value, (int)*(cyg_uint16*)address);
+                                                       address, value, (int)*(cyg_uint16*)address);
                        }
                }
        } 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",
-                                           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)
 {
-    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[])
@@ -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,
-                      OPTION_ARG_TYPE_NUM, "virtual address"))
+                                       OPTION_ARG_TYPE_NUM, "virtual address"))
                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",
-           "Update Redboot with currently running image",
-           "",
-           romupdate
-          );
+                       "Update Redboot with currently running image",
+                       "",
+                       romupdate
+       );
 
 #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",
-                           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",
-                           err_addr, flash_errmsg(stat));
+                                       err_addr, flash_errmsg(stat));
        }
 }
 #endif //CYGPKG_IO_FLASH
index 0137881..21ca766 100644 (file)
@@ -107,10 +107,10 @@ static void dump_reg(unsigned long addr)
 #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
+#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
 
@@ -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 */
-       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 */
@@ -172,7 +172,7 @@ static void fec_gpio_init(void)
 {
        /* 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
@@ -233,7 +233,7 @@ static void fec_gpio_init(void)
        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.
@@ -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",
-                                   i, fuse, mac_addr[i]);
+                                               i, 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",
-                                           i, bit);
+                                                       i, bit);
                                ret = -1;
                                goto out;
                        }
index 4291324..f24b037 100644 (file)
 /*
  * Translation Table Base Bit Masks
  */
-#define ARM_TRANSLATION_TABLE_MASK               0xFFFFC000
+#define ARM_TRANSLATION_TABLE_MASK                              0xFFFFC000
 
 /*
  * 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 {
-        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 {
-        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 {
-        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 {
-        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_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,                   \
-                        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 {
-        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
  */
-#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
-
-
-
-
-
index 672f611..1a6944f 100644 (file)
@@ -57,7 +57,7 @@
 #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))
index a125ccd..f2cf9b6 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,
-         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,
@@ -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,
-                                                                                                cyg_uint8 *ch)
+                                                                                               cyg_uint8 *ch)
 {
        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,
-                                                                        cyg_uint32 __len)
+                                                                       cyg_uint32 __len)
 {
        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_uint8 *ch)
+                                                                               cyg_uint8 *ch)
 {
        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,
-                                                                         __comm_control_cmd_t __func, ...)
+                                                                       __comm_control_cmd_t __func, ...)
 {
        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,
-                                                                 CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
+                                                               CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
 {
        int res = 0;
        channel_data_t *chan = __ch_data;
index 85ea66f..13283fb 100644 (file)
 #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_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.
 
 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
@@ -99,91 +99,91 @@ static int find_correct_chip;
  */
 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
-     * 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
-        return CHIP_VERSION_NONE;
+               return CHIP_VERSION_NONE;
 #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,
-                                      unsigned int is_mlc, unsigned int num_of_chips);
+                                                       unsigned int is_mlc, unsigned int num_of_chips);
 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);
 }
 
-#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[] = {
-    I2C_BASE_ADDR,
-    I2C2_BASE_ADDR,
-    I2C3_BASE_ADDR
+       I2C_BASE_ADDR,
+       I2C2_BASE_ADDR,
+       I2C3_BASE_ADDR
 };
 unsigned int i2c_num = 3;
 
@@ -246,30 +246,30 @@ static unsigned int led_on = 0;
 //
 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;
 
-    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
-    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
 
-    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
-    // 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
 }
 
@@ -311,10 +311,10 @@ void hal_interrupt_unmask(int vector)
 //    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
 }
 
@@ -323,10 +323,10 @@ void hal_interrupt_acknowledge(int vector)
 
 //    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
 }
 
@@ -334,10 +334,10 @@ void hal_interrupt_configure(int vector, int level, int up)
 {
 
 #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
 }
 
@@ -345,44 +345,44 @@ void hal_interrupt_set_level(int vector, int 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
 
-    // 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 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);
-    }
+       }
 
-    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 &= ~(3<<8);
+       tmp &= ~(3<<8);
        switch (pg_sz) {
-    case 2048:
+       case 2048:
                tmp |= (1<<8);
                break;
-    case 4096:
+       case 4096:
                tmp |= (1<<9);
                break;
-    }
+       }
 
-    writel(tmp, CCM_BASE_ADDR + CLKCTL_RCSR);
+       writel(tmp, CCM_BASE_ADDR + CLKCTL_RCSR);
        return MXC_NFC_V1_1;
 }
 
@@ -440,12 +440,12 @@ RedBoot_init(check_reset_source, RedBoot_INIT_LAST);
 
 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);
index 2ce2b44..b554fc0 100644 (file)
 //              combination of libbsp and vectors already in use by some
 //              eCos platforms.
 // Usage:       #include <cyg/hal/hal_if.h>
-//                           
+//
 //####DESCRIPTIONEND####
 //
 //=============================================================================
 
-#include <cyg/infra/cyg_type.h>         // types & externC
+#include <cyg/infra/cyg_type.h>                        // types & externC
 #include <cyg/hal/dbg-threads-api.h>
 #include <cyg/hal/dbg-thread-syscall.h>
 
 // and eCos share facilities, e.g. the network hardware.
 #if defined (CYGPKG_NET) || defined (CYGPKG_NET_LWIP)
 #include <cyg/hal/hal_intr.h>
-#include <cyg/hal/drv_api.h>            // cyg_drv_dsr_lock(), etc
-#define _ENTER_MONITOR()                        \
-    cyg_uint32 ints;                            \
-    HAL_DISABLE_INTERRUPTS(ints);               \
-    cyg_drv_dsr_lock()
-
-#define _EXIT_MONITOR()                         \
-    cyg_drv_dsr_unlock();                       \
-    HAL_RESTORE_INTERRUPTS(ints)
+#include <cyg/hal/drv_api.h>                   // cyg_drv_dsr_lock(), etc
+#define _ENTER_MONITOR()                                               \
+       cyg_uint32 ints;                                                        \
+       HAL_DISABLE_INTERRUPTS(ints);                           \
+       cyg_drv_dsr_lock()
+
+#define _EXIT_MONITOR()                                                        \
+       cyg_drv_dsr_unlock();                                           \
+       HAL_RESTORE_INTERRUPTS(ints)
 #else // !CYGPKG_NET && !CYGPKG_NET_LWIP
 #define _ENTER_MONITOR() CYG_EMPTY_STATEMENT
 #define _EXIT_MONITOR()  CYG_EMPTY_STATEMENT
@@ -98,81 +98,81 @@ typedef int (*bsp_handler_t)(int __irq_nr, void *__regs);
 // of this table.
 
 typedef enum {
-    /*
-     * For serial ports, the control function may be used to set and get the
-     * current baud rate. Usage:
-     * 
-     *   err = (*__control)(COMMCTL_SETBAUD, int bits_per_second);
-     *     err => Zero if successful, -1 if error.
-     *
-     *   baud = (*__control)(COMMCTL_GETBAUD);
-     *     baud => -1 if error, current baud otherwise.
-     */
-    __COMMCTL_SETBAUD=0,
-    __COMMCTL_GETBAUD,
-
-    /*
-     * Install and remove debugger interrupt handlers. These are the receiver
-     * interrupt routines which are used to change control from a running
-     * program to the debugger stub.
-     */
-    __COMMCTL_INSTALL_DBG_ISR,
-    __COMMCTL_REMOVE_DBG_ISR,
-
-    /*
-     * Disable comm port interrupt. Returns TRUE if interrupt was enabled,
-     * FALSE otherwise.
-     */
-    __COMMCTL_IRQ_DISABLE,
-
-    /*
-     * Enable comm port interrupt.
-     */
-    __COMMCTL_IRQ_ENABLE,
-
-    /*
-     * Returns the number of the interrupt vector used by the debug
-     * interrupt handler.
-     */
-    __COMMCTL_DBG_ISR_VECTOR,
-
-    /*
-     * Returns the current timeout value and sets a new timeout.
-     * Timeout resolution is in milliseconds.
-     *   old_timeout = (*__control)(__COMMCTL_SET_TIMEOUT, 
-     *                              cyg_int32 new_timeout);
-     */
-    __COMMCTL_SET_TIMEOUT,
-
-    /*
-     * Forces driver to send all characters which may be buffered in
-     * the driver. This only flushes the driver buffers, not necessarily
-     * any hardware FIFO, etc.
-     */
-    __COMMCTL_FLUSH_OUTPUT,
-
-    /*
-     * Forces driver to enable or disable flushes when a newline is
-     * seen in the output stream. Flushing at line boundaries occurs
-     * in the driver, not necessarily any hardware FIFO, etc. Line
-     * buffering is optional and may only be available in some drivers.
-     */
-    __COMMCTL_ENABLE_LINE_FLUSH,
-    __COMMCTL_DISABLE_LINE_FLUSH,
+       /*
+        * For serial ports, the control function may be used to set and get the
+        * current baud rate. Usage:
+        *
+        *   err = (*__control)(COMMCTL_SETBAUD, int bits_per_second);
+        *     err => Zero if successful, -1 if error.
+        *
+        *   baud = (*__control)(COMMCTL_GETBAUD);
+        *     baud => -1 if error, current baud otherwise.
+        */
+       __COMMCTL_SETBAUD=0,
+       __COMMCTL_GETBAUD,
+
+       /*
+        * Install and remove debugger interrupt handlers. These are the receiver
+        * interrupt routines which are used to change control from a running
+        * program to the debugger stub.
+        */
+       __COMMCTL_INSTALL_DBG_ISR,
+       __COMMCTL_REMOVE_DBG_ISR,
+
+       /*
+        * Disable comm port interrupt. Returns TRUE if interrupt was enabled,
+        * FALSE otherwise.
+        */
+       __COMMCTL_IRQ_DISABLE,
+
+       /*
+        * Enable comm port interrupt.
+        */
+       __COMMCTL_IRQ_ENABLE,
+
+       /*
+        * Returns the number of the interrupt vector used by the debug
+        * interrupt handler.
+        */
+       __COMMCTL_DBG_ISR_VECTOR,
+
+       /*
+        * Returns the current timeout value and sets a new timeout.
+        * Timeout resolution is in milliseconds.
+        *   old_timeout = (*__control)(__COMMCTL_SET_TIMEOUT,
+        *                              cyg_int32 new_timeout);
+        */
+       __COMMCTL_SET_TIMEOUT,
+
+       /*
+        * Forces driver to send all characters which may be buffered in
+        * the driver. This only flushes the driver buffers, not necessarily
+        * any hardware FIFO, etc.
+        */
+       __COMMCTL_FLUSH_OUTPUT,
+
+       /*
+        * Forces driver to enable or disable flushes when a newline is
+        * seen in the output stream. Flushing at line boundaries occurs
+        * in the driver, not necessarily any hardware FIFO, etc. Line
+        * buffering is optional and may only be available in some drivers.
+        */
+       __COMMCTL_ENABLE_LINE_FLUSH,
+       __COMMCTL_DISABLE_LINE_FLUSH,
 
 } __comm_control_cmd_t;
 
 
-#define CYGNUM_COMM_IF_CH_DATA                    0
-#define CYGNUM_COMM_IF_WRITE                      1
-#define CYGNUM_COMM_IF_READ                       2
-#define CYGNUM_COMM_IF_PUTC                       3
-#define CYGNUM_COMM_IF_GETC                       4
-#define CYGNUM_COMM_IF_CONTROL                    5
-#define CYGNUM_COMM_IF_DBG_ISR                    6
-#define CYGNUM_COMM_IF_GETC_TIMEOUT               7
+#define CYGNUM_COMM_IF_CH_DATA                                   0
+#define CYGNUM_COMM_IF_WRITE                                     1
+#define CYGNUM_COMM_IF_READ                                              2
+#define CYGNUM_COMM_IF_PUTC                                              3
+#define CYGNUM_COMM_IF_GETC                                              4
+#define CYGNUM_COMM_IF_CONTROL                                   5
+#define CYGNUM_COMM_IF_DBG_ISR                                   6
+#define CYGNUM_COMM_IF_GETC_TIMEOUT                              7
 
-#define CYGNUM_COMM_IF_TABLE_SIZE                 8
+#define CYGNUM_COMM_IF_TABLE_SIZE                                8
 
 typedef volatile CYG_ADDRWORD hal_virtual_comm_table_t[CYGNUM_COMM_IF_TABLE_SIZE];
 
@@ -183,104 +183,104 @@ typedef volatile CYG_ADDRWORD hal_virtual_comm_table_t[CYGNUM_COMM_IF_TABLE_SIZE
 
 typedef void* __comm_if_ch_data_t;
 typedef void (*__comm_if_write_t)(void* __ch_data, const cyg_uint8* __buf,
-                                  cyg_uint32 __len);
+                                                               cyg_uint32 __len);
 typedef int (*__comm_if_read_t)(void* __ch_data, cyg_uint8* __buf,
-                                cyg_uint32 __len);
+                                                               cyg_uint32 __len);
 typedef void (*__comm_if_putc_t)(void* __ch_data, cyg_uint8 __ch);
 typedef cyg_uint8 (*__comm_if_getc_t)(void* __ch_data);
-typedef int (*__comm_if_control_t)(void *__ch_data, 
-                                   __comm_control_cmd_t __func, ...);
-typedef int (*__comm_if_dbg_isr_t)(void *__ch_data, 
-                               int* __ctrlc, CYG_ADDRWORD __vec,
-                               CYG_ADDRWORD __data);
+typedef int (*__comm_if_control_t)(void *__ch_data,
+                                                               __comm_control_cmd_t __func, ...);
+typedef int (*__comm_if_dbg_isr_t)(void *__ch_data,
+                                                               int* __ctrlc, CYG_ADDRWORD __vec,
+                                                               CYG_ADDRWORD __data);
 typedef cyg_bool (*__comm_if_getc_timeout_t)(void *__ch_data, void *__ch);
 
-#define __call_COMM0(_n_,_rt_,_t_)                              \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t)                   \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                    \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM0(_n_,_rt_,_t_)                                                             \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t)                                  \
+{                                                                                                                              \
+       _rt_ res;                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                                        \
+       _EXIT_MONITOR();                                                                                        \
+       return res;                                                                                                     \
 }
 
-#define __call_voidCOMM(_n_,_rt_,_t_)                           \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t)                   \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                          \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM(_n_,_rt_,_t_)                                                  \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t)                                  \
+{                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp);                                                      \
+       _EXIT_MONITOR();                                                                                        \
 }
 
-#define __call_COMM1(_n_,_rt_,_t_,_t1_)                         \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)        \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);              \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM1(_n_,_rt_,_t_,_t1_)                                                        \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)               \
+{                                                                                                                              \
+       _rt_ res;                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);                          \
+       _EXIT_MONITOR();                                                                                        \
+       return res;                                                                                                     \
 }
 
-#define __call_voidCOMM1(_n_,_rt_,_t_,_t1_)                     \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)        \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);                    \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM1(_n_,_rt_,_t_,_t1_)                                            \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_)               \
+{                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_);                                        \
+       _EXIT_MONITOR();                                                                                        \
 }
 
-#define __call_COMM2(_n_,_rt_,_t_,_t1_,_t2_)                    \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)        \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);        \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM2(_n_,_rt_,_t_,_t1_,_t2_)                                   \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)               \
+{                                                                                                                              \
+       _rt_ res;                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);            \
+       _EXIT_MONITOR();                                                                                        \
+       return res;                                                                                                     \
 }
 
-#define __call_voidCOMM2(_n_,_rt_,_t_,_t1_,_t2_)                \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)        \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);              \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM2(_n_,_rt_,_t_,_t1_,_t2_)                               \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_)               \
+{                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];      \
+       _ENTER_MONITOR();                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_);                          \
+       _EXIT_MONITOR();                                                                                        \
 }
 
-#define __call_COMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)               \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_)        \
-{                                                               \
-    _rt_ res;                                                   \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);              \
-    _EXIT_MONITOR();                                            \
-    return res;                                                 \
+#define __call_COMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)                              \
+static __inline__ _rt_                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_) \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];                      \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);                      \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidCOMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)           \
-static __inline__ _rt_                                          \
-__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_)        \
-{                                                               \
-    void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];  \
-    _ENTER_MONITOR();                                           \
-    ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);        \
-    _EXIT_MONITOR();                                            \
+#define __call_voidCOMM3(_n_,_rt_,_t_,_t1_,_t2_,_t3_)                  \
+static __inline__ _rt_                                                                                                 \
+__call_COMM_##_n_(hal_virtual_comm_table_t t, _t1_ _p1_, _t2_ _p2_, _t3_ _p3_) \
+{                                                                                                                                              \
+       void *dp = (__comm_if_ch_data_t)t[CYGNUM_COMM_IF_CH_DATA];                      \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_t_)(t[CYGNUM_COMM_##_n_]))(dp, _p1_, _p2_, _p3_);                            \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
 #ifndef CYGACC_COMM_IF_DEFINED
@@ -317,76 +317,76 @@ __call_COMM0(IF_GETC, cyg_uint8, __comm_if_getc_t)
 // This macro has not been changed to use inline functions like the
 // others, simply because it uses variable arguments, and the change
 // would break binary compatibility.
-#define CYGACC_COMM_IF_CONTROL(_t_, args...)                                                            \
- ({ int res;                                                                                            \
-    _ENTER_MONITOR();                                                                                   \
-    res = ((__comm_if_control_t)((_t_)[CYGNUM_COMM_IF_CONTROL]))(CYGACC_COMM_IF_CH_DATA(_t_), args);    \
-    _EXIT_MONITOR();                                                                                    \
-    res;})
+#define CYGACC_COMM_IF_CONTROL(_t_, args...)                                                   \
+ ({ int res;                                                                                                                   \
+        _ENTER_MONITOR();                                                                                                      \
+        res = ((__comm_if_control_t)((_t_)[CYGNUM_COMM_IF_CONTROL]))(CYGACC_COMM_IF_CH_DATA(_t_), args); \
+        _EXIT_MONITOR();                                                                                                       \
+        res;})
 #define CYGACC_COMM_IF_CONTROL_SET(_t_, _x_) \
- (_t_)[CYGNUM_COMM_IF_CONTROL]=(CYG_ADDRWORD)(_x_)
      (_t_)[CYGNUM_COMM_IF_CONTROL]=(CYG_ADDRWORD)(_x_)
 
 __call_COMM3(IF_DBG_ISR, int, __comm_if_dbg_isr_t, int *, CYG_ADDRWORD, CYG_ADDRWORD)
 #define CYGACC_COMM_IF_DBG_ISR(_t_, _c_, _v_, _d_) \
- __call_COMM_IF_DBG_ISR(_t_, _c_, _v_, _d_)
      __call_COMM_IF_DBG_ISR(_t_, _c_, _v_, _d_)
 #define CYGACC_COMM_IF_DBG_ISR_SET(_t_, _x_) \
- (_t_)[CYGNUM_COMM_IF_DBG_ISR]=(CYG_ADDRWORD)(_x_)
      (_t_)[CYGNUM_COMM_IF_DBG_ISR]=(CYG_ADDRWORD)(_x_)
 
 __call_COMM1(IF_GETC_TIMEOUT, cyg_bool, __comm_if_getc_timeout_t, void *)
-#define CYGACC_COMM_IF_GETC_TIMEOUT(_t_, _c_) \
- __call_COMM_IF_GETC_TIMEOUT(_t_, _c_)
-#define CYGACC_COMM_IF_GETC_TIMEOUT_SET(_t_, _x_) \
- (_t_)[CYGNUM_COMM_IF_GETC_TIMEOUT]=(CYG_ADDRWORD)(_x_)
+#define CYGACC_COMM_IF_GETC_TIMEOUT(_t_, _c_)  \
      __call_COMM_IF_GETC_TIMEOUT(_t_, _c_)
+#define CYGACC_COMM_IF_GETC_TIMEOUT_SET(_t_, _x_)                      \
      (_t_)[CYGNUM_COMM_IF_GETC_TIMEOUT]=(CYG_ADDRWORD)(_x_)
 
 #endif // CYGACC_COMM_IF_DEFINED
 
 //--------------------------------------------------------------------------
-// Main calling interface table. Will be assigned a location by the 
+// Main calling interface table. Will be assigned a location by the
 // linker script. Both ROM and RAM startup applications will know about
 // the location.
-#define CYGNUM_CALL_IF_VERSION                    0
-#define CYGNUM_CALL_IF_available_1                1
-#define CYGNUM_CALL_IF_available_2                2
-#define CYGNUM_CALL_IF_available_3                3
-#define CYGNUM_CALL_IF_KILL_VECTOR                4
-#define CYGNUM_CALL_IF_CONSOLE_PROCS              5
-#define CYGNUM_CALL_IF_DEBUG_PROCS                6
-#define CYGNUM_CALL_IF_FLUSH_DCACHE               7
-#define CYGNUM_CALL_IF_FLUSH_ICACHE               8
-#define CYGNUM_CALL_IF_available_9                9
-#define CYGNUM_CALL_IF_available_10               10
-#define CYGNUM_CALL_IF_available_11               11
-#define CYGNUM_CALL_IF_SET_DEBUG_COMM             12
-#define CYGNUM_CALL_IF_SET_CONSOLE_COMM           13
-#define CYGNUM_CALL_IF_MONITOR_VERSION            14
-#define CYGNUM_CALL_IF_DBG_SYSCALL                15
-#define CYGNUM_CALL_IF_RESET                      16
-#define CYGNUM_CALL_IF_CONSOLE_INTERRUPT_FLAG     17
-#define CYGNUM_CALL_IF_DELAY_US                   18
-#define CYGNUM_CALL_IF_DBG_DATA                   19
-#define CYGNUM_CALL_IF_FLASH_CFG_OP               20
-#define CYGNUM_CALL_IF_MONITOR_RETURN             21
-#define CYGNUM_CALL_IF_FLASH_FIS_OP               22
-#define CYGNUM_CALL_IF_FLASH_FIS_OP2              23
-
-#define CYGNUM_CALL_IF_LAST_ENTRY                 CYGNUM_CALL_IF_FLASH_FIS_OP2
-
-#define CYGNUM_CALL_IF_INSTALL_BPT_FN             35
-
-#define CYGNUM_CALL_IF_TABLE_SIZE                 64
+#define CYGNUM_CALL_IF_VERSION                                   0
+#define CYGNUM_CALL_IF_available_1                               1
+#define CYGNUM_CALL_IF_available_2                               2
+#define CYGNUM_CALL_IF_available_3                               3
+#define CYGNUM_CALL_IF_KILL_VECTOR                               4
+#define CYGNUM_CALL_IF_CONSOLE_PROCS                     5
+#define CYGNUM_CALL_IF_DEBUG_PROCS                               6
+#define CYGNUM_CALL_IF_FLUSH_DCACHE                              7
+#define CYGNUM_CALL_IF_FLUSH_ICACHE                              8
+#define CYGNUM_CALL_IF_available_9                               9
+#define CYGNUM_CALL_IF_available_10                              10
+#define CYGNUM_CALL_IF_available_11                              11
+#define CYGNUM_CALL_IF_SET_DEBUG_COMM                    12
+#define CYGNUM_CALL_IF_SET_CONSOLE_COMM                          13
+#define CYGNUM_CALL_IF_MONITOR_VERSION                   14
+#define CYGNUM_CALL_IF_DBG_SYSCALL                               15
+#define CYGNUM_CALL_IF_RESET                                     16
+#define CYGNUM_CALL_IF_CONSOLE_INTERRUPT_FLAG    17
+#define CYGNUM_CALL_IF_DELAY_US                                          18
+#define CYGNUM_CALL_IF_DBG_DATA                                          19
+#define CYGNUM_CALL_IF_FLASH_CFG_OP                              20
+#define CYGNUM_CALL_IF_MONITOR_RETURN                    21
+#define CYGNUM_CALL_IF_FLASH_FIS_OP                              22
+#define CYGNUM_CALL_IF_FLASH_FIS_OP2                     23
+
+#define CYGNUM_CALL_IF_LAST_ENTRY                                CYGNUM_CALL_IF_FLASH_FIS_OP2
+
+#define CYGNUM_CALL_IF_INSTALL_BPT_FN                    35
+
+#define CYGNUM_CALL_IF_TABLE_SIZE                                64
 
 externC volatile CYG_ADDRWORD hal_virtual_vector_table[CYGNUM_CALL_IF_TABLE_SIZE];
 
 // Table version contains version information for both the CALL table
 // itself (the number of the last active entry in the table), and the
 // COMM table (the size of the table).
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL         CYGNUM_CALL_IF_LAST_ENTRY
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_HACK    (CYGNUM_CALL_IF_TABLE_SIZE+1)
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MAX     CYGNUM_CALL_IF_TABLE_SIZE
-#define CYGNUM_CALL_IF_TABLE_VERSION_COMM         CYGNUM_COMM_IF_TABLE_SIZE
-#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MASK    0x0000ffff
-#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_MASK    0xffff0000
-#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_shift   16
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL                CYGNUM_CALL_IF_LAST_ENTRY
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_HACK   (CYGNUM_CALL_IF_TABLE_SIZE+1)
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MAX    CYGNUM_CALL_IF_TABLE_SIZE
+#define CYGNUM_CALL_IF_TABLE_VERSION_COMM                CYGNUM_COMM_IF_TABLE_SIZE
+#define CYGNUM_CALL_IF_TABLE_VERSION_CALL_MASK   0x0000ffff
+#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_MASK   0xffff0000
+#define CYGNUM_CALL_IF_TABLE_VERSION_COMM_shift          16
 
 
 // These are special debug/console procs IDs
@@ -398,8 +398,8 @@ externC volatile CYG_ADDRWORD hal_virtual_vector_table[CYGNUM_CALL_IF_TABLE_SIZE
 //               allowing the application to temporarily disable mangling
 //               or temporarily switch in different console procs.
 #define CYGNUM_CALL_IF_SET_COMM_ID_QUERY_CURRENT -1
-#define CYGNUM_CALL_IF_SET_COMM_ID_EMPTY         -2
-#define CYGNUM_CALL_IF_SET_COMM_ID_MANGLER       -3
+#define CYGNUM_CALL_IF_SET_COMM_ID_EMPTY                -2
+#define CYGNUM_CALL_IF_SET_COMM_ID_MANGLER              -3
 
 // The below is a (messy) attempt at adding some type safety to the
 // above array. At the same time, the accessors allow the
@@ -419,7 +419,7 @@ typedef int (__call_if_set_debug_comm_t)(int __comm_id);
 typedef int (__call_if_set_console_comm_t)(int __comm_id);
 typedef void* __call_if_dbg_data_t;
 typedef int (__call_if_dbg_syscall_t) (enum dbg_syscall_ids id,
-                                        union dbg_thread_syscall_parms  *p );
+                                                                       union dbg_thread_syscall_parms  *p);
 typedef void (__call_if_reset_t)(void);
 typedef int __call_if_console_interrupt_flag_t;
 typedef void (__call_if_delay_us_t)(cyg_int32 usecs);
@@ -448,129 +448,129 @@ typedef int (__call_if_flash_fis_op2_fn_t)(int __oper, unsigned int index, struc
 // This allows a single virtual vector interface, with widely varying functionality
 //
 struct cyg_fconfig {
-    char *key;      // Datum 'key'
-    int   keylen;   // Length of key
-    void *val;      // Pointer to data
-    int   type;     // Type of datum
-    int   offset;   // Offset within data (used by _NEXT)
+       char *key;              // Datum 'key'
+       int       keylen;       // Length of key
+       void *val;              // Pointer to data
+       int       type;         // Type of datum
+       int       offset;       // Offset within data (used by _NEXT)
 };
 typedef cyg_bool (__call_if_flash_cfg_op_fn_t)(int __oper, struct cyg_fconfig *__data);
 
 #ifndef CYGACC_CALL_IF_DEFINED
 
-#define __data_VV(_n_,_tt_)                             \
-static __inline__ _tt_                                  \
-__call_vv_##_n_(void)                                   \
-{                                                       \
-    return ((_tt_)hal_virtual_vector_table[_n_]);       \
+#define __data_VV(_n_,_tt_)                                                            \
+static __inline__ _tt_                                                                 \
+__call_vv_##_n_(void)                                                                  \
+{                                                                                                              \
+       return ((_tt_)hal_virtual_vector_table[_n_]);           \
 }
 
-#define __call_VV0(_n_,_tt_,_rt_)                                       \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(void)                                                   \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])();                    \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV0(_n_,_tt_,_rt_)                                                                              \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(void)                                                                                                  \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])();                                        \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV0(_n_,_tt_,_rt_)                                   \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(void)                                                   \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])();                          \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV0(_n_,_tt_,_rt_)                                                                  \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(void)                                                                                                  \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])();                                                      \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV1(_n_,_tt_,_rt_,_t1_)                                  \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_)                                              \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV1(_n_,_tt_,_rt_,_t1_)                                                                 \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_)                                                                                             \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                            \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV1(_n_,_tt_,_rt_,_t1_)                              \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_)                                              \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                      \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV1(_n_,_tt_,_rt_,_t1_)                                                             \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_)                                                                                             \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_);                                          \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV2(_n_,_tt_,_rt_,_t1_,_t2_)                             \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                   \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);           \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV2(_n_,_tt_,_rt_,_t1_,_t2_)                                                            \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                                                  \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);                       \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV2(_n_,_tt_,_rt_,_t1_,_t2_)                         \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                   \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);                 \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV2(_n_,_tt_,_rt_,_t1_,_t2_)                                                        \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_)                                                                  \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_);                                     \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                        \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                        \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);      \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                                               \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                                               \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);          \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                    \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                        \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);            \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV3(_n_,_tt_,_rt_,_t1_,_t2_,_t3_)                                   \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_)                                               \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_);                        \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
-#define __call_VV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)                   \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)             \
-{                                                                       \
-    _rt_ res;                                                           \
-    _ENTER_MONITOR();                                                   \
-    res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_); \
-    _EXIT_MONITOR();                                                    \
-    return res;                                                         \
+#define __call_VV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)                                  \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)                            \
+{                                                                                                                                              \
+       _rt_ res;                                                                                                                       \
+       _ENTER_MONITOR();                                                                                                       \
+       res = ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_); \
+       _EXIT_MONITOR();                                                                                                        \
+       return res;                                                                                                                     \
 }
 
-#define __call_voidVV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)               \
-static __inline__ _rt_                                                  \
-__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)             \
-{                                                                       \
-    _ENTER_MONITOR();                                                   \
-    ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_);       \
-    _EXIT_MONITOR();                                                    \
+#define __call_voidVV4(_n_,_tt_,_rt_,_t1_,_t2_,_t3_,_t4_)                              \
+static __inline__ _rt_                                                                                                 \
+__call_vv_##_n_(_t1_ _p1_, _t2_ _p2_, _t3_ _p3_, _t4_ _p4_)                            \
+{                                                                                                                                              \
+       _ENTER_MONITOR();                                                                                                       \
+       ((_tt_ *)hal_virtual_vector_table[_n_])(_p1_,_p2_,_p3_,_p4_);           \
+       _EXIT_MONITOR();                                                                                                        \
 }
 
 
-#define CYGACC_DATA_VV(t,e)              __call_vv_##e()
-#define CYGACC_CALL_VV0(t,e)             __call_vv_##e
-#define CYGACC_CALL_VV1(t,e,p1)          __call_vv_##e((p1))
-#define CYGACC_CALL_VV2(t,e,p1,p2)       __call_vv_##e((p1),(p2))
-#define CYGACC_CALL_VV3(t,e,p1,p2,p3)    __call_vv_##e((p1),(p2),(p3))
+#define CYGACC_DATA_VV(t,e)                             __call_vv_##e()
+#define CYGACC_CALL_VV0(t,e)                    __call_vv_##e
+#define CYGACC_CALL_VV1(t,e,p1)                         __call_vv_##e((p1))
+#define CYGACC_CALL_VV2(t,e,p1,p2)              __call_vv_##e((p1),(p2))
+#define CYGACC_CALL_VV3(t,e,p1,p2,p3)   __call_vv_##e((p1),(p2),(p3))
 #define CYGACC_CALL_VV4(t,e,p1,p2,p3,p4) __call_vv_##e((p1),(p2),(p3),(p4))
 
 #define CYGACC_CALL_IF_VERSION() \
@@ -666,9 +666,9 @@ __call_voidVV1(CYGNUM_CALL_IF_INSTALL_BPT_FN, __call_if_install_bpt_fn_t, void,
 //
 // Access persistent data store - kept in FLASH or EEPROM by RedBoot
 //
-#define CYGNUM_CALL_IF_FLASH_CFG_GET  (0)     // Get a particular fconfig key
-#define CYGNUM_CALL_IF_FLASH_CFG_NEXT (1)     // Enumerate keys (get the next one)
-#define CYGNUM_CALL_IF_FLASH_CFG_SET  (2)     // Update particular fconfig key
+#define CYGNUM_CALL_IF_FLASH_CFG_GET   0         // Get a particular fconfig key
+#define CYGNUM_CALL_IF_FLASH_CFG_NEXT  1         // Enumerate keys (get the next one)
+#define CYGNUM_CALL_IF_FLASH_CFG_SET   2         // Update particular fconfig key
 #define CYGACC_CALL_IF_FLASH_CFG_OP2(_o_,_d_) \
  CYGACC_CALL_VV2(__call_if_flash_cfg_op_fn_t*, CYGNUM_CALL_IF_FLASH_CFG_OP, (_o_),(_d_))
 __call_VV2(CYGNUM_CALL_IF_FLASH_CFG_OP, __call_if_flash_cfg_op_fn_t, cyg_bool, int, struct cyg_fconfig *)
@@ -676,12 +676,12 @@ __call_VV2(CYGNUM_CALL_IF_FLASH_CFG_OP, __call_if_flash_cfg_op_fn_t, cyg_bool, i
 static __inline__ cyg_bool
 __call_if_flash_cfg_op(int op, char *key, void *data, int type)
 {
-    struct cyg_fconfig info;
-    info.key = key;
-    info.val = data;
-    info.type = type;
-    info.offset = 0;
-    return CYGACC_CALL_IF_FLASH_CFG_OP2(op, &info);
+       struct cyg_fconfig info;
+       info.key = key;
+       info.val = data;
+       info.type = type;
+       info.offset = 0;
+       return CYGACC_CALL_IF_FLASH_CFG_OP2(op, &info);
 }
 #define CYGACC_CALL_IF_FLASH_CFG_OP(_o_,_k_,_d_,_t_) \
   __call_if_flash_cfg_op(_o_,_k_,_d_,_t_)
@@ -699,38 +699,37 @@ __call_voidVV1(CYGNUM_CALL_IF_MONITOR_RETURN, __call_if_monitor_return_t, void,
 __call_VV3(CYGNUM_CALL_IF_FLASH_FIS_OP, __call_if_flash_fis_op_fn_t, cyg_bool, int, char *, void *)
 #define CYGACC_CALL_IF_FLASH_FIS_OP_SET(_x_) \
  hal_virtual_vector_table[CYGNUM_CALL_IF_FLASH_FIS_OP]=(CYG_ADDRWORD)(_x_)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_FLASH_BASE  (0)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_SIZE        (1)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_MEM_BASE    (2)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_POINT (3)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_DATA_LENGTH (4)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_DESC_CKSUM  (5)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_FILE_CKSUM  (6)
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_FLASH_BASE                0
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_SIZE                      1
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_MEM_BASE          2
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_POINT       3
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_DATA_LENGTH       4
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_DESC_CKSUM                5
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_FILE_CKSUM                6
 
 #define CYGACC_CALL_IF_FLASH_FIS_OP2(_o_,_k_,_d_) \
  CYGACC_CALL_VV3(__call_if_flash_fis_op2_fn_t*, CYGNUM_CALL_IF_FLASH_FIS_OP2, (_o_),(_k_),(_d_))
 __call_VV3(CYGNUM_CALL_IF_FLASH_FIS_OP2, __call_if_flash_fis_op2_fn_t, int, int, unsigned int, struct fis_table_entry *)
 #define CYGACC_CALL_IF_FLASH_FIS_OP2_SET(_x_) \
  hal_virtual_vector_table[CYGNUM_CALL_IF_FLASH_FIS_OP2]=(CYG_ADDRWORD)(_x_)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_VERSION     (0)
-#define CYGNUM_CALL_IF_FLASH_FIS_INIT            (1)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_COUNT (2)
-#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY       (3)
-#define CYGNUM_CALL_IF_FLASH_FIS_START_UPDATE    (4)
-#define CYGNUM_CALL_IF_FLASH_FIS_FINISH_UPDATE   (5)
-#define CYGNUM_CALL_IF_FLASH_FIS_MODIFY_ENTRY    (6)
-
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_VERSION           0
+#define CYGNUM_CALL_IF_FLASH_FIS_INIT                          1
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY_COUNT       2
+#define CYGNUM_CALL_IF_FLASH_FIS_GET_ENTRY                     3
+#define CYGNUM_CALL_IF_FLASH_FIS_START_UPDATE          4
+#define CYGNUM_CALL_IF_FLASH_FIS_FINISH_UPDATE         5
+#define CYGNUM_CALL_IF_FLASH_FIS_MODIFY_ENTRY          6
 
 
 // These need to be kept uptodate with the (unadorned) masters
 // in RedBoot's flash_config.h:
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_EMPTY   0
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_BOOL    1
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_INT     2
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_STRING  3
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_SCRIPT  4
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_IP      5
-#define CYGNUM_FLASH_CFG_TYPE_CONFIG_ESA     6
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_EMPTY                     0
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_BOOL                      1
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_INT                       2
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_STRING                    3
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_SCRIPT                    4
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_IP                                5
+#define CYGNUM_FLASH_CFG_TYPE_CONFIG_ESA                       6
 
 #endif // CYGACC_CALL_IF_DEFINED
 
@@ -751,9 +750,9 @@ externC cyg_bool   hal_ctrlc_check(CYG_ADDRWORD vector, CYG_ADDRWORD data);
 #else
 
 #if defined(CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT) \
-    || defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT)
+       || defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT)
 // Then other code might invoke this macro
-#define HAL_CTRLC_CHECK(a1,a2) (0) // Nothing, no CTRLC here
+#define HAL_CTRLC_CHECK(a1,a2)                         0 // Nothing, no CTRLC here
 #endif
 
 #endif // CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT
index 84f22f6..5131d79 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
-//              code. 
+//              code.
 //
 //####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
-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
@@ -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[] = {
-    "",
-    "hbreak",
-    "watch",
-    "rwatch",
-    "awatch"
+       "",
+       "hbreak",
+       "watch",
+       "rwatch",
+       "awatch"
 };
 #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.
-target_register_t 
+target_register_t
 get_register (regnames_t reg)
 {
-    return _registers[reg];
+       return _registers[reg];
 }
 #endif
 
@@ -159,29 +159,29 @@ get_register (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.
-void 
+void
 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
 
@@ -193,30 +193,30 @@ extern char ecos_bsp_console_getc(void);
 #endif
 
 // Write C to the current serial port.
-void 
+void
 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)
-    ecos_bsp_console_putc(c);
+       ecos_bsp_console_putc(c);
 #else
-    HAL_STUB_PLATFORM_PUT_CHAR(c);
+       HAL_STUB_PLATFORM_PUT_CHAR(c);
 #endif
 }
 
 // Read one character from the current serial port.
-int 
+int
 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)
-    return ecos_bsp_console_getc();
+       return ecos_bsp_console_getc();
 #else
-    return HAL_STUB_PLATFORM_GET_CHAR();
+       return HAL_STUB_PLATFORM_GET_CHAR();
 #endif
 }
 
@@ -225,23 +225,23 @@ void
 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.
-void 
-__set_baud_rate (int baud) 
+void
+__set_baud_rate (int baud)
 {
 #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)
-    // FIXME!
+       // FIXME!
 #else
-    HAL_STUB_PLATFORM_SET_BAUD_RATE(baud);
+       HAL_STUB_PLATFORM_SET_BAUD_RATE(baud);
 #endif
 }
 
@@ -264,76 +264,76 @@ typedef cyg_uint32 t_inst;
 
 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;
 
-void 
+void
 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)
 {
-    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)
 {
-    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)
 {
-    if (NULL != break_buffer.targetAddr) {
-        return 1;
-    }
-    return 0;
+       if (NULL != break_buffer.targetAddr) {
+               return 1;
+       }
+       return 0;
 }
 
 #endif // CYGPKG_HAL_ARM
@@ -349,37 +349,37 @@ cyg_hal_gdb_break_is_set (void)
 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
-            {
-                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
-        }
-    } 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
-            {
-                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
-    }
+       }
 }
 
 //-----------------------------------------------------------------------------
@@ -394,101 +394,101 @@ int cyg_hal_gdb_break;
 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*
-static void 
+static void
 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
-    set_pc((target_register_t)return_from_stub);
+       set_pc((target_register_t)return_from_stub);
 #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*
-static void 
+static void
 handle_exception_cleanup( void )
 {
 #ifndef CYGPKG_REDBOOT
-    static int orig_registers_set = 0;
+       static int orig_registers_set = 0;
 #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
-    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
-       
+
 #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
-    // 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)
-    // 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*
-static void 
+static 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.
-int 
+int
 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.
-void 
+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
-    // Control of GDB interrupts.
-    __interruptible_control = HAL_STUB_PLATFORM_INTERRUPTIBLE;
+       // Control of GDB interrupts.
+       __interruptible_control = HAL_STUB_PLATFORM_INTERRUPTIBLE;
 #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.
-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
-    // 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
-    // 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.
-void 
+void
 __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
-    HAL_PLATFORM_RESET();
+       HAL_PLATFORM_RESET();
 #endif
 }
 
@@ -575,203 +575,203 @@ __reset (void)
 void
 breakpoint()
 {
-    HAL_BREAKPOINT(_breakinst);
+       HAL_BREAKPOINT(_breakinst);
 }
 
 // This function returns the opcode for a 'trap' instruction.
-unsigned long 
+unsigned long
 __break_opcode ()
 {
-  return HAL_BREAKINST;
+       return HAL_BREAKINST;
 }
 #endif
 
 //-----------------------------------------------------------------------------
 // Write the 'T' packet in BUFFER. SIGVAL is the signal the program received.
-void 
+void
 __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
-    // 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)
-           // 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
-           ptr = __mem2hex((char *)&id, ptr, sizeof(id), 0);
-           *ptr++ = ';';
+                       ptr = __mem2hex((char *)&id, ptr, sizeof(id), 0);
+                       *ptr++ = ';';
+               }
        }
-    }
 #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
-        // 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
-       *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
 
-    *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
-        {
-            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
-    }
+       }
 #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
-    ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
+       ptr = __mem2hex((char *)&addr, ptr, sizeof(addr), 0);
 #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
-    *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
-        {
-            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
-        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.
 
-// 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.
-int 
+int
 __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
-    HAL_ICACHE_IS_ENABLED(state);
+       HAL_ICACHE_IS_ENABLED(state);
 #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.
-int 
+int
 __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
-    HAL_DCACHE_IS_ENABLED(state);
+       HAL_DCACHE_IS_ENABLED(state);
 #endif
 
-    return state;
+       return state;
 }
 
 //-----------------------------------------------------------------------------
@@ -786,7 +786,7 @@ __data_cache (cache_control_t request)
 
 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.  */
 
@@ -795,55 +795,55 @@ static volatile target_register_t memCount;
 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)
 {
-  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)
 {
-  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)
 {
-    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)
 {
-    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)
 {
-  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)
 {
-  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?!
-int 
+int
 __process_target_query(char * pkt, char * out, int maxOut)
 { return 0 ; }
-int 
+int
 __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.
-void 
+void
 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
index 012360d..7e7be1d 100644 (file)
@@ -43,9 +43,9 @@
 // Author(s):     Red Hat, nickg
 // Contributors:  Red Hat, nickg
 // Date:          1998-08-25
-// Purpose:       
+// Purpose:
 // Description:   Provides multi-threaded debug support
-// Usage:         
+// Usage:
 //
 //####DESCRIPTIONEND####
 //
@@ -58,8 +58,8 @@
 // #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
 
 #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 */
-     
+
 #include "thread-pkts.h"
 
 #ifdef __ECOS__
 /*
  * 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
-extern void output_string(char * message) ;
+extern void output_string(char *message);
 
 #if PKT_DEBUG
-void output_threadid(char * title,threadref * ref) ;
+void output_threadid(char *title, threadref *ref);
 #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
-#define PKT_TRACE(title,packet) {}
-#endif 
+#define PKT_TRACE(title, packet) {}
+#endif
 
 
 /* This is going to be irregular because the various implementations
@@ -122,52 +122,50 @@ void output_threadid(char * title,threadref * ref) ;
      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 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__
-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__
 
-extern int stubhex(char ch) ;
+extern int stubhex(char ch);
 
 /* ----- 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 */
-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 ------------------------------- */
@@ -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 */
 
-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 */
 
-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 */
-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 */
 
-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 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 */
 
-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__
 
@@ -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 */
 
-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 */
 
 
@@ -293,32 +297,32 @@ char * unpack_varlen_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 */
-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 */
 
 
@@ -330,35 +334,35 @@ static char * pack_int(char * buf,int value)
    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__
-  int len = 0;
-  char *s = string;
-  while( *s++ ) len++;
+       int len = 0;
+       char *s = string;
+       while( *s++ ) len++;
 #else  // __ECOS__
-  int len ;
-  len = strlen(string) ;
+       int len;
+       len = strlen(string);
 #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 */
 
 
@@ -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 */
 
-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
@@ -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.
- */
+*/
 
-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 */
 
-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(
-                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 */
 
-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)
 {
-  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(
-                                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 --------------------------------- */
@@ -500,38 +504,38 @@ void stub_pkt_currthread(
 
 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_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.
-     '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(
-                           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 */
 
 
@@ -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.
-   */
+*/
 
-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
-  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 (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 */
 
 
@@ -710,380 +712,380 @@ void stub_pkt_getthreadlist(char * inbuf,
 /* 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(
-                            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 */
-                        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 ----------------- */
 
-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
-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_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 --------------------------------- */
-/*    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 ------------------------------------ */
-/* 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(
-                              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 */
+
 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 -------------------------------- */
 
-/* 
-   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 */
 
 
 
-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 */
 
 
-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 */
-/* 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_MOREDISPLAY 16 
+#define TAG_MOREDISPLAY 16
 
 
 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 */
 
-/* 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 */
 
 
@@ -1092,227 +1094,227 @@ char * remote_pack_currthread_request(char * pkt )
 
 
 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
-  {
-    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
-  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"
-   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 */
 
 
-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 ------------------------------- */
 
-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 */
-     
+
 #endif /* GDB_MOCKUP */
-\f
+
 /* ---------------------------------------------------------------------- */
 /* 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 */
 
-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 -------------------------------------------- */
-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 ------------------------------------------- */
-  /* 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 ---------------------- */
-  /* 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(
-                           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 */
 
 
-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 (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 */
 
 
@@ -1320,92 +1322,86 @@ static int get_and_display_threadinfo(threadref * thread)
 /* ----- THREADLIST_TEST ------------------------------------------ */
 #define TESTLISTSIZE 16
 #define TLRSIZ 2
-static threadref test_threadlist[TESTLISTSIZE] ;
+static threadref test_threadlist[TESTLISTSIZE];
 
 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 */
 
 
-static threadref testthread ;
+static threadref testthread;
 
 
 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 */