Firmware/ThreadX4TGFS
8
0
Fork 2
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

applies clang--format

Browse Source
This commit is contained in:
Eyck Jentzsch
2026-02-06 19:31:29 +01:00
parent 28c14404d2
commit 47588180b9
14 changed files with 3355 additions and 2877 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
port/moonlight/aclint.h
View File

@@ -4,34 +4,39 @@
#include "gen/aclint.h" #include "gen/aclint.h"
#include <stdint.h> #include <stdint.h>
static void set_aclint_mtime(volatile aclint_t* reg, uint64_t value) { static void set_aclint_mtime(volatile aclint_t* reg, uint64_t value)
{
set_aclint_mtime_hi(reg, (uint32_t)(value >> 32)); set_aclint_mtime_hi(reg, (uint32_t)(value >> 32));
set_aclint_mtime_lo(reg, (uint32_t)value); set_aclint_mtime_lo(reg, (uint32_t)value);
} }
static uint64_t get_aclint_mtime(volatile aclint_t* reg) { static uint64_t get_aclint_mtime(volatile aclint_t* reg)
#if(__riscv_xlen == 64) {
#if (__riscv_xlen == 64)
// this assume little endianness // this assume little endianness
volatile uint64_t* mtime = (volatile uint64_t*)(uint64_t)(&reg->MTIME_LO); volatile uint64_t* mtime = (volatile uint64_t*)(uint64_t)(&reg->MTIME_LO);
return *mtime; return *mtime;
#else #else
uint32_t mtimeh_val; uint32_t mtimeh_val;
uint32_t mtimel_val; uint32_t mtimel_val;
do { do
{
mtimeh_val = get_aclint_mtime_hi(reg); mtimeh_val = get_aclint_mtime_hi(reg);
mtimel_val = get_aclint_mtime_lo(reg); mtimel_val = get_aclint_mtime_lo(reg);
} while(mtimeh_val != get_aclint_mtime_hi(reg)); } while (mtimeh_val != get_aclint_mtime_hi(reg));
return (uint64_t)((((uint64_t)mtimeh_val) << 32) | mtimel_val); return (uint64_t)((((uint64_t)mtimeh_val) << 32) | mtimel_val);
#endif #endif
} }
static void set_aclint_mtimecmp(volatile aclint_t* reg, uint64_t value) { static void set_aclint_mtimecmp(volatile aclint_t* reg, uint64_t value)
{
set_aclint_mtimecmp0lo(reg, (uint32_t)0xFFFFFFFF); set_aclint_mtimecmp0lo(reg, (uint32_t)0xFFFFFFFF);
set_aclint_mtimecmp0hi(reg, (uint32_t)(value >> 32)); set_aclint_mtimecmp0hi(reg, (uint32_t)(value >> 32));
set_aclint_mtimecmp0lo(reg, (uint32_t)value); set_aclint_mtimecmp0lo(reg, (uint32_t)value);
} }
static uint64_t get_aclint_mtimecmp(volatile aclint_t* reg) { static uint64_t get_aclint_mtimecmp(volatile aclint_t* reg)
{
uint64_t value = ((uint64_t)get_aclint_mtimecmp0hi(reg) << 32) | (uint64_t)get_aclint_mtimecmp0lo(reg); uint64_t value = ((uint64_t)get_aclint_mtimecmp0hi(reg) << 32) | (uint64_t)get_aclint_mtimecmp0lo(reg);
return value; return value;
} }

8
port/moonlight/hwtimer.h
View File

