OpenCores
URL https://opencores.org/ocsvn/neorv32/neorv32/trunk

Subversion Repositories neorv32

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /neorv32/trunk/sw/lib
    from Rev 61 to Rev 62
    ↔ Reverse comparison
  •

Rev 61 → Rev 62

/include/neorv32.h
68,6 → 68,8
CSR_MTVEC = 0x305, /**< 0x305 - mtvec (r/w): Machine trap-handler base address (for ALL traps) */
CSR_MCOUNTEREN = 0x306, /**< 0x305 - mcounteren (r/w): Machine counter enable register (controls access rights from U-mode) */
 
CSR_MSTATUSH = 0x310, /**< 0x310 - mstatush (r/h): Machine status register - high word */
 
CSR_MCOUNTINHIBIT = 0x320, /**< 0x320 - mcountinhibit (r/w): Machine counter-inhibit register */
 
CSR_MHPMEVENT3 = 0x323, /**< 0x323 - mhpmevent3 (r/w): Machine hardware performance monitor event selector 3 */
262,10 → 264,11
CSR_TIMEH = 0xc81, /**< 0xc81 - timeh (r/-): Timer high word (from MTIME.TIME_HI) */
CSR_INSTRETH = 0xc82, /**< 0xc82 - instreth (r/-): Instructions-retired counter high word (from MINSTRETH) */
 
CSR_MVENDORID = 0xf11, /**< 0xf11 - mvendorid (r/-): Vendor ID */
CSR_MARCHID = 0xf12, /**< 0xf12 - marchid (r/-): Architecture ID */
CSR_MIMPID = 0xf13, /**< 0xf13 - mimpid (r/-): Implementation ID/version */
CSR_MHARTID = 0xf14, /**< 0xf14 - mhartid (r/-): Hardware thread ID (always 0) */
CSR_MVENDORID = 0xf11, /**< 0xf11 - mvendorid (r/-): Vendor ID */
CSR_MARCHID = 0xf12, /**< 0xf12 - marchid (r/-): Architecture ID */
CSR_MIMPID = 0xf13, /**< 0xf13 - mimpid (r/-): Implementation ID/version */
CSR_MHARTID = 0xf14, /**< 0xf14 - mhartid (r/-): Hardware thread ID (always 0) */
CSR_MCONFIGPTR = 0xf15, /**< 0xf15 - mconfigptr (r/-): Machine configuration pointer register */
 
CSR_MZEXT = 0xfc0 /**< 0xfc0 - mzext (custom CSR) (r/-): Available Z* CPU extensions */
};
278,7 → 281,11
CSR_MSTATUS_MIE = 3, /**< CPU mstatus CSR (3): MIE - Machine interrupt enable bit (r/w) */
CSR_MSTATUS_MPIE = 7, /**< CPU mstatus CSR (7): MPIE - Machine previous interrupt enable bit (r/w) */
CSR_MSTATUS_MPP_L = 11, /**< CPU mstatus CSR (11): MPP_L - Machine previous privilege mode bit low (r/w) */
CSR_MSTATUS_MPP_H = 12 /**< CPU mstatus CSR (12): MPP_H - Machine previous privilege mode bit high (r/w) */
CSR_MSTATUS_MPP_H = 12, /**< CPU mstatus CSR (12): MPP_H - Machine previous privilege mode bit high (r/w) */
CSR_MSTATUS_FS_L = 13, /**< CPU mstatus CSR (13): FS_L - FPU state bit low (r/w) */
CSR_MSTATUS_FS_H = 14, /**< CPU mstatus CSR (14): FS_H - FPU state bit high (r/w) */
CSR_MSTATUS_TW = 21, /**< CPU mstatus CSR (21): TW - timeout wait (trigger illegal instruction exception if WFI is executed outside of m-mode when set) (r/w) */
CSR_MSTATUS_SD = 31 /**< CPU mstatus CSR (31): SD - extension's state summary (set = non-clean) (r/-) */
};
 
 
685,63 → 692,88
#define SLINK_SIZE (16*4) // /**< SLINK address space size in bytes */
 
