From: lothar Date: Thu, 14 Jan 2010 17:07:36 +0000 (+0000) Subject: TX51 pre-release X-Git-Tag: v1.5.3~32 X-Git-Url: https://git.kernelconcepts.de/?p=karo-tx-redboot.git;a=commitdiff_plain;h=180ccf89a5ded9754f2cf2b1fff49e4ce086df1e;hp=90030eb5f15e1119b6f08463856ac32794d1c3e2 TX51 pre-release --- diff --git a/packages/hal/arm/mx25/karo/v1_0/include/karo_tx25.h b/packages/hal/arm/mx25/karo/v1_0/include/karo_tx25.h index a2fc9bf4..b443ed70 100644 --- a/packages/hal/arm/mx25/karo/v1_0/include/karo_tx25.h +++ b/packages/hal/arm/mx25/karo/v1_0/include/karo_tx25.h @@ -44,37 +44,27 @@ #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) @@ -88,33 +78,33 @@ }) #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); \ @@ -123,7 +113,7 @@ HAL_DELAY_US(300000); \ } \ HAL_DELAY_US(1000000); \ - CYG_MACRO_END + CYG_MACRO_END #if !defined(__ASSEMBLER__) enum { diff --git a/packages/hal/arm/mx25/karo/v1_0/include/pkgconf/mlt_arm_tx25_romram.h b/packages/hal/arm/mx25/karo/v1_0/include/pkgconf/mlt_arm_tx25_romram.h index 664f5b61..24a15a9e 100644 --- a/packages/hal/arm/mx25/karo/v1_0/include/pkgconf/mlt_arm_tx25_romram.h +++ b/packages/hal/arm/mx25/karo/v1_0/include/pkgconf/mlt_arm_tx25_romram.h @@ -11,6 +11,17 @@ #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 diff --git a/packages/hal/arm/mx25/karo/v1_0/include/plf_mmap.h b/packages/hal/arm/mx25/karo/v1_0/include/plf_mmap.h index e81d8331..b703569e 100644 --- a/packages/hal/arm/mx25/karo/v1_0/include/plf_mmap.h +++ b/packages/hal/arm/mx25/karo/v1_0/include/plf_mmap.h @@ -42,38 +42,85 @@ //=========================================================================== #include +#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 diff --git a/packages/hal/arm/mx25/karo/v1_0/src/redboot_cmds.c b/packages/hal/arm/mx25/karo/v1_0/src/redboot_cmds.c index 8eff72c1..457f331c 100644 --- a/packages/hal/arm/mx25/karo/v1_0/src/redboot_cmds.c +++ b/packages/hal/arm/mx25/karo/v1_0/src/redboot_cmds.c @@ -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
] ", - do_mem - ); + "Set a memory location", + "[-h|-b] [-n] [-a
] ", + do_mem + ); RedBoot_cmd("run", - "Run an image at a location with MMU off", - "[]", - runImg - ); + "Run an image at a location with MMU off", + "[]", + 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 diff --git a/packages/hal/arm/mx25/karo/v1_0/src/tx25_misc.c b/packages/hal/arm/mx25/karo/v1_0/src/tx25_misc.c index 01378819..21ca7665 100644 --- a/packages/hal/arm/mx25/karo/v1_0/src/tx25_misc.c +++ b/packages/hal/arm/mx25/karo/v1_0/src/tx25_misc.c @@ -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; } diff --git a/packages/hal/arm/mx25/var/v2_0/include/hal_mm.h b/packages/hal/arm/mx25/var/v2_0/include/hal_mm.h index 42913243..f24b0376 100644 --- a/packages/hal/arm/mx25/var/v2_0/include/hal_mm.h +++ b/packages/hal/arm/mx25/var/v2_0/include/hal_mm.h @@ -49,169 +49,122 @@ /* * 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 - - - - - diff --git a/packages/hal/arm/mx25/var/v2_0/include/hal_soc.h b/packages/hal/arm/mx25/var/v2_0/include/hal_soc.h index 672f6112..1a6944f4 100644 --- a/packages/hal/arm/mx25/var/v2_0/include/hal_soc.h +++ b/packages/hal/arm/mx25/var/v2_0/include/hal_soc.h @@ -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)) diff --git a/packages/hal/arm/mx25/var/v2_0/src/soc_diag.c b/packages/hal/arm/mx25/var/v2_0/src/soc_diag.c index a125ccd0..f2cf9b6c 100644 --- a/packages/hal/arm/mx25/var/v2_0/src/soc_diag.c +++ b/packages/hal/arm/mx25/var/v2_0/src/soc_diag.c @@ -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; diff --git a/packages/hal/arm/mx25/var/v2_0/src/soc_misc.c b/packages/hal/arm/mx25/var/v2_0/src/soc_misc.c index 85ea66f2..13283fbc 100644 --- a/packages/hal/arm/mx25/var/v2_0/src/soc_misc.c +++ b/packages/hal/arm/mx25/var/v2_0/src/soc_misc.c @@ -44,20 +44,20 @@ #include #include CYGBLD_HAL_PLATFORM_H -#include // base types -#include // tracing macros -#include // assertion macros +#include // base types +#include // tracing macros +#include // assertion macros -#include // Size constants -#include // IO macros -#include // Register state info +#include // Size constants +#include // IO macros +#include // Register state info #include -#include // Interrupt names -#include // Cache control -#include // Hardware definitions -#include // MMap table definitions +#include // Interrupt names +#include // Cache control +#include // Hardware definitions +#include // MMap table definitions -#include // diag_printf +#include // diag_printf #include // Most initialization has already been done before we get here. @@ -66,17 +66,17 @@ 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); diff --git a/packages/hal/common/v2_0/include/hal_if.h b/packages/hal/common/v2_0/include/hal_if.h index 2ce2b447..b554fc01 100644 --- a/packages/hal/common/v2_0/include/hal_if.h +++ b/packages/hal/common/v2_0/include/hal_if.h @@ -52,12 +52,12 @@ // combination of libbsp and vectors already in use by some // eCos platforms. // Usage: #include -// +// //####DESCRIPTIONEND#### // //============================================================================= -#include // types & externC +#include // types & externC #include #include @@ -72,15 +72,15 @@ // and eCos share facilities, e.g. the network hardware. #if defined (CYGPKG_NET) || defined (CYGPKG_NET_LWIP) #include -#include // 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_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 diff --git a/packages/hal/common/v2_0/src/hal_stub.c b/packages/hal/common/v2_0/src/hal_stub.c index 84f22f62..5131d799 100644 --- a/packages/hal/common/v2_0/src/hal_stub.c +++ b/packages/hal/common/v2_0/src/hal_stub.c @@ -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(®isters[0], _hal_registers); - _registers = ®isters[0]; + // Expand the HAL_SavedRegisters structure into the GDB register + // array format. + HAL_GET_GDB_REGISTERS(®isters[0], _hal_registers); + _registers = ®isters[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 = ®isters[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 = ®isters[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, ®isters[0]); + // Compact register array again. + HAL_SET_GDB_REGISTERS(_hal_registers, ®isters[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' as 'c'. - __process_signal_vec = &cyg_hal_process_signal; - __process_exit_vec = &handle_exception_exit; + // Set signal handling vector so we can treat 'C' 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 diff --git a/packages/hal/common/v2_0/src/thread-packets.c b/packages/hal/common/v2_0/src/thread-packets.c index 012360d5..7e7be1d7 100644 --- a/packages/hal/common/v2_0/src/thread-packets.c +++ b/packages/hal/common/v2_0/src/thread-packets.c @@ -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 -#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 */ @@ -78,12 +78,12 @@ #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__ @@ -96,22 +96,22 @@ /* * 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 = ®isters[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 = ®isters[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); } - + #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 */ - + /* ---------------------------------------------------------------------- */ /* 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 */