@@ -15,15 +15,17 @@
#include "platform.h" #include "platform.h"
#define TICKNUM_PER_SECOND 32768 #define TICKNUM_PER_SECOND 32768
#define TICKNUM_PER_TIMER (TICKNUM_PER_SECOND / 100) // ~ 1ms timer #define TICKNUM_PER_TIMER (TICKNUM_PER_SECOND / 100) // ~ 1ms timer
static inline int hwtimer_init(void) { static inline int hwtimer_init(void)
{
uint64_t time = get_aclint_mtime(aclint); uint64_t time = get_aclint_mtime(aclint);
set_aclint_mtimecmp(aclint, time + TICKNUM_PER_TIMER); set_aclint_mtimecmp(aclint, time + TICKNUM_PER_TIMER);
return 0; return 0;
} }
static inline int hwtimer_handler(void) { static inline int hwtimer_handler(void)
{
uint64_t time = get_aclint_mtime(aclint); uint64_t time = get_aclint_mtime(aclint);
set_aclint_mtimecmp(aclint, time + TICKNUM_PER_TIMER); set_aclint_mtimecmp(aclint, time + TICKNUM_PER_TIMER);
return 0; return 0;

31
port/moonlight/platform.h
View File

@@ -1,24 +1,23 @@
#include "uart.h"
#include "gen/ethmac.h"
#include "aclint.h" #include "aclint.h"
#include "gen/ethmac.h"
#include "riscv-csr.h" #include "riscv-csr.h"
#include "riscv-traps.h" #include "riscv-traps.h"
#include "uart.h"
#define PERIPH(TYPE, ADDR) ((volatile TYPE*)(ADDR)) #define PERIPH(TYPE, ADDR) ((volatile TYPE*)(ADDR))
#define PERIPH_BASE 0x10000000 #define PERIPH_BASE 0x10000000
#define uart PERIPH(uart_t, PERIPH_BASE + 0x01000) #define uart PERIPH(uart_t, PERIPH_BASE + 0x01000)
#define aclint PERIPH(aclint_t, PERIPH_BASE + 0x30000) #define aclint PERIPH(aclint_t, PERIPH_BASE + 0x30000)
#define ethmac0 PERIPH(ethmac_t, PERIPH_BASE + 0x1000000) #define ethmac0 PERIPH(ethmac_t, PERIPH_BASE + 0x1000000)
#define ethmac1 PERIPH(ethmac_t, PERIPH_BASE + 0x1001000) #define ethmac1 PERIPH(ethmac_t, PERIPH_BASE + 0x1001000)
#define UART0_IRQ 16 #define UART0_IRQ 16
#define TIMER0_IRQ0 17 #define TIMER0_IRQ0 17
#define TIMER0_IRQ1 18 #define TIMER0_IRQ1 18
#define QSPI_IRQ 19 #define QSPI_IRQ 19
#define I2S_IRQ 20 #define I2S_IRQ 20
#define CAM_IRQ 21 #define CAM_IRQ 21
#define DMA_IRQ 22 #define DMA_IRQ 22
#define GPIO_ORQ 23 #define GPIO_ORQ 23
#define ETH0_IRQ 24 #define ETH0_IRQ 24
#define ETH1_IRQ 25 #define ETH1_IRQ 25

4864
port/moonlight/riscv-csr.h
View File

File diff suppressed because it is too large Load Diff

63
port/moonlight/riscv-traps.h
View File

@@ -9,7 +9,8 @@
#ifndef RISCV_TRAPS_H #ifndef RISCV_TRAPS_H
#define RISCV_TRAPS_H #define RISCV_TRAPS_H
enum { enum
{
RISCV_INT_MSI = 3, RISCV_INT_MSI = 3,
RISCV_INT_MTI = 7, RISCV_INT_MTI = 7,
RISCV_INT_MEI = 11, RISCV_INT_MEI = 11,
@@ -21,7 +22,8 @@ enum {
RISCV_INT_UEI = 8, RISCV_INT_UEI = 8,
}; };
enum { enum
{
RISCV_INT_POS_MSI = 3, RISCV_INT_POS_MSI = 3,
RISCV_INT_POS_MTI = 7, RISCV_INT_POS_MTI = 7,
RISCV_INT_POS_MEI = 11, RISCV_INT_POS_MEI = 11,
@@ -33,36 +35,37 @@ enum {
RISCV_INT_POS_UEI = 8, RISCV_INT_POS_UEI = 8,
}; };
enum { enum
RISCV_INT_MASK_MSI = (1UL<<RISCV_INT_POS_MSI), {
RISCV_INT_MASK_MTI = (1UL<<RISCV_INT_POS_MTI), RISCV_INT_MASK_MSI = (1UL << RISCV_INT_POS_MSI),
RISCV_INT_MASK_MEI = (1UL<<RISCV_INT_POS_MEI), RISCV_INT_MASK_MTI = (1UL << RISCV_INT_POS_MTI),
RISCV_INT_MASK_SSI = (1UL<<RISCV_INT_POS_SSI), RISCV_INT_MASK_MEI = (1UL << RISCV_INT_POS_MEI),
RISCV_INT_MASK_STI = (1UL<<RISCV_INT_POS_STI), RISCV_INT_MASK_SSI = (1UL << RISCV_INT_POS_SSI),
RISCV_INT_MASK_SEI = (1UL<<RISCV_INT_POS_SEI), RISCV_INT_MASK_STI = (1UL << RISCV_INT_POS_STI),
RISCV_INT_MASK_USI = (1UL<<RISCV_INT_POS_USI), RISCV_INT_MASK_SEI = (1UL << RISCV_INT_POS_SEI),
RISCV_INT_MASK_UTI = (1UL<<RISCV_INT_POS_UTI), RISCV_INT_MASK_USI = (1UL << RISCV_INT_POS_USI),
RISCV_INT_MASK_UEI = (1UL<<RISCV_INT_POS_UEI), RISCV_INT_MASK_UTI = (1UL << RISCV_INT_POS_UTI),
RISCV_INT_MASK_UEI = (1UL << RISCV_INT_POS_UEI),
}; };
enum { enum
RISCV_EXCP_INSTRUCTION_ADDRESS_MISALIGNED=0, /* Instruction address misaligned */ {
RISCV_EXCP_INSTRUCTION_ACCESS_FAULT=1, /* Instruction access fault */ RISCV_EXCP_INSTRUCTION_ADDRESS_MISALIGNED = 0, /* Instruction address misaligned */
RISCV_EXCP_ILLEGAL_INSTRUCTION=2, /* Illegal instruction */ RISCV_EXCP_INSTRUCTION_ACCESS_FAULT = 1, /* Instruction access fault */
RISCV_EXCP_BREAKPOINT=3, /* Breakpoint */ RISCV_EXCP_ILLEGAL_INSTRUCTION = 2, /* Illegal instruction */
RISCV_EXCP_LOAD_ADDRESS_MISALIGNED=4, /* Load address misaligned */ RISCV_EXCP_BREAKPOINT = 3, /* Breakpoint */
RISCV_EXCP_LOAD_ACCESS_FAULT=5, /* Load access fault */ RISCV_EXCP_LOAD_ADDRESS_MISALIGNED = 4, /* Load address misaligned */
RISCV_EXCP_STORE_AMO_ADDRESS_MISALIGNED =6, /* Store/AMO address misaligned */ RISCV_EXCP_LOAD_ACCESS_FAULT = 5, /* Load access fault */
RISCV_EXCP_STORE_AMO_ACCESS_FAULT=7, /* Store/AMO access fault */ RISCV_EXCP_STORE_AMO_ADDRESS_MISALIGNED = 6, /* Store/AMO address misaligned */
RISCV_EXCP_ENVIRONMENT_CALL_FROM_U_MODE=8, /* Environment call from U-mode */ RISCV_EXCP_STORE_AMO_ACCESS_FAULT = 7, /* Store/AMO access fault */
RISCV_EXCP_ENVIRONMENT_CALL_FROM_S_MODE=9, /* Environment call from S-mode */ RISCV_EXCP_ENVIRONMENT_CALL_FROM_U_MODE = 8, /* Environment call from U-mode */
RISCV_EXCP_RESERVED10=10, /* Reserved */ RISCV_EXCP_ENVIRONMENT_CALL_FROM_S_MODE = 9, /* Environment call from S-mode */
RISCV_EXCP_ENVIRONMENT_CALL_FROM_M_MODE=11, /* Environment call from M-mode */ RISCV_EXCP_RESERVED10 = 10, /* Reserved */
RISCV_EXCP_INSTRUCTION_PAGE_FAULT=12, /* Instruction page fault */ RISCV_EXCP_ENVIRONMENT_CALL_FROM_M_MODE = 11, /* Environment call from M-mode */
RISCV_EXCP_LOAD_PAGE_FAULT=13, /* Load page fault */ RISCV_EXCP_INSTRUCTION_PAGE_FAULT = 12, /* Instruction page fault */
RISCV_EXCP_RESERVED14=14, /* Reserved */ RISCV_EXCP_LOAD_PAGE_FAULT = 13, /* Load page fault */
RISCV_EXCP_STORE_AMO_PAGE_FAULT=15, /* Store/AMO page fault */ RISCV_EXCP_RESERVED14 = 14, /* Reserved */
RISCV_EXCP_STORE_AMO_PAGE_FAULT = 15, /* Store/AMO page fault */
}; };
#endif /* RISCV_TRAPS_H */ #endif /* RISCV_TRAPS_H */

25
port/moonlight/uart.h
View File

@@ -3,21 +3,32 @@
#include "gen/uart.h" #include "gen/uart.h"
#include <stdint.h> #include <stdint.h>
static inline uint32_t uart_get_tx_free(volatile uart_t* reg) { return get_uart_rx_tx_reg_tx_free(reg); } static inline uint32_t uart_get_tx_free(volatile uart_t* reg)
{
return get_uart_rx_tx_reg_tx_free(reg);
}
static inline uint32_t uart_get_tx_empty(volatile uart_t* reg) { return get_uart_rx_tx_reg_tx_empty(reg); } static inline uint32_t uart_get_tx_empty(volatile uart_t* reg)
{
return get_uart_rx_tx_reg_tx_empty(reg);
}
static inline uint32_t uart_get_rx_avail(volatile uart_t* reg) { return get_uart_rx_tx_reg_rx_avail(reg); } static inline uint32_t uart_get_rx_avail(volatile uart_t* reg)
{
return get_uart_rx_tx_reg_rx_avail(reg);
}
static inline void uart_write(volatile uart_t* reg, uint8_t data) { static inline void uart_write(volatile uart_t* reg, uint8_t data)
while(get_uart_rx_tx_reg_tx_free(reg) == 0) {
while (get_uart_rx_tx_reg_tx_free(reg) == 0)
; ;
set_uart_rx_tx_reg_data(reg, data); set_uart_rx_tx_reg_data(reg, data);
} }
static inline uint8_t uart_read(volatile uart_t* reg) { static inline uint8_t uart_read(volatile uart_t* reg)
{
uint32_t res = get_uart_rx_tx_reg_data(reg); uint32_t res = get_uart_rx_tx_reg_data(reg);
while((res & 0x10000) == 0) while ((res & 0x10000) == 0)
res = get_uart_rx_tx_reg_data(reg); res = get_uart_rx_tx_reg_data(reg);
return res; return res;
} }

71
port/moonlight/vector_table.h
View File

@@ -17,12 +17,11 @@
#ifndef VECTOR_TABLE_H #ifndef VECTOR_TABLE_H
#define VECTOR_TABLE_H #define VECTOR_TABLE_H
/** Symbol for machine mode vector table - do not call /** Symbol for machine mode vector table - do not call
*/ */
void riscv_mtvec_table(void) __attribute__ ((naked)); void riscv_mtvec_table(void) __attribute__((naked));
void riscv_stvec_table(void) __attribute__ ((naked)); void riscv_stvec_table(void) __attribute__((naked));
void riscv_utvec_table(void) __attribute__ ((naked)); void riscv_utvec_table(void) __attribute__((naked));
/** Machine mode syncronous exception handler. /** Machine mode syncronous exception handler.
@@ -35,79 +34,77 @@ practice, since user-mode software interrupts are either disabled or
delegated to user mode. delegated to user mode.
*/ */
void riscv_mtvec_exception(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_exception(void) __attribute__((interrupt("machine")));
/** Machine mode software interrupt */ /** Machine mode software interrupt */
void riscv_mtvec_msi(void) __attribute__ ((interrupt ("machine") )); void riscv_mtvec_msi(void) __attribute__((interrupt("machine")));
/** Machine mode timer interrupt */ /** Machine mode timer interrupt */
void riscv_mtvec_mti(void) __attribute__ ((interrupt ("machine") )); void riscv_mtvec_mti(void) __attribute__((interrupt("machine")));
/** Machine mode al interrupt */ /** Machine mode al interrupt */
void riscv_mtvec_mei(void) __attribute__ ((interrupt ("machine") )); void riscv_mtvec_mei(void) __attribute__((interrupt("machine")));
/** Supervisor mode software interrupt */ /** Supervisor mode software interrupt */
void riscv_mtvec_ssi(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_ssi(void) __attribute__((interrupt("machine")));
/** Supervisor mode timer interrupt */ /** Supervisor mode timer interrupt */
void riscv_mtvec_sti(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_sti(void) __attribute__((interrupt("machine")));
/** Supervisor mode al interrupt */ /** Supervisor mode al interrupt */
void riscv_mtvec_sei(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_sei(void) __attribute__((interrupt("machine")));
/** Supervisor mode syncronous exception handler. */ /** Supervisor mode syncronous exception handler. */
void riscv_stvec_exception(void) __attribute__ ((interrupt ("supervisor")) ); void riscv_stvec_exception(void) __attribute__((interrupt("supervisor")));
/** Supervisor mode software interrupt */ /** Supervisor mode software interrupt */
void riscv_stvec_ssi(void) __attribute__ ((interrupt ("supervisor")) ); void riscv_stvec_ssi(void) __attribute__((interrupt("supervisor")));
/** Supervisor mode timer interrupt */ /** Supervisor mode timer interrupt */
void riscv_stvec_sti(void) __attribute__ ((interrupt ("supervisor")) ); void riscv_stvec_sti(void) __attribute__((interrupt("supervisor")));
/** Supervisor mode al interrupt */ /** Supervisor mode al interrupt */
void riscv_stvec_sei(void) __attribute__ ((interrupt ("supervisor")) ); void riscv_stvec_sei(void) __attribute__((interrupt("supervisor")));
/** User mode software interrupt */ /** User mode software interrupt */
void riscv_utvec_usi(void) __attribute__ ((interrupt ("user")) ); void riscv_utvec_usi(void) __attribute__((interrupt("user")));
/** User mode timer interrupt */ /** User mode timer interrupt */
void riscv_utvec_uti(void) __attribute__ ((interrupt ("user")) ); void riscv_utvec_uti(void) __attribute__((interrupt("user")));
/** User mode al interrupt */ /** User mode al interrupt */
void riscv_utvec_uei(void) __attribute__ ((interrupt ("user")) ); void riscv_utvec_uei(void) __attribute__((interrupt("user")));
#ifndef VECTOR_TABLE_MTVEC_PLATFORM_INTS #ifndef VECTOR_TABLE_MTVEC_PLATFORM_INTS
/* Platform interrupts, bits 16+ of mie, mip etc /* Platform interrupts, bits 16+ of mie, mip etc
*/ */
/* Platform interrupt 0, bit 16 of mip/mie */ /* Platform interrupt 0, bit 16 of mip/mie */
void riscv_mtvec_platform_irq0(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq0(void) __attribute__((interrupt("machine")));
/* Platform interrupt 1, bit 17 of mip/mie */ /* Platform interrupt 1, bit 17 of mip/mie */
void riscv_mtvec_platform_irq1(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq1(void) __attribute__((interrupt("machine")));
/* Platform interrupt 2, bit 18 of mip/mie */ /* Platform interrupt 2, bit 18 of mip/mie */
void riscv_mtvec_platform_irq2(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq2(void) __attribute__((interrupt("machine")));
/* Platform interrupt 3, bit 19 of mip/mie */ /* Platform interrupt 3, bit 19 of mip/mie */
void riscv_mtvec_platform_irq3(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq3(void) __attribute__((interrupt("machine")));
/* Platform interrupt 4, bit 20 of mip/mie */ /* Platform interrupt 4, bit 20 of mip/mie */
void riscv_mtvec_platform_irq4(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq4(void) __attribute__((interrupt("machine")));
/* Platform interrupt 5, bit 21 of mip/mie */ /* Platform interrupt 5, bit 21 of mip/mie */
void riscv_mtvec_platform_irq5(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq5(void) __attribute__((interrupt("machine")));
/* Platform interrupt 6, bit 22 of mip/mie */ /* Platform interrupt 6, bit 22 of mip/mie */
void riscv_mtvec_platform_irq6(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq6(void) __attribute__((interrupt("machine")));
/* Platform interrupt 7, bit 23 of mip/mie */ /* Platform interrupt 7, bit 23 of mip/mie */
void riscv_mtvec_platform_irq7(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq7(void) __attribute__((interrupt("machine")));
/* Platform interrupt 8, bit 24 of mip/mie */ /* Platform interrupt 8, bit 24 of mip/mie */
void riscv_mtvec_platform_irq8(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq8(void) __attribute__((interrupt("machine")));
/* Platform interrupt 9, bit 25 of mip/mie */ /* Platform interrupt 9, bit 25 of mip/mie */
void riscv_mtvec_platform_irq9(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq9(void) __attribute__((interrupt("machine")));
/* Platform interrupt 10, bit 26 of mip/mie */ /* Platform interrupt 10, bit 26 of mip/mie */
void riscv_mtvec_platform_irq10(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq10(void) __attribute__((interrupt("machine")));
/* Platform interrupt 11, bit 27 of mip/mie */ /* Platform interrupt 11, bit 27 of mip/mie */
void riscv_mtvec_platform_irq11(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq11(void) __attribute__((interrupt("machine")));
/* Platform interrupt 12, bit 28 of mip/mie */ /* Platform interrupt 12, bit 28 of mip/mie */
void riscv_mtvec_platform_irq12(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq12(void) __attribute__((interrupt("machine")));
/* Platform interrupt 13, bit 29 of mip/mie */ /* Platform interrupt 13, bit 29 of mip/mie */
void riscv_mtvec_platform_irq13(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq13(void) __attribute__((interrupt("machine")));
/* Platform interrupt 14, bit 30 of mip/mie */ /* Platform interrupt 14, bit 30 of mip/mie */
void riscv_mtvec_platform_irq14(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq14(void) __attribute__((interrupt("machine")));
/* Platform interrupt 15, bit 31 of mip/mie */ /* Platform interrupt 15, bit 31 of mip/mie */
void riscv_mtvec_platform_irq15(void) __attribute__ ((interrupt ("machine")) ); void riscv_mtvec_platform_irq15(void) __attribute__((interrupt("machine")));
#endif // #ifndef VECTOR_TABLE_MTVEC_PLATFORM_INTS #endif // #ifndef VECTOR_TABLE_MTVEC_PLATFORM_INTS
#endif // #ifndef VECTOR_TABLE_H #endif // #ifndef VECTOR_TABLE_H

262
port/threadx/inc/csr.h
View File

@@ -8,41 +8,39 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
**************************************************************************/ **************************************************************************/
#ifndef CSR_H #ifndef CSR_H
#define CSR_H #define CSR_H
// Machine Status Register, mstatus // Machine Status Register, mstatus
#define MSTATUS_MPP_MASK (3L << 11) // previous mode. #define MSTATUS_MPP_MASK (3L << 11) // previous mode.
#define MSTATUS_MPP_M (3L << 11) #define MSTATUS_MPP_M (3L << 11)
#define MSTATUS_MPP_S (1L << 11) #define MSTATUS_MPP_S (1L << 11)
#define MSTATUS_MPP_U (0L << 11) #define MSTATUS_MPP_U (0L << 11)
#define MSTATUS_MIE (1L << 3) // machine-mode interrupt enable. #define MSTATUS_MIE (1L << 3) // machine-mode interrupt enable.
#define MSTATUS_MPIE (1L << 7) #define MSTATUS_MPIE (1L << 7)
#define MSTATUS_FS (1L << 13) #define MSTATUS_FS (1L << 13)
// Machine-mode Interrupt Enable // Machine-mode Interrupt Enable
#define MIE_MTIE (1L << 7) #define MIE_MTIE (1L << 7)
#define MIE_MSIE (1L << 3) #define MIE_MSIE (1L << 3)
#define MIE_MEIE (1L << 11) #define MIE_MEIE (1L << 11)
#define MIE_STIE (1L << 5) // supervisor timer #define MIE_STIE (1L << 5) // supervisor timer
#define MIE_SSIE (1L << 1) #define MIE_SSIE (1L << 1)
#define MIE_SEIE (1L << 9) #define MIE_SEIE (1L << 9)
// Supervisor Status Register, sstatus // Supervisor Status Register, sstatus
#define SSTATUS_SPP (1L << 8) // Previous mode, 1=Supervisor, 0=User #define SSTATUS_SPP (1L << 8) // Previous mode, 1=Supervisor, 0=User
#define SSTATUS_SPIE (1L << 5) // Supervisor Previous Interrupt Enable #define SSTATUS_SPIE (1L << 5) // Supervisor Previous Interrupt Enable
#define SSTATUS_UPIE (1L << 4) // User Previous Interrupt Enable #define SSTATUS_UPIE (1L << 4) // User Previous Interrupt Enable
#define SSTATUS_SIE (1L << 1) // Supervisor Interrupt Enable #define SSTATUS_SIE (1L << 1) // Supervisor Interrupt Enable
#define SSTATUS_UIE (1L << 0) // User Interrupt Enable #define SSTATUS_UIE (1L << 0) // User Interrupt Enable
#define SSTATUS_SPIE (1L << 5) #define SSTATUS_SPIE (1L << 5)
#define SSTATUS_UPIE (1L << 4) #define SSTATUS_UPIE (1L << 4)
// Supervisor Interrupt Enable // Supervisor Interrupt Enable
#define SIE_SEIE (1L << 9) // external #define SIE_SEIE (1L << 9) // external
#define SIE_STIE (1L << 5) // timer #define SIE_STIE (1L << 5) // timer
#define SIE_SSIE (1L << 1) // software #define SIE_SSIE (1L << 1) // software
#ifndef __ASSEMBLER__ #ifndef __ASSEMBLER__
@@ -50,21 +48,21 @@
static inline uint64_t riscv_get_core() static inline uint64_t riscv_get_core()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, mhartid" : "=r" (x) ); asm volatile("csrr %0, mhartid" : "=r"(x));
return x; return x;
} }
static inline uint64_t riscv_get_mstatus() static inline uint64_t riscv_get_mstatus()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, mstatus" : "=r" (x) ); asm volatile("csrr %0, mstatus" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_mstatus(uint64_t x) static inline void riscv_writ_mstatus(uint64_t x)
{ {
asm volatile("csrw mstatus, %0" : : "r" (x)); asm volatile("csrw mstatus, %0" : : "r"(x));
} }
// machine exception program counter, holds the // machine exception program counter, holds the
@@ -72,56 +70,56 @@ static inline void riscv_writ_mstatus(uint64_t x)
// exception will go. // exception will go.
static inline void riscv_writ_mepc(uint64_t x) static inline void riscv_writ_mepc(uint64_t x)
{ {
asm volatile("csrw mepc, %0" : : "r" (x)); asm volatile("csrw mepc, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_sstatus() static inline uint64_t riscv_get_sstatus()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, sstatus" : "=r" (x) ); asm volatile("csrr %0, sstatus" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_sstatus(uint64_t x) static inline void riscv_writ_sstatus(uint64_t x)
{ {
asm volatile("csrw sstatus, %0" : : "r" (x)); asm volatile("csrw sstatus, %0" : : "r"(x));
} }
// Supervisor Interrupt Pending // Supervisor Interrupt Pending
static inline uint64_t riscv_get_sip() static inline uint64_t riscv_get_sip()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, sip" : "=r" (x) ); asm volatile("csrr %0, sip" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_sip(uint64_t x) static inline void riscv_writ_sip(uint64_t x)
{ {
asm volatile("csrw sip, %0" : : "r" (x)); asm volatile("csrw sip, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_sie() static inline uint64_t riscv_get_sie()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, sie" : "=r" (x) ); asm volatile("csrr %0, sie" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_sie(uint64_t x) static inline void riscv_writ_sie(uint64_t x)
{ {
asm volatile("csrw sie, %0" : : "r" (x)); asm volatile("csrw sie, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_mie() static inline uint64_t riscv_get_mie()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, mie" : "=r" (x) ); asm volatile("csrr %0, mie" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_mie(uint64_t x) static inline void riscv_writ_mie(uint64_t x)
{ {
asm volatile("csrw mie, %0" : : "r" (x)); asm volatile("csrw mie, %0" : : "r"(x));
} }
// supervisor exception program counter, holds the // supervisor exception program counter, holds the
@@ -129,243 +127,243 @@ static inline void riscv_writ_mie(uint64_t x)
// exception will go. // exception will go.
static inline void riscv_writ_sepc(uint64_t x) static inline void riscv_writ_sepc(uint64_t x)
{ {
asm volatile("csrw sepc, %0" : : "r" (x)); asm volatile("csrw sepc, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_sepc() static inline uint64_t riscv_get_sepc()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, sepc" : "=r" (x) ); asm volatile("csrr %0, sepc" : "=r"(x));
return x; return x;
} }
// Machine Exception Delegation // Machine Exception Delegation
static inline uint64_t riscv_get_medeleg() static inline uint64_t riscv_get_medeleg()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, medeleg" : "=r" (x) ); asm volatile("csrr %0, medeleg" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_medeleg(uint64_t x) static inline void riscv_writ_medeleg(uint64_t x)
{ {
asm volatile("csrw medeleg, %0" : : "r" (x)); asm volatile("csrw medeleg, %0" : : "r"(x));
} }
// Machine Interrupt Delegation // Machine Interrupt Delegation
static inline uint64_t riscv_get_mideleg() static inline uint64_t riscv_get_mideleg()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, mideleg" : "=r" (x) ); asm volatile("csrr %0, mideleg" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_mideleg(uint64_t x) static inline void riscv_writ_mideleg(uint64_t x)
{ {
asm volatile("csrw mideleg, %0" : : "r" (x)); asm volatile("csrw mideleg, %0" : : "r"(x));
} }
// Supervisor Trap-Vector Base Address // Supervisor Trap-Vector Base Address
// low two bits are mode. // low two bits are mode.
static inline void riscv_writ_stvec(uint64_t x) static inline void riscv_writ_stvec(uint64_t x)
{ {
asm volatile("csrw stvec, %0" : : "r" (x)); asm volatile("csrw stvec, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_stvec() static inline uint64_t riscv_get_stvec()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, stvec" : "=r" (x) ); asm volatile("csrr %0, stvec" : "=r"(x));
return x; return x;
} }
// Supervisor Timer Comparison Register // Supervisor Timer Comparison Register
static inline uint64_t riscv_get_stimecmp() static inline uint64_t riscv_get_stimecmp()
{ {
uint64_t x; uint64_t x;
// asm volatile("csrr %0, stimecmp" : "=r" (x) ); // asm volatile("csrr %0, stimecmp" : "=r" (x) );
asm volatile("csrr %0, 0x14d" : "=r" (x) ); asm volatile("csrr %0, 0x14d" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_stimecmp(uint64_t x) static inline void riscv_writ_stimecmp(uint64_t x)
{ {
// asm volatile("csrw stimecmp, %0" : : "r" (x)); // asm volatile("csrw stimecmp, %0" : : "r" (x));
asm volatile("csrw 0x14d, %0" : : "r" (x)); asm volatile("csrw 0x14d, %0" : : "r"(x));
} }
// Machine Environment Configuration Register // Machine Environment Configuration Register
static inline uint64_t riscv_get_menvcfg() static inline uint64_t riscv_get_menvcfg()
{ {
uint64_t x; uint64_t x;
// asm volatile("csrr %0, menvcfg" : "=r" (x) ); // asm volatile("csrr %0, menvcfg" : "=r" (x) );
asm volatile("csrr %0, 0x30a" : "=r" (x) ); asm volatile("csrr %0, 0x30a" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_menvcfg(uint64_t x) static inline void riscv_writ_menvcfg(uint64_t x)
{ {
// asm volatile("csrw menvcfg, %0" : : "r" (x)); // asm volatile("csrw menvcfg, %0" : : "r" (x));
asm volatile("csrw 0x30a, %0" : : "r" (x)); asm volatile("csrw 0x30a, %0" : : "r"(x));
} }
// Physical Memory Protection // Physical Memory Protection
static inline void riscv_writ_pmpcfg0(uint64_t x) static inline void riscv_writ_pmpcfg0(uint64_t x)
{ {
asm volatile("csrw pmpcfg0, %0" : : "r" (x)); asm volatile("csrw pmpcfg0, %0" : : "r"(x));
} }
static inline void riscv_writ_pmpaddr0(uint64_t x) static inline void riscv_writ_pmpaddr0(uint64_t x)
{ {
asm volatile("csrw pmpaddr0, %0" : : "r" (x)); asm volatile("csrw pmpaddr0, %0" : : "r"(x));
} }
// supervisor address translation and protection; // supervisor address translation and protection;
// holds the address of the page table. // holds the address of the page table.
static inline void riscv_writ_satp(uint64_t x) static inline void riscv_writ_satp(uint64_t x)
{ {
asm volatile("csrw satp, %0" : : "r" (x)); asm volatile("csrw satp, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_satp() static inline uint64_t riscv_get_satp()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, satp" : "=r" (x) ); asm volatile("csrr %0, satp" : "=r"(x));
return x; return x;
} }
// Supervisor Trap Cause // Supervisor Trap Cause
static inline uint64_t riscv_get_scause() static inline uint64_t riscv_get_scause()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, scause" : "=r" (x) ); asm volatile("csrr %0, scause" : "=r"(x));
return x; return x;
} }
// Supervisor Trap Value // Supervisor Trap Value
static inline uint64_t riscv_get_stval() static inline uint64_t riscv_get_stval()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, stval" : "=r" (x) ); asm volatile("csrr %0, stval" : "=r"(x));
return x; return x;
} }
// Machine-mode Counter-Enable // Machine-mode Counter-Enable
static inline void riscv_writ_mcounteren(uint64_t x) static inline void riscv_writ_mcounteren(uint64_t x)
{ {
asm volatile("csrw mcounteren, %0" : : "r" (x)); asm volatile("csrw mcounteren, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_mcounteren() static inline uint64_t riscv_get_mcounteren()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, mcounteren" : "=r" (x) ); asm volatile("csrr %0, mcounteren" : "=r"(x));
return x; return x;
} }
// machine-mode cycle counter // machine-mode cycle counter
static inline uint64_t riscv_get_time() static inline uint64_t riscv_get_time()
{ {
uint64_t x; uint64_t x;
asm volatile("csrr %0, time" : "=r" (x) ); asm volatile("csrr %0, time" : "=r"(x));
return x; return x;
} }
// enable device interrupts // enable device interrupts
static inline void riscv_sintr_on() static inline void riscv_sintr_on()
{ {
uint64_t sstatus = riscv_get_sstatus(); uint64_t sstatus = riscv_get_sstatus();
sstatus |= SSTATUS_SIE; sstatus |= SSTATUS_SIE;
riscv_writ_sstatus(sstatus); riscv_writ_sstatus(sstatus);
} }
// disable device interrupts // disable device interrupts
static inline void riscv_sintr_off() static inline void riscv_sintr_off()
{ {
uint64_t sstatus = riscv_get_sstatus(); uint64_t sstatus = riscv_get_sstatus();
sstatus &= (~SSTATUS_SIE); sstatus &= (~SSTATUS_SIE);
riscv_writ_sstatus(sstatus); riscv_writ_sstatus(sstatus);
} }
// are device interrupts enabled? // are device interrupts enabled?
static inline int riscv_sintr_get() static inline int riscv_sintr_get()
{ {
uint64_t x = riscv_get_sstatus(); uint64_t x = riscv_get_sstatus();
return (x & SSTATUS_SIE) != 0; return (x & SSTATUS_SIE) != 0;
} }
static inline void riscv_sintr_restore(int x) static inline void riscv_sintr_restore(int x)
{ {
if(x) if (x)
riscv_sintr_on(); riscv_sintr_on();
else else
riscv_sintr_off(); riscv_sintr_off();
} }
// enable device interrupts // enable device interrupts
static inline void riscv_mintr_on() static inline void riscv_mintr_on()
{ {
uint64_t mstatus = riscv_get_mstatus(); uint64_t mstatus = riscv_get_mstatus();
mstatus |= MSTATUS_MIE; mstatus |= MSTATUS_MIE;
riscv_writ_mstatus(mstatus); riscv_writ_mstatus(mstatus);
} }
// disable device interrupts // disable device interrupts
static inline void riscv_mintr_off() static inline void riscv_mintr_off()
{ {
uint64_t mstatus = riscv_get_mstatus(); uint64_t mstatus = riscv_get_mstatus();
mstatus &= (~MSTATUS_MIE); mstatus &= (~MSTATUS_MIE);
riscv_writ_mstatus(mstatus); riscv_writ_mstatus(mstatus);
} }
// are device interrupts enabled? // are device interrupts enabled?
static inline int riscv_mintr_get() static inline int riscv_mintr_get()
{ {
uint64_t x = riscv_get_mstatus(); uint64_t x = riscv_get_mstatus();
return (x & MSTATUS_MIE) != 0; return (x & MSTATUS_MIE) != 0;
} }
static inline void riscv_mintr_restore(int x) static inline void riscv_mintr_restore(int x)
{ {
if(x) if (x)
riscv_mintr_on(); riscv_mintr_on();
else else
riscv_mintr_off(); riscv_mintr_off();
} }
static inline uint64_t riscv_get_sp() static inline uint64_t riscv_get_sp()
{ {
uint64_t x; uint64_t x;
asm volatile("mv %0, sp" : "=r" (x) ); asm volatile("mv %0, sp" : "=r"(x));
return x; return x;
} }
// read and write tp, the thread pointer, which xv6 uses to hold // read and write tp, the thread pointer, which xv6 uses to hold
// this core's hartid (core number), the index into cpus[]. // this core's hartid (core number), the index into cpus[].
static inline uint64_t riscv_get_tp() static inline uint64_t riscv_get_tp()
{ {
uint64_t x; uint64_t x;
asm volatile("mv %0, tp" : "=r" (x) ); asm volatile("mv %0, tp" : "=r"(x));
return x; return x;
} }
static inline void riscv_writ_tp(uint64_t x) static inline void riscv_writ_tp(uint64_t x)
{ {
asm volatile("mv tp, %0" : : "r" (x)); asm volatile("mv tp, %0" : : "r"(x));
} }
static inline uint64_t riscv_get_ra() static inline uint64_t riscv_get_ra()
{ {
uint64_t x; uint64_t x;
asm volatile("mv %0, ra" : "=r" (x) ); asm volatile("mv %0, ra" : "=r"(x));
return x; return x;
} }
// flush the TLB. // flush the TLB.
static inline void sfence_vma() static inline void sfence_vma()
{ {
// the zero, zero means flush all TLB entries. // the zero, zero means flush all TLB entries.
asm volatile("sfence.vma zero, zero"); asm volatile("sfence.vma zero, zero");
} }
#endif // __ASSEMBLER__ #endif // __ASSEMBLER__

77
port/threadx/inc/nx_port.h
View File

@@ -64,21 +64,21 @@
/* Define macros that swap the endian for little endian ports. */ /* Define macros that swap the endian for little endian ports. */
#ifdef NX_LITTLE_ENDIAN #ifdef NX_LITTLE_ENDIAN
#define NX_CHANGE_ULONG_ENDIAN(arg) \ #define NX_CHANGE_ULONG_ENDIAN(arg) \
{ \ { \
ULONG _i; \ ULONG _i; \
ULONG _tmp; \ ULONG _tmp; \
_i = (UINT)arg; \ _i = (UINT)arg; \
/* _i = A, B, C, D */ \ /* _i = A, B, C, D */ \
_tmp = _i ^ (((_i) >> 16) | (_i << 16)); \ _tmp = _i ^ (((_i) >> 16) | (_i << 16)); \
/* _tmp = _i ^ (_i ROR 16) = A^C, B^D, C^A, D^B */ \ /* _tmp = _i ^ (_i ROR 16) = A^C, B^D, C^A, D^B */ \
_tmp &= 0xff00ffff; \ _tmp &= 0xff00ffff; \
/* _tmp = A^C, 0, C^A, D^B */ \ /* _tmp = A^C, 0, C^A, D^B */ \
_i = ((_i) >> 8) | (_i << 24); \ _i = ((_i) >> 8) | (_i << 24); \
/* _i = D, A, B, C */ \ /* _i = D, A, B, C */ \
_i = _i ^ ((_tmp) >> 8); \ _i = _i ^ ((_tmp) >> 8); \
/* _i = D, C, B, A */ \ /* _i = D, C, B, A */ \
arg = _i; \ arg = _i; \
} }
#define NX_CHANGE_USHORT_ENDIAN(a) (a = (((a >> 8) | (a << 8)) & 0xFFFF)) #define NX_CHANGE_USHORT_ENDIAN(a) (a = (((a >> 8) | (a << 8)) & 0xFFFF))
@@ -125,49 +125,50 @@
#ifndef TX_TIMER_PROCESS_IN_ISR #ifndef TX_TIMER_PROCESS_IN_ISR
#define NX_CALLER_CHECKING_EXTERNS \ #define NX_CALLER_CHECKING_EXTERNS \
extern TX_THREAD* _tx_thread_current_ptr; \ extern TX_THREAD* _tx_thread_current_ptr; \
extern TX_THREAD _tx_timer_thread; \ extern TX_THREAD _tx_timer_thread; \
extern volatile ULONG TX_THREAD_GET_SYSTEM_STATE(); extern volatile ULONG TX_THREAD_GET_SYSTEM_STATE();
#define NX_THREADS_ONLY_CALLER_CHECKING \ #define NX_THREADS_ONLY_CALLER_CHECKING \
if((TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == TX_NULL) || (_tx_thread_current_ptr == &_tx_timer_thread)) \ if ((TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == TX_NULL) || \
(_tx_thread_current_ptr == &_tx_timer_thread)) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#define NX_INIT_AND_THREADS_CALLER_CHECKING \ #define NX_INIT_AND_THREADS_CALLER_CHECKING \
if(((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0))) || \ if (((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0))) || \
(_tx_thread_current_ptr == &_tx_timer_thread)) \ (_tx_thread_current_ptr == &_tx_timer_thread)) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#define NX_NOT_ISR_CALLER_CHECKING \ #define NX_NOT_ISR_CALLER_CHECKING \
if((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0))) \ if ((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0))) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#define NX_THREAD_WAIT_CALLER_CHECKING \ #define NX_THREAD_WAIT_CALLER_CHECKING \
if((wait_option) && \ if ((wait_option) && ((_tx_thread_current_ptr == NX_NULL) || (TX_THREAD_GET_SYSTEM_STATE()) || \
((_tx_thread_current_ptr == NX_NULL) || (TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == &_tx_timer_thread))) \ (_tx_thread_current_ptr == &_tx_timer_thread))) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#else #else
#define NX_CALLER_CHECKING_EXTERNS \ #define NX_CALLER_CHECKING_EXTERNS \
extern TX_THREAD* _tx_thread_current_ptr; \ extern TX_THREAD* _tx_thread_current_ptr; \
extern volatile ULONG TX_THREAD_GET_SYSTEM_STATE(); extern volatile ULONG TX_THREAD_GET_SYSTEM_STATE();
#define NX_THREADS_ONLY_CALLER_CHECKING \ #define NX_THREADS_ONLY_CALLER_CHECKING \
if((TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == TX_NULL)) \ if ((TX_THREAD_GET_SYSTEM_STATE()) || (_tx_thread_current_ptr == TX_NULL)) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#define NX_INIT_AND_THREADS_CALLER_CHECKING \ #define NX_INIT_AND_THREADS_CALLER_CHECKING \
if(((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0)))) \ if (((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0)))) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#define NX_NOT_ISR_CALLER_CHECKING \ #define NX_NOT_ISR_CALLER_CHECKING \
if((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0))) \ if ((TX_THREAD_GET_SYSTEM_STATE()) && (TX_THREAD_GET_SYSTEM_STATE() < ((ULONG)0xF0F0F0F0))) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#define NX_THREAD_WAIT_CALLER_CHECKING \ #define NX_THREAD_WAIT_CALLER_CHECKING \
if((wait_option) && ((_tx_thread_current_ptr == NX_NULL) || (TX_THREAD_GET_SYSTEM_STATE()))) \ if ((wait_option) && ((_tx_thread_current_ptr == NX_NULL) || (TX_THREAD_GET_SYSTEM_STATE()))) \
return (NX_CALLER_ERROR); return (NX_CALLER_ERROR);
#endif #endif

19
port/threadx/inc/nx_user.h
View File

@@ -62,7 +62,7 @@
/* Define the base exponent of 2 for huge number. /* Define the base exponent of 2 for huge number.
* Only 16 and 32 are supported. */ * Only 16 and 32 are supported. */
#define NX_CRYPTO_HUGE_NUMBER_BITS 32 #define NX_CRYPTO_HUGE_NUMBER_BITS 32
#define NX_DIRECT_ISR_CALL 1 #define NX_DIRECT_ISR_CALL 1
/* Define various build options for the NetX Duo port. The application should either make changes /* Define various build options for the NetX Duo port. The application should either make changes
here by commenting or un-commenting the conditional compilation defined OR supply the defines here by commenting or un-commenting the conditional compilation defined OR supply the defines
though the compiler's equivalent of the -D option. */ though the compiler's equivalent of the -D option. */
@@ -76,7 +76,7 @@
present to NetX Duo IP layer. Physical interface does not include present to NetX Duo IP layer. Physical interface does not include
loopback interface. By default there is at least one physical interface loopback interface. By default there is at least one physical interface
in the system. */ in the system. */
#define NX_MAX_PHYSICAL_INTERFACES 2 #define NX_MAX_PHYSICAL_INTERFACES 2
/* Defined, this option disables NetX Duo support on the 127.0.0.1 loopback interface. /* Defined, this option disables NetX Duo support on the 127.0.0.1 loopback interface.
127.0.0.1 loopback interface is enabled by default. Uncomment out the follow code to disable 127.0.0.1 loopback interface is enabled by default. Uncomment out the follow code to disable
@@ -95,9 +95,9 @@
/* This defines specifies the number of ThreadX timer ticks in one second. The default value is based /* This defines specifies the number of ThreadX timer ticks in one second. The default value is based
on ThreadX timer interrupt. */ on ThreadX timer interrupt. */
#ifdef TX_TIMER_TICKS_PER_SECOND #ifdef TX_TIMER_TICKS_PER_SECOND
#define NX_IP_PERIODIC_RATE TX_TIMER_TICKS_PER_SECOND #define NX_IP_PERIODIC_RATE TX_TIMER_TICKS_PER_SECOND
#else #else
#define NX_IP_PERIODIC_RATE 100 #define NX_IP_PERIODIC_RATE 100
#endif #endif
/* Defined, NX_ENABLE_IP_RAW_PACKET_FILTER allows an application to install a filter /* Defined, NX_ENABLE_IP_RAW_PACKET_FILTER allows an application to install a filter
@@ -430,7 +430,7 @@
/* Automatically define NX_TCP_ACK_EVERY_N_PACKETS to 1 if NX_TCP_IMMEDIATE_ACK is defined. /* Automatically define NX_TCP_ACK_EVERY_N_PACKETS to 1 if NX_TCP_IMMEDIATE_ACK is defined.
This is needed for backward compatibility. */ This is needed for backward compatibility. */
#if(defined(NX_TCP_IMMEDIATE_ACK) && !defined(NX_TCP_ACK_EVERY_N_PACKETS)) #if (defined(NX_TCP_IMMEDIATE_ACK) && !defined(NX_TCP_ACK_EVERY_N_PACKETS))
#define NX_TCP_ACK_EVERY_N_PACKETS 1 #define NX_TCP_ACK_EVERY_N_PACKETS 1
#endif #endif
@@ -765,16 +765,17 @@
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C"
{
#endif #endif
int rand(void); int rand(void);
void srand(unsigned seed); void srand(unsigned seed);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#define NX_RAND rand #define NX_RAND rand
#define NX_SRAND srand #define NX_SRAND srand
#endif #endif

48
port/threadx/inc/tx_port.h
View File

@@ -54,21 +54,21 @@
#ifdef __ASSEMBLER__ #ifdef __ASSEMBLER__
#if __riscv_xlen == 64 #if __riscv_xlen == 64
#define SLL32 sllw #define SLL32 sllw
#define STORE sd #define STORE sd
#define LOAD ld #define LOAD ld
#define LWU lwu #define LWU lwu
#define LOG_REGBYTES 3 #define LOG_REGBYTES 3
#else #else
#define SLL32 sll #define SLL32 sll
#define STORE sw #define STORE sw
#define LOAD lw #define LOAD lw
#define LWU lw #define LWU lw
#define LOG_REGBYTES 2 #define LOG_REGBYTES 2
#endif #endif
#define REGBYTES (1 << LOG_REGBYTES) #define REGBYTES (1 << LOG_REGBYTES)
#define TX_THREAD_STACK_END_OFFSET 2*4 + 2*REGBYTES #define TX_THREAD_STACK_END_OFFSET 2 * 4 + 2 * REGBYTES
#define TX_THREAD_TIME_SLICE_OFFSET 3*4+ 3*REGBYTES #define TX_THREAD_TIME_SLICE_OFFSET 3 * 4 + 3 * REGBYTES
#else /*not __ASSEMBLER__ */ #else /*not __ASSEMBLER__ */
@@ -134,7 +134,7 @@ typedef unsigned short USHORT;
/* Define various constants for the ThreadX RISC-V port. */ /* Define various constants for the ThreadX RISC-V port. */
#define TX_INT_DISABLE 0x00000000 /* Disable interrupts value */ #define TX_INT_DISABLE 0x00000000 /* Disable interrupts value */
#define TX_INT_ENABLE 0x00000008 /* Enable interrupt value */ #define TX_INT_ENABLE 0x00000008 /* Enable interrupt value */
/* Define the clock source for trace event entry time stamp. The following two item are port specific. /* Define the clock source for trace event entry time stamp. The following two item are port specific.
For example, if the time source is at the address 0x0a800024 and is 16-bits in size, the clock For example, if the time source is at the address 0x0a800024 and is 16-bits in size, the clock
@@ -247,25 +247,27 @@ ULONG64 _tx_thread_interrupt_control(unsigned int new_posture);
#define TX_INTERRUPT_SAVE_AREA ULONG64 interrupt_save; #define TX_INTERRUPT_SAVE_AREA ULONG64 interrupt_save;
/* Atomically read mstatus into interrupt_save and clear bit 3 of mstatus. */ /* Atomically read mstatus into interrupt_save and clear bit 3 of mstatus. */
#define TX_DISABLE \ #define TX_DISABLE \
{ __asm__("csrrci %0, mstatus, 0x08" : "=r"(interrupt_save) :); }; { \
__asm__("csrrci %0, mstatus, 0x08" : "=r"(interrupt_save) :); \
};
/* We only care about mstatus.mie (bit 3), so mask interrupt_save and write to mstatus. */ /* We only care about mstatus.mie (bit 3), so mask interrupt_save and write to mstatus. */
#define TX_RESTORE \ #define TX_RESTORE \
{ \ { \
register ULONG64 __tempmask = interrupt_save & 0x08; \ register ULONG64 __tempmask = interrupt_save & 0x08; \
__asm__("csrrs x0, mstatus, %0 \n\t" : : "r"(__tempmask) :); \ __asm__("csrrs x0, mstatus, %0 \n\t" : : "r"(__tempmask) :); \
}; };
#endif #endif
/* Define the interrupt lockout macros for each ThreadX object. */ /* Define the interrupt lockout macros for each ThreadX object. */
#define TX_BLOCK_POOL_DISABLE TX_DISABLE #define TX_BLOCK_POOL_DISABLE TX_DISABLE
#define TX_BYTE_POOL_DISABLE TX_DISABLE #define TX_BYTE_POOL_DISABLE TX_DISABLE
#define TX_EVENT_FLAGS_GROUP_DISABLE TX_DISABLE #define TX_EVENT_FLAGS_GROUP_DISABLE TX_DISABLE
#define TX_MUTEX_DISABLE TX_DISABLE #define TX_MUTEX_DISABLE TX_DISABLE
#define TX_QUEUE_DISABLE TX_DISABLE #define TX_QUEUE_DISABLE TX_DISABLE
#define TX_SEMAPHORE_DISABLE TX_DISABLE #define TX_SEMAPHORE_DISABLE TX_DISABLE
/* Define the version ID of ThreadX. This may be utilized by the application. */ /* Define the version ID of ThreadX. This may be utilized by the application. */

13
port/threadx/inc/tx_user.h
View File

@@ -8,7 +8,6 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
**************************************************************************/ **************************************************************************/
/**************************************************************************/ /**************************************************************************/
/**************************************************************************/ /**************************************************************************/
/** */ /** */
@@ -19,7 +18,6 @@
/**************************************************************************/ /**************************************************************************/
/**************************************************************************/ /**************************************************************************/
/**************************************************************************/ /**************************************************************************/
/* */ /* */
/* PORT SPECIFIC C INFORMATION RELEASE */ /* PORT SPECIFIC C INFORMATION RELEASE */
@@ -71,7 +69,6 @@
#ifndef TX_USER_H #ifndef TX_USER_H
#define TX_USER_H #define TX_USER_H
/* Define various build options for the ThreadX port. The application should either make changes /* Define various build options for the ThreadX port. The application should either make changes
here by commenting or un-commenting the conditional compilation defined OR supply the defines here by commenting or un-commenting the conditional compilation defined OR supply the defines
though the compiler's equivalent of the -D option. though the compiler's equivalent of the -D option.
@@ -105,7 +102,6 @@
therefore return an error if this option is used. This may or may not be desirable for a therefore return an error if this option is used. This may or may not be desirable for a
given application. */ given application. */
/* Override various options with default values already assigned in tx_port.h. Please also refer /* Override various options with default values already assigned in tx_port.h. Please also refer
to tx_port.h for descriptions on each of these options. */ to tx_port.h for descriptions on each of these options. */
@@ -129,9 +125,7 @@
version in tx_port.h or here. version in tx_port.h or here.
Note: the actual hardware timer value may need to be changed (usually in tx_initialize_low_level). */ Note: the actual hardware timer value may need to be changed (usually in tx_initialize_low_level). */
#define TX_TIMER_TICKS_PER_SECOND (100) // for moonlight with 32,7kHz Frequency (divided by 1000)
#define TX_TIMER_TICKS_PER_SECOND (100) // for moonlight with 32,7kHz Frequency (divided by 1000)
/* Determine if there is a FileX pointer in the thread control block. /* Determine if there is a FileX pointer in the thread control block.
By default, the pointer is there for legacy/backwards compatibility. By default, the pointer is there for legacy/backwards compatibility.
@@ -225,7 +219,6 @@
#define TX_DISABLE_NOTIFY_CALLBACKS #define TX_DISABLE_NOTIFY_CALLBACKS
*/ */
/* Determine if the tx_thread_resume and tx_thread_suspend services should have their internal /* Determine if the tx_thread_resume and tx_thread_suspend services should have their internal
code in-line. This results in a larger image, but improves the performance of the thread code in-line. This results in a larger image, but improves the performance of the thread
resume and suspend services. */ resume and suspend services. */
@@ -234,7 +227,6 @@
#define TX_INLINE_THREAD_RESUME_SUSPEND #define TX_INLINE_THREAD_RESUME_SUSPEND
*/ */
/* Determine if the internal ThreadX code is non-interruptable. This results in smaller code /* Determine if the internal ThreadX code is non-interruptable. This results in smaller code
size and less processing overhead, but increases the interrupt lockout time. */ size and less processing overhead, but increases the interrupt lockout time. */
@@ -242,7 +234,6 @@
#define TX_NOT_INTERRUPTABLE #define TX_NOT_INTERRUPTABLE
*/ */
/* Determine if the trace event logging code should be enabled. This causes slight increases in /* Determine if the trace event logging code should be enabled. This causes slight increases in
code size and overhead, but provides the ability to generate system trace information which code size and overhead, but provides the ability to generate system trace information which
is available for viewing in TraceX. */ is available for viewing in TraceX. */
@@ -251,7 +242,6 @@
#define TX_ENABLE_EVENT_TRACE #define TX_ENABLE_EVENT_TRACE
*/ */
/* Determine if block pool performance gathering is required by the application. When the following is /* Determine if block pool performance gathering is required by the application. When the following is
defined, ThreadX gathers various block pool performance information. */ defined, ThreadX gathers various block pool performance information. */
@@ -321,4 +311,3 @@
*/ */
#endif #endif

146
src/tcp_demo/main.c
View File

@@ -7,9 +7,9 @@
#include "tx_api.h" #include "tx_api.h"
#include <stdio.h> #include <stdio.h>
#define DEMO_STACK_SIZE 2048 #define DEMO_STACK_SIZE 2048
#define DEMO_DATA "ABCDEFGHIJKLMNOPQRSTUVWXYZ " #define DEMO_DATA "ABCDEFGHIJKLMNOPQRSTUVWXYZ "
#define PACKET_SIZE 1536 #define PACKET_SIZE 1536
#define POOL_SIZE ((sizeof(NX_PACKET) + PACKET_SIZE) * 8) #define POOL_SIZE ((sizeof(NX_PACKET) + PACKET_SIZE) * 8)
#define NX_DISABLE_IPV6 #define NX_DISABLE_IPV6
/* Define the ThreadX and NetX object control blocks... */ /* Define the ThreadX and NetX object control blocks... */
@@ -44,13 +44,15 @@ void _nx_mnrs_network_driver(struct NX_IP_DRIVER_STRUCT* driver_req);
/* Define main entry point. */ /* Define main entry point. */
int main() { int main()
/* Enter the ThreadX kernel. */ {
/* Enter the ThreadX kernel. */
tx_kernel_enter(); tx_kernel_enter();
} }
/* Define what the initial system looks like. */ /* Define what the initial system looks like. */
void tx_application_define(void* first_unused_memory) { void tx_application_define(void* first_unused_memory)
{
CHAR* pointer; CHAR* pointer;
UINT status; UINT status;
puts("Setting up application"); puts("Setting up application");
@@ -58,12 +60,14 @@ void tx_application_define(void* first_unused_memory) {
pointer = (CHAR*)first_unused_memory; pointer = (CHAR*)first_unused_memory;
/* Create the main thread. */ /* Create the main thread. */
tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(
&thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
pointer = pointer + DEMO_STACK_SIZE; pointer = pointer + DEMO_STACK_SIZE;
/* Create the main thread. */ /* Create the main thread. */
tx_thread_create(&thread_1, "thread 1", thread_1_entry, 0, pointer, DEMO_STACK_SIZE, 3, 3, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(
&thread_1, "thread 1", thread_1_entry, 0, pointer, DEMO_STACK_SIZE, 3, 3, TX_NO_TIME_SLICE, TX_AUTO_START);
pointer = pointer + DEMO_STACK_SIZE; pointer = pointer + DEMO_STACK_SIZE;
@@ -73,24 +77,28 @@ void tx_application_define(void* first_unused_memory) {
/* Create a packet pool. */ /* Create a packet pool. */
status = nx_packet_pool_create(&pool_0, "packet_pool0", PACKET_SIZE, pool_buffer, POOL_SIZE); status = nx_packet_pool_create(&pool_0, "packet_pool0", PACKET_SIZE, pool_buffer, POOL_SIZE);
if(status) { if (status)
{
error_counter++; error_counter++;
} }
/* Create an IP instance. */ /* Create an IP instance. */
status = nx_ip_create(&ip_0, "eth0", IP_ADDRESS(1, 2, 3, 4), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1); status =
nx_ip_create(&ip_0, "eth0", IP_ADDRESS(1, 2, 3, 4), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1);
pointer = pointer + 2048; pointer = pointer + 2048;
/* Create another IP instance. */ /* Create another IP instance. */
status += nx_ip_create(&ip_1, "eth1", IP_ADDRESS(1, 2, 3, 5), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1); status +=
nx_ip_create(&ip_1, "eth1", IP_ADDRESS(1, 2, 3, 5), 0xFFFFFF00UL, &pool_0, NETWORK_DRIVER, pointer, 2048, 1);
pointer = pointer + 2048; pointer = pointer + 2048;
if(status) { if (status)
{
error_counter++; error_counter++;
} }
/* Enable ARP and supply ARP cache memory for IP Instance 0. */ /* Enable ARP and supply ARP cache memory for IP Instance 0. */
status = nx_arp_enable(&ip_0, (void*)pointer, 1024); status = nx_arp_enable(&ip_0, (void*)pointer, 1024);
pointer = pointer + 1024; pointer = pointer + 1024;
/* Enable ARP and supply ARP cache memory for IP Instance 1. */ /* Enable ARP and supply ARP cache memory for IP Instance 1. */
@@ -98,18 +106,21 @@ void tx_application_define(void* first_unused_memory) {
pointer = pointer + 1024; pointer = pointer + 1024;
/* Check ARP enable status. */ /* Check ARP enable status. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
/* Enable ICMP */ /* Enable ICMP */
status = nxd_icmp_enable(&ip_0); status = nxd_icmp_enable(&ip_0);
if(status) { if (status)
{
error_counter++; error_counter++;
} }
status = nxd_icmp_enable(&ip_1); status = nxd_icmp_enable(&ip_1);
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -122,7 +133,8 @@ void tx_application_define(void* first_unused_memory) {
/* Define the test threads. */ /* Define the test threads. */
void thread_0_entry(ULONG thread_input) { void thread_0_entry(ULONG thread_input)
{
UINT status; UINT status;
NX_PACKET* my_packet; NX_PACKET* my_packet;
@@ -138,18 +150,27 @@ void thread_0_entry(ULONG thread_input) {
tx_thread_sleep(/* NX_IP_PERIODIC_RATE */ 10); tx_thread_sleep(/* NX_IP_PERIODIC_RATE */ 10);
/* set the TCP server addresses. */ /* set the TCP server addresses. */
server_ipv4_address.nxd_ip_version = NX_IP_VERSION_V4; server_ipv4_address.nxd_ip_version = NX_IP_VERSION_V4;
server_ipv4_address.nxd_ip_address.v4 = IP_ADDRESS(1, 2, 3, 5); server_ipv4_address.nxd_ip_address.v4 = IP_ADDRESS(1, 2, 3, 5);
/* Loop to repeat things over and over again! */ /* Loop to repeat things over and over again! */
puts("Entering client loop"); puts("Entering client loop");
while(1) { while (1)
{
/* Create a socket. */ /* Create a socket. */
status = nx_tcp_socket_create(&ip_0, &client_socket, "Client Socket", NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 200, status = nx_tcp_socket_create(&ip_0,
NX_NULL, NX_NULL); &client_socket,
"Client Socket",
NX_IP_NORMAL,
NX_FRAGMENT_OKAY,
NX_IP_TIME_TO_LIVE,
200,
NX_NULL,
NX_NULL);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -157,7 +178,8 @@ void thread_0_entry(ULONG thread_input) {
status = nx_tcp_client_socket_bind(&client_socket, 12, NX_WAIT_FOREVER); status = nx_tcp_client_socket_bind(&client_socket, 12, NX_WAIT_FOREVER);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -165,7 +187,8 @@ void thread_0_entry(ULONG thread_input) {
status = nxd_tcp_client_socket_connect(&client_socket, &server_ipv4_address, 12, NX_IP_PERIODIC_RATE); status = nxd_tcp_client_socket_connect(&client_socket, &server_ipv4_address, 12, NX_IP_PERIODIC_RATE);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
printf("Error with socket connect: 0x%x\n", status); printf("Error with socket connect: 0x%x\n", status);
return; return;
} }
@@ -176,7 +199,8 @@ void thread_0_entry(ULONG thread_input) {
status = nx_packet_allocate(&pool_0, &my_packet, NX_TCP_PACKET, NX_WAIT_FOREVER); status = nx_packet_allocate(&pool_0, &my_packet, NX_TCP_PACKET, NX_WAIT_FOREVER);
/* Check status. */ /* Check status. */
if(status != NX_SUCCESS) { if (status != NX_SUCCESS)
{
break; break;
} }
@@ -184,7 +208,8 @@ void thread_0_entry(ULONG thread_input) {
nx_packet_data_append(my_packet, DEMO_DATA, sizeof(DEMO_DATA), &pool_0, TX_WAIT_FOREVER); nx_packet_data_append(my_packet, DEMO_DATA, sizeof(DEMO_DATA), &pool_0, TX_WAIT_FOREVER);
status = nx_packet_length_get(my_packet, &length); status = nx_packet_length_get(my_packet, &length);
if((status) || (length != sizeof(DEMO_DATA))) { if ((status) || (length != sizeof(DEMO_DATA)))
{
error_counter++; error_counter++;
} }
@@ -192,7 +217,8 @@ void thread_0_entry(ULONG thread_input) {
status = nx_tcp_socket_send(&client_socket, my_packet, NX_IP_PERIODIC_RATE); status = nx_tcp_socket_send(&client_socket, my_packet, NX_IP_PERIODIC_RATE);
/* Determine if the status is valid. */ /* Determine if the status is valid. */
if(status) { if (status)
{
error_counter++; error_counter++;
nx_packet_release(my_packet); nx_packet_release(my_packet);
} }
@@ -201,7 +227,8 @@ void thread_0_entry(ULONG thread_input) {
status = nx_tcp_socket_disconnect(&client_socket, NX_IP_PERIODIC_RATE); status = nx_tcp_socket_disconnect(&client_socket, NX_IP_PERIODIC_RATE);
/* Determine if the status is valid. */ /* Determine if the status is valid. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -209,7 +236,8 @@ void thread_0_entry(ULONG thread_input) {
status = nx_tcp_client_socket_unbind(&client_socket); status = nx_tcp_client_socket_unbind(&client_socket);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -217,7 +245,8 @@ void thread_0_entry(ULONG thread_input) {
status = nx_tcp_socket_delete(&client_socket); status = nx_tcp_socket_delete(&client_socket);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -226,7 +255,8 @@ void thread_0_entry(ULONG thread_input) {
} }
} }
void thread_1_entry(ULONG thread_input) { void thread_1_entry(ULONG thread_input)
{
UINT status; UINT status;
NX_PACKET* packet_ptr; NX_PACKET* packet_ptr;
@@ -241,18 +271,27 @@ void thread_1_entry(ULONG thread_input) {
status = nx_ip_status_check(&ip_1, NX_IP_INITIALIZE_DONE, &actual_status, NX_IP_PERIODIC_RATE); status = nx_ip_status_check(&ip_1, NX_IP_INITIALIZE_DONE, &actual_status, NX_IP_PERIODIC_RATE);
/* Check status... */ /* Check status... */
if(status != NX_SUCCESS) { if (status != NX_SUCCESS)
{
error_counter++; error_counter++;
return; return;
} }
/* Create a socket. */ /* Create a socket. */
status = nx_tcp_socket_create(&ip_1, &server_socket, "Server Socket", NX_IP_NORMAL, NX_FRAGMENT_OKAY, NX_IP_TIME_TO_LIVE, 100, NX_NULL, status = nx_tcp_socket_create(&ip_1,
thread_1_disconnect_received); &server_socket,
"Server Socket",
NX_IP_NORMAL,
NX_FRAGMENT_OKAY,
NX_IP_TIME_TO_LIVE,
100,
NX_NULL,
thread_1_disconnect_received);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -260,13 +299,15 @@ void thread_1_entry(ULONG thread_input) {
status = nx_tcp_server_socket_listen(&ip_1, 12, &server_socket, 5, thread_1_connect_received); status = nx_tcp_server_socket_listen(&ip_1, 12, &server_socket, 5, thread_1_connect_received);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
/* Loop to create and establish server connections. */ /* Loop to create and establish server connections. */
puts("Entering server loop"); puts("Entering server loop");
while(1) { while (1)
{
/* Increment thread 1's counter. */ /* Increment thread 1's counter. */
thread_1_counter++; thread_1_counter++;
@@ -275,7 +316,8 @@ void thread_1_entry(ULONG thread_input) {
status = nx_tcp_server_socket_accept(&server_socket, NX_WAIT_FOREVER); status = nx_tcp_server_socket_accept(&server_socket, NX_WAIT_FOREVER);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -283,9 +325,12 @@ void thread_1_entry(ULONG thread_input) {
status = nx_tcp_socket_receive(&server_socket, &packet_ptr, NX_IP_PERIODIC_RATE); status = nx_tcp_socket_receive(&server_socket, &packet_ptr, NX_IP_PERIODIC_RATE);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} else { }
else
{
char buffer[64]; char buffer[64];
ULONG size; ULONG size;
nx_packet_data_extract_offset(packet_ptr, 0, buffer, 64, &size); nx_packet_data_extract_offset(packet_ptr, 0, buffer, 64, &size);
@@ -299,7 +344,8 @@ void thread_1_entry(ULONG thread_input) {
status = nx_tcp_socket_disconnect(&server_socket, NX_IP_PERIODIC_RATE); status = nx_tcp_socket_disconnect(&server_socket, NX_IP_PERIODIC_RATE);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -307,7 +353,8 @@ void thread_1_entry(ULONG thread_input) {
status = nx_tcp_server_socket_unaccept(&server_socket); status = nx_tcp_server_socket_unaccept(&server_socket);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
@@ -315,24 +362,29 @@ void thread_1_entry(ULONG thread_input) {
status = nx_tcp_server_socket_relisten(&ip_1, 12, &server_socket); status = nx_tcp_server_socket_relisten(&ip_1, 12, &server_socket);
/* Check for error. */ /* Check for error. */
if(status) { if (status)
{
error_counter++; error_counter++;
} }
} }
} }
void thread_1_connect_received(NX_TCP_SOCKET* socket_ptr, UINT port) { void thread_1_connect_received(NX_TCP_SOCKET* socket_ptr, UINT port)
{
/* Check for the proper socket and port. */ /* Check for the proper socket and port. */
if((socket_ptr != &server_socket) || (port != 12)) { if ((socket_ptr != &server_socket) || (port != 12))
{
error_counter++; error_counter++;
} }
} }
void thread_1_disconnect_received(NX_TCP_SOCKET* socket) { void thread_1_disconnect_received(NX_TCP_SOCKET* socket)
{
/* Check for proper disconnected socket. */ /* Check for proper disconnected socket. */
if(socket != &server_socket) { if (socket != &server_socket)
{
error_counter++; error_counter++;
} }
} }

122
src/thread_demo/main.c
View File

@@ -5,10 +5,10 @@
#include "tx_api.h" #include "tx_api.h"
#include <stdio.h> #include <stdio.h>
#define DEMO_STACK_SIZE 1024 #define DEMO_STACK_SIZE 1024
#define DEMO_BYTE_POOL_SIZE 9120 #define DEMO_BYTE_POOL_SIZE 9120
#define DEMO_BLOCK_POOL_SIZE 100 #define DEMO_BLOCK_POOL_SIZE 100
#define DEMO_QUEUE_SIZE 50 #define DEMO_QUEUE_SIZE 50
/* Define the ThreadX object control blocks... */ /* Define the ThreadX object control blocks... */
@@ -51,14 +51,16 @@ void thread_5_entry(ULONG thread_input);
void thread_6_and_7_entry(ULONG thread_input); void thread_6_and_7_entry(ULONG thread_input);
/* Define main entry point. */ /* Define main entry point. */
int main() { int main()
{
/* Enter the ThreadX kernel. */ /* Enter the ThreadX kernel. */
tx_kernel_enter(); tx_kernel_enter();
} }
/* Define what the initial system looks like. */ /* Define what the initial system looks like. */
void tx_application_define(void* first_unused_memory) { void tx_application_define(void* first_unused_memory)
{
CHAR* pointer = TX_NULL; CHAR* pointer = TX_NULL;
@@ -72,7 +74,8 @@ void tx_application_define(void* first_unused_memory) {
tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT); tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
/* Create the main thread. */ /* Create the main thread. */
tx_thread_create(&thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 1, 1, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(
&thread_0, "thread 0", thread_0_entry, 0, pointer, DEMO_STACK_SIZE, 1, 1, TX_NO_TIME_SLICE, TX_AUTO_START);
/* Allocate the stack for thread 1. */ /* Allocate the stack for thread 1. */
tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT); tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
@@ -93,30 +96,67 @@ void tx_application_define(void* first_unused_memory) {
/* Create threads 3 and 4. These threads compete for a ThreadX counting /* Create threads 3 and 4. These threads compete for a ThreadX counting
semaphore. An interesting thing here is that both threads share the same semaphore. An interesting thing here is that both threads share the same
instruction area. */ instruction area. */
tx_thread_create(&thread_3, "thread 3", thread_3_and_4_entry, 3, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(&thread_3,
"thread 3",
thread_3_and_4_entry,
3,
pointer,
DEMO_STACK_SIZE,
8,
8,
TX_NO_TIME_SLICE,
TX_AUTO_START);
/* Allocate the stack for thread 4. */ /* Allocate the stack for thread 4. */
tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT); tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
tx_thread_create(&thread_4, "thread 4", thread_3_and_4_entry, 4, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(&thread_4,
"thread 4",
thread_3_and_4_entry,
4,
pointer,
DEMO_STACK_SIZE,
8,
8,
TX_NO_TIME_SLICE,
TX_AUTO_START);
/* Allocate the stack for thread 5. */ /* Allocate the stack for thread 5. */
tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT); tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
/* Create thread 5. This thread simply pends on an event flag which will be /* Create thread 5. This thread simply pends on an event flag which will be
set by thread_0. */ set by thread_0. */
tx_thread_create(&thread_5, "thread 5", thread_5_entry, 5, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(
&thread_5, "thread 5", thread_5_entry, 5, pointer, DEMO_STACK_SIZE, 4, 4, TX_NO_TIME_SLICE, TX_AUTO_START);
/* Allocate the stack for thread 6. */ /* Allocate the stack for thread 6. */
tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT); tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
/* Create threads 6 and 7. These threads compete for a ThreadX mutex. */ /* Create threads 6 and 7. These threads compete for a ThreadX mutex. */
tx_thread_create(&thread_6, "thread 6", thread_6_and_7_entry, 6, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(&thread_6,
"thread 6",
thread_6_and_7_entry,
6,
pointer,
DEMO_STACK_SIZE,
8,
8,
TX_NO_TIME_SLICE,
TX_AUTO_START);
/* Allocate the stack for thread 7. */ /* Allocate the stack for thread 7. */
tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT); tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_STACK_SIZE, TX_NO_WAIT);
tx_thread_create(&thread_7, "thread 7", thread_6_and_7_entry, 7, pointer, DEMO_STACK_SIZE, 8, 8, TX_NO_TIME_SLICE, TX_AUTO_START); tx_thread_create(&thread_7,
"thread 7",
thread_6_and_7_entry,
7,
pointer,
DEMO_STACK_SIZE,
8,
8,
TX_NO_TIME_SLICE,
TX_AUTO_START);
/* Allocate the message queue. */ /* Allocate the message queue. */
tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_QUEUE_SIZE * sizeof(ULONG), TX_NO_WAIT); tx_byte_allocate(&byte_pool_0, (VOID**)&pointer, DEMO_QUEUE_SIZE * sizeof(ULONG), TX_NO_WAIT);
@@ -148,12 +188,14 @@ void tx_application_define(void* first_unused_memory) {
/* Define the test threads. */ /* Define the test threads. */
void thread_0_entry(ULONG thread_input) { void thread_0_entry(ULONG thread_input)
{
UINT status; UINT status;
/* This thread simply sits in while-forever-sleep loop. */ /* This thread simply sits in while-forever-sleep loop. */
while(1) { while (1)
{
puts("[Thread] : thread_0_entry is here!"); puts("[Thread] : thread_0_entry is here!");
/* Increment the thread counter. */ /* Increment the thread counter. */
thread_0_counter++; thread_0_counter++;
@@ -165,17 +207,19 @@ void thread_0_entry(ULONG thread_input) {
status = tx_event_flags_set(&event_flags_0, 0x1, TX_OR); status = tx_event_flags_set(&event_flags_0, 0x1, TX_OR);
/* Check status. */ /* Check status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
} }
} }
void thread_1_entry(ULONG thread_input) { void thread_1_entry(ULONG thread_input)
{
UINT status; UINT status;
/* This thread simply sends messages to a queue shared by thread 2. */ /* This thread simply sends messages to a queue shared by thread 2. */
while(1) { while (1)
{
/* Increment the thread counter. */ /* Increment the thread counter. */
thread_1_counter++; thread_1_counter++;
@@ -183,7 +227,7 @@ void thread_1_entry(ULONG thread_input) {
status = tx_queue_send(&queue_0, &thread_1_messages_sent, TX_WAIT_FOREVER); status = tx_queue_send(&queue_0, &thread_1_messages_sent, TX_WAIT_FOREVER);
/* Check completion status. */ /* Check completion status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
/* Increment the message sent. */ /* Increment the message sent. */
@@ -192,13 +236,15 @@ void thread_1_entry(ULONG thread_input) {
} }
} }
void thread_2_entry(ULONG thread_input) { void thread_2_entry(ULONG thread_input)
{
ULONG received_message; ULONG received_message;
UINT status; UINT status;
/* This thread retrieves messages placed on the queue by thread 1. */ /* This thread retrieves messages placed on the queue by thread 1. */
while(1) { while (1)
{
/* Increment the thread counter. */ /* Increment the thread counter. */
thread_2_counter++; thread_2_counter++;
@@ -208,7 +254,7 @@ void thread_2_entry(ULONG thread_input) {
/* Check completion status and make sure the message is what we /* Check completion status and make sure the message is what we
expected. */ expected. */
if((status != TX_SUCCESS) || (received_message != thread_2_messages_received)) if ((status != TX_SUCCESS) || (received_message != thread_2_messages_received))
break; break;
/* Otherwise, all is okay. Increment the received message count. */ /* Otherwise, all is okay. Increment the received message count. */
@@ -216,17 +262,19 @@ void thread_2_entry(ULONG thread_input) {
} }
} }
void thread_3_and_4_entry(ULONG thread_input) { void thread_3_and_4_entry(ULONG thread_input)
{
UINT status; UINT status;
/* This function is executed from thread 3 and thread 4. As the loop /* This function is executed from thread 3 and thread 4. As the loop
below shows, these function compete for ownership of semaphore_0. */ below shows, these function compete for ownership of semaphore_0. */
while(1) { while (1)
{
puts("[Thread] : thread_3_and_4_entry is here!"); puts("[Thread] : thread_3_and_4_entry is here!");
/* Increment the thread counter. */ /* Increment the thread counter. */
if(thread_input == 3) if (thread_input == 3)
thread_3_counter++; thread_3_counter++;
else else
thread_4_counter++; thread_4_counter++;
@@ -235,7 +283,7 @@ void thread_3_and_4_entry(ULONG thread_input) {
status = tx_semaphore_get(&semaphore_0, TX_WAIT_FOREVER); status = tx_semaphore_get(&semaphore_0, TX_WAIT_FOREVER);
/* Check status. */ /* Check status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
/* Sleep for 2 ticks to hold the semaphore. */ /* Sleep for 2 ticks to hold the semaphore. */
@@ -245,18 +293,20 @@ void thread_3_and_4_entry(ULONG thread_input) {
status = tx_semaphore_put(&semaphore_0); status = tx_semaphore_put(&semaphore_0);
/* Check status. */ /* Check status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
} }
} }
void thread_5_entry(ULONG thread_input) { void thread_5_entry(ULONG thread_input)
{
UINT status; UINT status;
ULONG actual_flags; ULONG actual_flags;
/* This thread simply waits for an event in a forever loop. */ /* This thread simply waits for an event in a forever loop. */
while(1) { while (1)
{
puts("[Thread] : thread_5_entry is here!"); puts("[Thread] : thread_5_entry is here!");
/* Increment the thread counter. */ /* Increment the thread counter. */
thread_5_counter++; thread_5_counter++;
@@ -265,21 +315,23 @@ void thread_5_entry(ULONG thread_input) {
status = tx_event_flags_get(&event_flags_0, 0x1, TX_OR_CLEAR, &actual_flags, TX_WAIT_FOREVER); status = tx_event_flags_get(&event_flags_0, 0x1, TX_OR_CLEAR, &actual_flags, TX_WAIT_FOREVER);
/* Check status. */ /* Check status. */
if((status != TX_SUCCESS) || (actual_flags != 0x1)) if ((status != TX_SUCCESS) || (actual_flags != 0x1))
break; break;
} }
} }
void thread_6_and_7_entry(ULONG thread_input) { void thread_6_and_7_entry(ULONG thread_input)
{
UINT status; UINT status;
/* This function is executed from thread 6 and thread 7. As the loop /* This function is executed from thread 6 and thread 7. As the loop
below shows, these function compete for ownership of mutex_0. */ below shows, these function compete for ownership of mutex_0. */
while(1) { while (1)
{
puts("[Thread] : thread_6_and_7_entry is here!"); puts("[Thread] : thread_6_and_7_entry is here!");
/* Increment the thread counter. */ /* Increment the thread counter. */
if(thread_input == 6) if (thread_input == 6)
thread_6_counter++; thread_6_counter++;
else else
thread_7_counter++; thread_7_counter++;
@@ -288,7 +340,7 @@ void thread_6_and_7_entry(ULONG thread_input) {
status = tx_mutex_get(&mutex_0, TX_WAIT_FOREVER); status = tx_mutex_get(&mutex_0, TX_WAIT_FOREVER);
/* Check status. */ /* Check status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
/* Get the mutex again with suspension. This shows /* Get the mutex again with suspension. This shows
@@ -297,7 +349,7 @@ void thread_6_and_7_entry(ULONG thread_input) {
status = tx_mutex_get(&mutex_0, TX_WAIT_FOREVER); status = tx_mutex_get(&mutex_0, TX_WAIT_FOREVER);
/* Check status. */ /* Check status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
/* Sleep for 2 ticks to hold the mutex. */ /* Sleep for 2 ticks to hold the mutex. */
@@ -307,7 +359,7 @@ void thread_6_and_7_entry(ULONG thread_input) {
status = tx_mutex_put(&mutex_0); status = tx_mutex_put(&mutex_0);
/* Check status. */ /* Check status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
/* Release the mutex again. This will actually /* Release the mutex again. This will actually
@@ -315,7 +367,7 @@ void thread_6_and_7_entry(ULONG thread_input) {
status = tx_mutex_put(&mutex_0); status = tx_mutex_put(&mutex_0);
/* Check status. */ /* Check status. */
if(status != TX_SUCCESS) if (status != TX_SUCCESS)
break; break;
} }
} }