/** SLINK control register (r/w) */
#define SLINK_CT (*(IO_REG32 (SLINK_BASE + 0))) // r/w: control register
#define SLINK_CT (*(IO_REG32 (SLINK_BASE + 0))) // r/w: control register
/** SLINK status register (r/-) */
#define SLINK_STATUS (*(IO_REG32 (SLINK_BASE + 16))) // r/-: status register
/** stream link 0 (r/w) */
#define SLINK_CH0 (*(IO_REG32 (SLINK_BASE + 32 + 0))) // r/w: link 0
#define SLINK_CH0 (*(IO_REG32 (SLINK_BASE + 32 + 0))) // r/w: link 0
/** stream link 1 (r/w) */
#define SLINK_CH1 (*(IO_REG32 (SLINK_BASE + 32 + 4))) // r/w: link 1
#define SLINK_CH1 (*(IO_REG32 (SLINK_BASE + 32 + 4))) // r/w: link 1
/** stream link 2 (r/w) */
#define SLINK_CH2 (*(IO_REG32 (SLINK_BASE + 32 + 8))) // r/w: link 2
#define SLINK_CH2 (*(IO_REG32 (SLINK_BASE + 32 + 8))) // r/w: link 2
/** stream link 3 (r/w) */
#define SLINK_CH3 (*(IO_REG32 (SLINK_BASE + 32 + 12))) // r/w: link 3
#define SLINK_CH3 (*(IO_REG32 (SLINK_BASE + 32 + 12))) // r/w: link 3
/** stream link 4 (r/w) */
#define SLINK_CH4 (*(IO_REG32 (SLINK_BASE + 32 + 16))) // r/w: link 4
#define SLINK_CH4 (*(IO_REG32 (SLINK_BASE + 32 + 16))) // r/w: link 4
/** stream link 5 (r/w) */
#define SLINK_CH5 (*(IO_REG32 (SLINK_BASE + 32 + 20))) // r/w: link 5
#define SLINK_CH5 (*(IO_REG32 (SLINK_BASE + 32 + 20))) // r/w: link 5
/** stream link 6 (r/w) */
#define SLINK_CH6 (*(IO_REG32 (SLINK_BASE + 32 + 24))) // r/w: link 6
#define SLINK_CH6 (*(IO_REG32 (SLINK_BASE + 32 + 24))) // r/w: link 6
/** stream link 7 (r/w) */
#define SLINK_CH7 (*(IO_REG32 (SLINK_BASE + 32 + 28))) // r/w: link 7
#define SLINK_CH7 (*(IO_REG32 (SLINK_BASE + 32 + 28))) // r/w: link 7
 
/** SLINK control register bits */
enum NEORV32_SLINK_CT_enum {
SLINK_CT_RX0_AVAIL = 0, /**< SLINK control register(0) (r/-): RX link 0 data available */
SLINK_CT_RX1_AVAIL = 1, /**< SLINK control register(1) (r/-): RX link 1 data available */
SLINK_CT_RX2_AVAIL = 2, /**< SLINK control register(2) (r/-): RX link 2 data available */
SLINK_CT_RX3_AVAIL = 3, /**< SLINK control register(3) (r/-): RX link 3 data available */
SLINK_CT_RX4_AVAIL = 4, /**< SLINK control register(4) (r/-): RX link 4 data available */
SLINK_CT_RX5_AVAIL = 5, /**< SLINK control register(5) (r/-): RX link 5 data available */
SLINK_CT_RX6_AVAIL = 6, /**< SLINK control register(6) (r/-): RX link 6 data available */
SLINK_CT_RX7_AVAIL = 7, /**< SLINK control register(7) (r/-): RX link 7 data available */
SLINK_CT_RX_NUM0 = 0, /**< SLINK control register(0) (r/-): number of implemented RX links bit 0 */
SLINK_CT_RX_NUM1 = 1, /**< SLINK control register(1) (r/-): number of implemented RX links bit 1 */
SLINK_CT_RX_NUM2 = 2, /**< SLINK control register(2) (r/-): number of implemented RX links bit 2 */
SLINK_CT_RX_NUM3 = 3, /**< SLINK control register(3) (r/-): number of implemented RX links bit 3 */
 
SLINK_CT_TX0_FREE = 8, /**< SLINK control register(8) (r/-): RT link 0 ready to send */
SLINK_CT_TX1_FREE = 9, /**< SLINK control register(9) (r/-): RT link 1 ready to send */
SLINK_CT_TX2_FREE = 10, /**< SLINK control register(10) (r/-): RT link 2 ready to send */
SLINK_CT_TX3_FREE = 11, /**< SLINK control register(11) (r/-): RT link 3 ready to send */
SLINK_CT_TX4_FREE = 12, /**< SLINK control register(12) (r/-): RT link 4 ready to send */
SLINK_CT_TX5_FREE = 13, /**< SLINK control register(13) (r/-): RT link 5 ready to send */
SLINK_CT_TX6_FREE = 14, /**< SLINK control register(14) (r/-): RT link 6 ready to send */
SLINK_CT_TX7_FREE = 15, /**< SLINK control register(15) (r/-): RT link 7 ready to send */
SLINK_CT_TX_NUM0 = 4, /**< SLINK control register(4) (r/-): number of implemented TX links bit 0 */
SLINK_CT_TX_NUM1 = 5, /**< SLINK control register(5) (r/-): number of implemented TX links bit 1 */
SLINK_CT_TX_NUM2 = 6, /**< SLINK control register(6) (r/-): number of implemented TX links bit 2 */
SLINK_CT_TX_NUM3 = 7, /**< SLINK control register(7) (r/-): number of implemented TX links bit 3 */
 
SLINK_CT_RX_NUM0 = 16, /**< SLINK control register(16) (r/-): number of implemented RX links -1 bit 0 */
SLINK_CT_RX_NUM1 = 17, /**< SLINK control register(17) (r/-): number of implemented RX links -1 bit 1 */
SLINK_CT_RX_NUM2 = 18, /**< SLINK control register(18) (r/-): number of implemented RX links -1 bit 2 */
SLINK_CT_RX_FIFO_S0 = 8, /**< SLINK control register( 8) (r/-): log2(RX FIFO size) bit 0 */
SLINK_CT_RX_FIFO_S1 = 9, /**< SLINK control register( 9) (r/-): log2(RX FIFO size) bit 1 */
SLINK_CT_RX_FIFO_S2 = 10, /**< SLINK control register(10) (r/-): log2(RX FIFO size) bit 2 */
SLINK_CT_RX_FIFO_S3 = 11, /**< SLINK control register(11) (r/-): log2(RX FIFO size) bit 3 */
 
SLINK_CT_TX_NUM0 = 19, /**< SLINK control register(19) (r/-): number of implemented TX links -1bit 0 */
SLINK_CT_TX_NUM1 = 20, /**< SLINK control register(20) (r/-): number of implemented TX links -1bit 1 */
SLINK_CT_TX_NUM2 = 21, /**< SLINK control register(21) (r/-): number of implemented TX links -1bit 2 */
SLINK_CT_TX_FIFO_S0 = 12, /**< SLINK control register(12) (r/-): log2(TX FIFO size) bit 0 */
SLINK_CT_TX_FIFO_S1 = 13, /**< SLINK control register(13) (r/-): log2(TX FIFO size) bit 1 */
SLINK_CT_TX_FIFO_S2 = 14, /**< SLINK control register(14) (r/-): log2(TX FIFO size) bit 2 */
SLINK_CT_TX_FIFO_S3 = 15, /**< SLINK control register(15) (r/-): log2(TX FIFO size) bit 3 */
 
SLINK_CT_RX_FIFO_S0 = 22, /**< SLINK control register(22) (r/-): log2(RX FIFO size) bit 0 */
SLINK_CT_RX_FIFO_S1 = 23, /**< SLINK control register(23) (r/-): log2(RX FIFO size) bit 1 */
SLINK_CT_RX_FIFO_S2 = 24, /**< SLINK control register(24) (r/-): log2(RX FIFO size) bit 2 */
SLINK_CT_RX_FIFO_S3 = 25, /**< SLINK control register(25) (r/-): log2(RX FIFO size) bit 3 */
SLINK_CT_EN = 31, /**< SLINK control register(0) (r/w): SLINK controller enable */
};
 
SLINK_CT_TX_FIFO_S0 = 26, /**< SLINK control register(26) (r/-): log2(TX FIFO size) bit 0 */
SLINK_CT_TX_FIFO_S1 = 27, /**< SLINK control register(27) (r/-): log2(TX FIFO size) bit 1 */
SLINK_CT_TX_FIFO_S2 = 28, /**< SLINK control register(28) (r/-): log2(TX FIFO size) bit 2 */
SLINK_CT_TX_FIFO_S3 = 29, /**< SLINK control register(29) (r/-): log2(TX FIFO size) bit 3 */
/** SLINK status register bits */
enum NEORV32_SLINK_STATUS_enum {
SLINK_STATUS_RX0_AVAIL = 0, /**< SLINK status register(0) (r/-): RX link 0 data available */
SLINK_STATUS_RX1_AVAIL = 1, /**< SLINK status register(1) (r/-): RX link 1 data available */
SLINK_STATUS_RX2_AVAIL = 2, /**< SLINK status register(2) (r/-): RX link 2 data available */
SLINK_STATUS_RX3_AVAIL = 3, /**< SLINK status register(3) (r/-): RX link 3 data available */
SLINK_STATUS_RX4_AVAIL = 4, /**< SLINK status register(4) (r/-): RX link 4 data available */
SLINK_STATUS_RX5_AVAIL = 5, /**< SLINK status register(5) (r/-): RX link 5 data available */
SLINK_STATUS_RX6_AVAIL = 6, /**< SLINK status register(6) (r/-): RX link 6 data available */
SLINK_STATUS_RX7_AVAIL = 7, /**< SLINK status register(7) (r/-): RX link 7 data available */
 
SLINK_CT_EN = 31 /**< SLINK control register(31) (r/w): SLINK controller enable */
SLINK_STATUS_TX0_FREE = 8, /**< SLINK status register(8) (r/-): TX link 0 ready to send */
SLINK_STATUS_TX1_FREE = 9, /**< SLINK status register(9) (r/-): TX link 1 ready to send */
SLINK_STATUS_TX2_FREE = 10, /**< SLINK status register(10) (r/-): TX link 2 ready to send */
SLINK_STATUS_TX3_FREE = 11, /**< SLINK status register(11) (r/-): TX link 3 ready to send */
SLINK_STATUS_TX4_FREE = 12, /**< SLINK status register(12) (r/-): TX link 4 ready to send */
SLINK_STATUS_TX5_FREE = 13, /**< SLINK status register(13) (r/-): TX link 5 ready to send */
SLINK_STATUS_TX6_FREE = 14, /**< SLINK status register(14) (r/-): TX link 6 ready to send */
SLINK_STATUS_TX7_FREE = 15, /**< SLINK status register(15) (r/-): TX link 7 ready to send */
 
SLINK_STATUS_RX0_HALF = 16, /**< SLINK status register(16) (r/-): RX link 0 FIFO fill level is >= half-full */
SLINK_STATUS_RX1_HALF = 17, /**< SLINK status register(17) (r/-): RX link 1 FIFO fill level is >= half-full */
SLINK_STATUS_RX2_HALF = 18, /**< SLINK status register(18) (r/-): RX link 2 FIFO fill level is >= half-full */
SLINK_STATUS_RX3_HALF = 19, /**< SLINK status register(19) (r/-): RX link 3 FIFO fill level is >= half-full */
SLINK_STATUS_RX4_HALF = 20, /**< SLINK status register(20) (r/-): RX link 4 FIFO fill level is >= half-full */
SLINK_STATUS_RX5_HALF = 21, /**< SLINK status register(21) (r/-): RX link 5 FIFO fill level is >= half-full */
SLINK_STATUS_RX6_HALF = 22, /**< SLINK status register(22) (r/-): RX link 6 FIFO fill level is >= half-full */
SLINK_STATUS_RX7_HALF = 23, /**< SLINK status register(23) (r/-): RX link 7 FIFO fill level is >= half-full */
 
SLINK_STATUS_TX0_HALF = 24, /**< SLINK status register(24) (r/-): TX link 0 FIFO fill level is > half-full */
SLINK_STATUS_TX1_HALF = 25, /**< SLINK status register(25) (r/-): TX link 1 FIFO fill level is > half-full */
SLINK_STATUS_TX2_HALF = 26, /**< SLINK status register(26) (r/-): TX link 2 FIFO fill level is > half-full */
SLINK_STATUS_TX3_HALF = 27, /**< SLINK status register(27) (r/-): TX link 3 FIFO fill level is > half-full */
SLINK_STATUS_TX4_HALF = 28, /**< SLINK status register(28) (r/-): TX link 4 FIFO fill level is > half-full */
SLINK_STATUS_TX5_HALF = 29, /**< SLINK status register(29) (r/-): TX link 5 FIFO fill level is > half-full */
SLINK_STATUS_TX6_HALF = 30, /**< SLINK status register(30) (r/-): TX link 6 FIFO fill level is > half-full */
SLINK_STATUS_TX7_HALF = 31 /**< SLINK status register(31) (r/-): TX link 7 FIFO fill level is > half-full */
};
/**@}*/
 
1040,7 → 1072,7
enum NEORV32_NEOLED_CT_enum {
NEOLED_CT_EN = 0, /**< NEOLED control register(0) (r/w): NEOLED global enable */
NEOLED_CT_MODE = 1, /**< NEOLED control register(1) (r/w): TX mode (0=24-bit, 1=32-bit) */
NEOLED_CT_BSCON = 2, /**< NEOLED control register(2) (r/w): buffer status configuration -> busy_flag/IRQ config (0=at least one free entry, 1=whole buffer empty) */
NEOLED_CT_STROBE = 2, /**< NEOLED control register(2) (r/w): Strobe (0=send normal data, 1=send RESET command on data write) */
NEOLED_CT_PRSC0 = 3, /**< NEOLED control register(3) (r/w): Clock prescaler select bit 0 (pulse-clock speed select) */
NEOLED_CT_PRSC1 = 4, /**< NEOLED control register(4) (r/w): Clock prescaler select bit 1 (pulse-clock speed select) */
NEOLED_CT_PRSC2 = 5, /**< NEOLED control register(5) (r/w): Clock prescaler select bit 2 (pulse-clock speed select) */
1068,8 → 1100,10
NEOLED_CT_T_ONE_H_3 = 23, /**< NEOLED control register(23) (r/w): pulse-clock ticks per ONE high-time bit 3 */
NEOLED_CT_T_ONE_H_4 = 24, /**< NEOLED control register(24) (r/w): pulse-clock ticks per ONE high-time bit 4 */
//
NEOLED_CT_TX_STATUS = 30, /**< NEOLED control register(30) (r/-): serial transmit engine still busy when set */
NEOLED_CT_BUSY = 31 /**< NEOLED control register(31) (r/-): busy / buffer status flag (configured via #NEOLED_CT_BSCON) */
NEOLED_CT_TX_EMPTY = 28, /**< NEOLED control register(28) (r/-): TX FIFO is empty */
NEOLED_CT_TX_HALF = 29, /**< NEOLED control register(29) (r/-): TX FIFO is at least half-full */
NEOLED_CT_TX_FULL = 30, /**< NEOLED control register(30) (r/-): TX FIFO is full */
NEOLED_CT_TX_BUSY = 31 /**< NEOLED control register(31) (r/-): busy / buffer status flag (configured via #NEOLED_CT_BSCON) */
};
/**@}*/
 
1109,7 → 1143,7
SYSINFO_FEATURES_MEM_EXT = 1, /**< SYSINFO_FEATURES (1) (r/-): External bus interface implemented when 1 (via MEM_EXT_EN generic) */
SYSINFO_FEATURES_MEM_INT_IMEM = 2, /**< SYSINFO_FEATURES (2) (r/-): Processor-internal instruction memory implemented when 1 (via MEM_INT_IMEM_EN generic) */
SYSINFO_FEATURES_MEM_INT_DMEM = 3, /**< SYSINFO_FEATURES (3) (r/-): Processor-internal data memory implemented when 1 (via MEM_INT_DMEM_EN generic) */
SYSINFO_FEATURES_MEM_EXT_ENDIAN = 4, /**< SYSINFO_FEATURES (4) (r/-): External bus interface uses BIG-endian byte-order when 1 (via package.xbus_big_endian_c constant) */
SYSINFO_FEATURES_MEM_EXT_ENDIAN = 4, /**< SYSINFO_FEATURES (4) (r/-): External bus interface uses BIG-endian byte-order when 1 (via MEM_EXT_BIG_ENDIAN generic) */
SYSINFO_FEATURES_ICACHE = 5, /**< SYSINFO_FEATURES (5) (r/-): Processor-internal instruction cache implemented when 1 (via ICACHE_EN generic) */
 
SYSINFO_FEATURES_OCD = 14, /**< SYSINFO_FEATURES (14) (r/-): On-chip debugger implemented when 1 (via ON_CHIP_DEBUGGER_EN generic) */
/include/neorv32_cpu.h
66,7 → 66,7
* @param[in] return_code Return value of main() function.
* @return Return value is irrelevant (there is no one left to check for it...).
**************************************************************************/
extern int __neorv32_crt0_after_main(int32_t return_code);
extern int __neorv32_crt0_after_main(int32_t return_code) __attribute__ ((weak));
 
 
/**********************************************************************//**
/include/neorv32_neoled.h
46,12 → 46,27
 
// prototypes
int neorv32_neoled_available(void);
void neorv32_neoled_setup_raw(uint32_t bs_config, uint32_t prsc, uint32_t t_total, uint32_t t_high_zero, uint32_t t_high_one);
void neorv32_neoled_setup_ws2812(uint32_t bs_config);
void neorv32_neoled_setup(uint32_t prsc, uint32_t t_total, uint32_t t_high_zero, uint32_t t_high_one);
void neorv32_neoled_setup_ws2812(void);
void neorv32_neoled_set_mode(uint32_t mode);
void neorv32_neoled_strobe_blocking(void);
void neorv32_neoled_strobe_nonblocking(void);
void neorv32_neoled_enable(void);
void neorv32_neoled_disable(void);
void neorv32_neoled_send_polling(uint32_t mode, uint32_t data);
void neorv32_neoled_send_direct(uint32_t mode, uint32_t data);
void neorv32_neoled_write_blocking(uint32_t data);
uint32_t neorv32_neoled_get_buffer_size(void);
 
 
/**********************************************************************//**
* Send single RGB(W) data word to NEOLED module (non-blocking).
*
* @warning This function uses NO busy/flag checks at all!
*
* @param[in] data LSB-aligned 24-bit RGB or 32-bit RGBW data
**************************************************************************/
inline void __attribute__ ((always_inline)) neorv32_neoled_write_nonblocking(uint32_t data) {
 
NEOLED_DATA = data; // send new LED data
}
 
#endif // neorv32_neoled_h
/include/neorv32_slink.h
50,6 → 50,8
int neorv32_slink_get_tx_num(void);
int neorv32_slink_get_rx_depth(void);
int neorv32_slink_get_tx_depth(void);
int neorv32_slink_check_rx_half_full(int link_id);
int neorv32_slink_check_tx_half_full(int link_id);
// non-blocking transmit
int neorv32_slink_tx0_nonblocking(uint32_t tx_data);
int neorv32_slink_tx1_nonblocking(uint32_t tx_data);
/source/neorv32_neoled.c
65,13 → 65,12
* Enable and configure NEOLED controller. The NEOLED control register bits are listed in #NEORV32_NEOLED_CT_enum.
* This function performs a "raw" configuration (just configuraing the according control register bit).
*
* @param[in] bs_config Busy flag / IRQ configuration (0 = at least one free entry, 1 = whole buffer empty).
* @param[in] prsc Clock prescaler select (0..7). See #NEORV32_CLOCK_PRSC_enum.
* @param[in] t_total Number of pre-scaled clock ticks for total bit period (0..31).
* @param[in] t_high_zero Number of pre-scaled clock ticks to generate high-time for sending a '0' (0..31).
* @param[in] t_high_one Number of pre-scaled clock ticks to generate high-time for sending a '1' (0..31).
**************************************************************************/
void neorv32_neoled_setup_raw(uint32_t bs_config, uint32_t prsc, uint32_t t_total, uint32_t t_high_zero, uint32_t t_high_one) {
void neorv32_neoled_setup(uint32_t prsc, uint32_t t_total, uint32_t t_high_zero, uint32_t t_high_one) {
 
NEOLED_CT = 0; // reset
 
78,9 → 77,6
// module enable
uint32_t ct_enable = 1 << NEOLED_CT_EN;
 
// busy flag / IRQ config
uint32_t ct_bs_config = (bs_config & 0x1) << NEOLED_CT_BSCON;
 
// clock pre-scaler
uint32_t ct_prsc = (prsc & 0x7) << NEOLED_CT_PRSC0;
 
94,7 → 90,7
uint32_t ct_t_one = (t_high_one & 0x1f) << NEOLED_CT_T_ONE_H_0;
 
// set new configuration
NEOLED_CT = ct_enable | ct_bs_config | ct_prsc | ct_t_total | ct_t_zero | ct_t_one;
NEOLED_CT = ct_enable | ct_prsc | ct_t_total | ct_t_zero | ct_t_one;
}
 
 
104,10 → 100,8
*
* @note WS2812 timing: T_period = 1.2us, T_high_zero = 0.4us, T_high_one = 0.8us. Change the constants if required.
* @note This function uses the SYSINFO_CLK value (from the SYSINFO HW module) to do the timing computations.
*
* @param[in] bs_config Busy flag / IRQ configuration (0 = at least one free entry, 1 = whole buffer empty).
**************************************************************************/
void neorv32_neoled_setup_ws2812(uint32_t bs_config) {
void neorv32_neoled_setup_ws2812(void) {
 
// WS2812 timing
const uint32_t T_TOTAL_C = 1200; // ns
157,62 → 151,87
}
 
// set raw configuration
neorv32_neoled_setup_raw(bs_config, clk_prsc_sel, t_total, t_high_zero, t_high_one);
neorv32_neoled_setup(clk_prsc_sel, t_total, t_high_zero, t_high_one);
}
 
 
/**********************************************************************//**
* Enable NEOLED controller.
* Set NEOLED mode (24-bit RGB / 32-bit RGBW).
*
* @param[in] mode 0 = 24-bit mode (RGB), 1 = 32-bit mode (RGBW)
**************************************************************************/
void neorv32_neoled_enable(void) {
void neorv32_neoled_set_mode(uint32_t mode) {
 
NEOLED_CT |= ((uint32_t)(1 << NEOLED_CT_EN));
uint32_t ctrl = NEOLED_CT;
ctrl &= ~(0b1 << NEOLED_CT_MODE); // clear current mode
ctrl |= ((mode & 1) << NEOLED_CT_MODE); // set new mode
NEOLED_CT = ctrl;
}
 
 
/**********************************************************************//**
* Disable NEOLED controller.
* Send strobe command ("RESET") - blocking.
**************************************************************************/
void neorv32_neoled_disable(void) {
void neorv32_neoled_strobe_blocking(void) {
 
NEOLED_CT &= ~((uint32_t)(1 << NEOLED_CT_EN));
while(1) { // wait for FIFO full flag to clear
if ((NEOLED_CT & (1 << NEOLED_CT_TX_FULL)) == 0) {
break;
}
}
 
neorv32_neoled_strobe_nonblocking();
}
 
 
/**********************************************************************//**
* Send single data word to NEOLED module.
*
* @warning This function is blocking as it polls the NEOLED busy flag.
*
* @param[in] mode 0 = 24-bit mode (RGB), 1 = 32-bit mode (RGBW)
* @param[in] data 24-bit RGB or 32-bit RGBW data
* Send strobe command ("RESET") - non-blocking.
**************************************************************************/
void neorv32_neoled_send_polling(uint32_t mode, uint32_t data) {
void neorv32_neoled_strobe_nonblocking(void) {
 
while(NEOLED_CT & (1 << NEOLED_CT_BUSY)); // wait for busy flag to clear
const uint32_t mask = 1 << NEOLED_CT_STROBE; // strobe bit
uint32_t ctrl = NEOLED_CT;
 
neorv32_neoled_send_direct(mode, data);
NEOLED_CT = ctrl | mask; // set strobe bit
NEOLED_DATA = 0; // send any data to trigger strobe command
NEOLED_CT = ctrl & (~mask); // clear strobe bit
}
 
 
/**********************************************************************//**
* Send single data word to NEOLED module.
* Enable NEOLED controller.
**************************************************************************/
void neorv32_neoled_enable(void) {
 
NEOLED_CT |= ((uint32_t)(1 << NEOLED_CT_EN));
}
 
 
/**********************************************************************//**
* Disable NEOLED controller.
**************************************************************************/
void neorv32_neoled_disable(void) {
 
NEOLED_CT &= ~((uint32_t)(1 << NEOLED_CT_EN));
}
 
 
/**********************************************************************//**
* Send single RGB(W) data word to NEOLED module (blocking).
*
* @warning This function used NO busy checks at all!
* @note This function can be called several times in a row to fill the TX buffer (when busy_flag is cleared and bscon = 1).
* @warning This function is blocking as it polls the NEOLED FIFO full flag.
*
* @param[in] mode 0 = 24-bit mode (RGB), 1 = 32-bit mode (RGBW)
* @param[in] data 24-bit RGB or 32-bit RGBW data
* @param[in] data LSB-aligned 24-bit RGB or 32-bit RGBW data
**************************************************************************/
void neorv32_neoled_send_direct(uint32_t mode, uint32_t data) {
void neorv32_neoled_write_blocking(uint32_t data) {
 
// configure TX mode (data size)
uint32_t ctrl = NEOLED_CT;
ctrl &= ~(0b1 << NEOLED_CT_MODE); // clear current mode
ctrl |= ((mode & 1) << NEOLED_CT_MODE); // set new mode
NEOLED_CT = ctrl;
while(1) { // wait for FIFO full flag to clear
if ((NEOLED_CT & (1 << NEOLED_CT_TX_FULL)) == 0) {
break;
}
}
 
NEOLED_DATA = data; // send new LED data
neorv32_neoled_write_nonblocking(data); // send new LED data
}
 
 
225,7 → 244,7
 
uint32_t tmp = NEOLED_CT;
tmp = tmp >> NEOLED_CT_BUFS_0;
tmp = tmp & 0b1111; // insulate buffer size flags
tmp = tmp & 0xf; // isolate buffer size bits
 
return (1 << tmp); // num entries = pow(2, buffer size flags)
}
/source/neorv32_slink.c
87,7 → 87,7
int neorv32_slink_get_rx_num(void) {
 
if (neorv32_slink_available()) {
return (int)(((SLINK_CT >> SLINK_CT_RX_NUM0) & 0x07) + 1);
return (int)((SLINK_CT >> SLINK_CT_RX_NUM0) & 0xf);
}
else {
return 0;
103,7 → 103,7
int neorv32_slink_get_tx_num(void) {
 
if (neorv32_slink_available()) {
return (int)(((SLINK_CT >> SLINK_CT_TX_NUM0) & 0x07) + 1);
return (int)((SLINK_CT >> SLINK_CT_TX_NUM0) & 0xf);
}
else {
return 0;
146,6 → 146,44
 
 
/**********************************************************************//**
* Check if RX link FIFO fill level is >= half-full
*
* @param[in] link_id Link id (0..7).
* @return 1 if fill level is >= half-full.
**************************************************************************/
int neorv32_slink_check_rx_half_full(int link_id) {
 
const uint32_t mask = 1 << SLINK_STATUS_RX0_HALF;
 
if (SLINK_STATUS & (mask << (link_id & 0x7))) {
return 1;
}
else {
return 0;
}
}
 
 
/**********************************************************************//**
* Check if TX link FIFO fill level is > half-full
*
* @param[in] link_id Link id (0..7).
* @return 1 if fill level is > half-full.
**************************************************************************/
int neorv32_slink_check_tx_half_full(int link_id) {
 
const uint32_t mask = 1 << SLINK_STATUS_TX0_HALF;
 
if (SLINK_STATUS & (mask << (link_id & 0x7))) {
return 1;
}
else {
return 0;
}
}
 
 
/**********************************************************************//**
* Write data to TX stream link 0 (non-blocking)
*
* @param[in] tx_data Data to send to link.
153,7 → 191,7
**************************************************************************/
int neorv32_slink_tx0_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX0_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX0_FREE)) {
SLINK_CH0 = tx_data;
return 0;
}
169,7 → 207,7
**************************************************************************/
int neorv32_slink_tx1_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX1_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX1_FREE)) {
SLINK_CH1 = tx_data;
return 0;
}
185,7 → 223,7
**************************************************************************/
int neorv32_slink_tx2_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX2_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX2_FREE)) {
SLINK_CH2 = tx_data;
return 0;
}
201,7 → 239,7
**************************************************************************/
int neorv32_slink_tx3_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX3_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX3_FREE)) {
SLINK_CH3 = tx_data;
return 0;
}
217,7 → 255,7
**************************************************************************/
int neorv32_slink_tx4_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX4_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX4_FREE)) {
SLINK_CH4 = tx_data;
return 0;
}
233,7 → 271,7
**************************************************************************/
int neorv32_slink_tx5_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX5_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX5_FREE)) {
SLINK_CH5 = tx_data;
return 0;
}
249,7 → 287,7
**************************************************************************/
int neorv32_slink_tx6_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX6_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX6_FREE)) {
SLINK_CH6 = tx_data;
return 0;
}
265,7 → 303,7
**************************************************************************/
int neorv32_slink_tx7_nonblocking(uint32_t tx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_TX7_FREE)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_TX7_FREE)) {
SLINK_CH7 = tx_data;
return 0;
}
281,7 → 319,7
**************************************************************************/
int neorv32_slink_rx0_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX0_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX0_AVAIL)) {
*rx_data = SLINK_CH0;
return 0;
}
297,7 → 335,7
**************************************************************************/
int neorv32_slink_rx1_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX1_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX1_AVAIL)) {
*rx_data = SLINK_CH1;
return 0;
}
313,7 → 351,7
**************************************************************************/
int neorv32_slink_rx2_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX2_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX2_AVAIL)) {
*rx_data = SLINK_CH2;
return 0;
}
329,7 → 367,7
**************************************************************************/
int neorv32_slink_rx3_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX3_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX3_AVAIL)) {
*rx_data = SLINK_CH3;
return 0;
}
345,7 → 383,7
**************************************************************************/
int neorv32_slink_rx4_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX4_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX4_AVAIL)) {
*rx_data = SLINK_CH4;
return 0;
}
361,7 → 399,7
**************************************************************************/
int neorv32_slink_rx5_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX5_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX5_AVAIL)) {
*rx_data = SLINK_CH5;
return 0;
}
377,7 → 415,7
**************************************************************************/
int neorv32_slink_rx6_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX6_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX6_AVAIL)) {
*rx_data = SLINK_CH6;
return 0;
}
393,7 → 431,7
**************************************************************************/
int neorv32_slink_rx7_nonblocking(uint32_t *rx_data) {
 
if (SLINK_CT & (1 << SLINK_CT_RX7_AVAIL)) {
if (SLINK_STATUS & (1 << SLINK_STATUS_RX7_AVAIL)) {
*rx_data = SLINK_CH7;
return 0;
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.