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

Subversion Repositories neorv32

[/] [neorv32/] [trunk/] [sw/] [lib/] [source/] [neorv32_slink.c] - Blame information for rev 74

Details | Compare with Previous | View Log


// #################################################################################################
// # << NEORV32: neorv32_slink.c - Stream Link Interface HW Driver >>                              #
// # ********************************************************************************************* #
// # BSD 3-Clause License                                                                          #
// #                                                                                               #
// # Copyright (c) 2021, Stephan Nolting. All rights reserved.                                     #
// #                                                                                               #
// # Redistribution and use in source and binary forms, with or without modification, are          #
// # permitted provided that the following conditions are met:                                     #
// #                                                                                               #
// # 1. Redistributions of source code must retain the above copyright notice, this list of        #
// #    conditions and the following disclaimer.                                                   #
// #                                                                                               #
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #
// #    conditions and the following disclaimer in the documentation and/or other materials        #
// #    provided with the distribution.                                                            #
// #                                                                                               #
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #
// #    endorse or promote products derived from this software without specific prior written      #
// #    permission.                                                                                #
// #                                                                                               #
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #
// # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #
// # ********************************************************************************************* #
// # The NEORV32 Processor - https://github.com/stnolting/neorv32              (c) Stephan Nolting #
// #################################################################################################
 
 
/**********************************************************************//**
 * @file neorv32_slink.c
 * @brief Stream Link Interface HW driver source file.
 **************************************************************************/
 
#include "neorv32.h"
#include "neorv32_slink.h"
 
 
/**********************************************************************//**
 * Check if stream link interface was synthesized.
 *
 * @return 0 if SLINK was not synthesized, 1 if SLINK is available.
 **************************************************************************/
int neorv32_slink_available(void) {
 
  if (NEORV32_SYSINFO.SOC & (1 << SYSINFO_SOC_IO_SLINK)) {
    return 1;
  }
  else {
    return 0;
  }
}
 
 
/**********************************************************************//**
 * Activate stream link interface.
 **************************************************************************/
void neorv32_slink_enable(void) {
 
  NEORV32_SLINK.CTRL |= (uint32_t)(1 << SLINK_CTRL_EN);
}
 
 
/**********************************************************************//**
 * Deactivate stream link interface.
 *
 * @note This will also clear all link FIFOs.
 **************************************************************************/
void neorv32_slink_disable(void) {
 
  NEORV32_SLINK.CTRL &= ~(uint32_t)(1 << SLINK_CTRL_EN);
}
 
 
/**********************************************************************//**
 * Configure SLINK RX interrupt.
 *
 * @param[in] link_id Link id (0..7).
 * @param[in] irq_en Link's IRQ enable (#NEORV32_SLINK_IRQ_EN_enum)
 * @param[in] irq_type Link's IRQ type (#NEORV32_SLINK_IRQ_RX_TYPE_enum)
 **************************************************************************/
void neorv32_slink_rx_irq_config(int link_id, int irq_en, int irq_type) {
 
  link_id = link_id & 7;
 
  uint32_t slink_irq_conf = NEORV32_SLINK.IRQ;
 
  // enable IRQ
  if (irq_en) {
    slink_irq_conf |=  (1 << (SLINK_IRQ_RX_EN_LSB + link_id));
  }
  else {
    slink_irq_conf &= ~(1 << (SLINK_IRQ_RX_EN_LSB + link_id));
  }
 
  // configure type
  if (irq_type) {
    slink_irq_conf |=  (1 << (SLINK_IRQ_RX_MODE_LSB + link_id));
  }
  else {
    slink_irq_conf &= ~(1 << (SLINK_IRQ_RX_MODE_LSB + link_id));
  }
 
  NEORV32_SLINK.IRQ = slink_irq_conf;
}
 
 
/**********************************************************************//**
 * Configure SLINK TX interrupt.
 *
 * @param[in] link_id Link id (0..7).
 * @param[in] irq_en Link's IRQ enable (#NEORV32_SLINK_IRQ_EN_enum)
 * @param[in] irq_type Link's IRQ type (#NEORV32_SLINK_IRQ_TX_TYPE_enum)
 **************************************************************************/
void neorv32_slink_tx_irq_config(int link_id, int irq_en, int irq_type) {
 
  link_id = link_id & 7;
 
  uint32_t slink_irq_conf = NEORV32_SLINK.IRQ;
 
  // enable IRQ
  if (irq_en) {
    slink_irq_conf |=  (1 << (SLINK_IRQ_TX_EN_LSB + link_id));
  }
  else {
    slink_irq_conf &= ~(1 << (SLINK_IRQ_TX_EN_LSB + link_id));
  }
 
  // configure type
  if (irq_type) {
    slink_irq_conf |=  (1 << (SLINK_IRQ_TX_MODE_LSB + link_id));
  }
  else {
    slink_irq_conf &= ~(1 << (SLINK_IRQ_TX_MODE_LSB + link_id));
  }
 
  NEORV32_SLINK.IRQ = slink_irq_conf;
}
 
 
/**********************************************************************//**
 * Get number of implemented RX links
 *
 * @return Number of implemented RX link (0..8).
 **************************************************************************/
int neorv32_slink_get_rx_num(void) {
 
  if (neorv32_slink_available()) {
    return (int)((NEORV32_SLINK.CTRL >> SLINK_CTRL_RX_NUM0) & 0xf);
  }
  else {
    return 0;
  }
}
 
 
/**********************************************************************//**
 * Get number of implemented TX links
 *
 * @return Number of implemented TX link (0..8).
 **************************************************************************/
int neorv32_slink_get_tx_num(void) {
 
  if (neorv32_slink_available()) {
    return (int)((NEORV32_SLINK.CTRL >> SLINK_CTRL_TX_NUM0) & 0xf);
  }
  else {
    return 0;
  }
}
 
 
/**********************************************************************//**
 * Get FIFO depth of RX links
 *
 * @return FIFO depth of RX links (1..32768); 0 if no RX links implemented.
 **************************************************************************/
int neorv32_slink_get_rx_depth(void) {
 
  if (neorv32_slink_available()) {
    uint32_t tmp = (NEORV32_SLINK.CTRL >> SLINK_CTRL_RX_FIFO_S0) & 0x0f;
    return (int)(1 << tmp);
  }
  else {
    return 0;
  }
}
 
 
/**********************************************************************//**
 * Get FIFO depth of TX links
 *
 * @return FIFO depth of TX links (1..32768); 0 if no TX links implemented.
 **************************************************************************/
int neorv32_slink_get_tx_depth(void) {
 
  if (neorv32_slink_available()) {
    uint32_t tmp = (NEORV32_SLINK.CTRL >> SLINK_CTRL_TX_FIFO_S0) & 0x0f;
    return (int)(1 << tmp);
  }
  else {
    return 0;
  }
}
 
 
/**********************************************************************//**
 * 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 (NEORV32_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 (NEORV32_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.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx0_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX0_FREE)) {
    NEORV32_SLINK.DATA[0] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Write data to TX stream link 1 (non-blocking)
 *
 * @param[in] tx_data Data to send to link.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx1_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX1_FREE)) {
    NEORV32_SLINK.DATA[1] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Write data to TX stream link 2 (non-blocking)
 *
 * @param[in] tx_data Data to send to link.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx2_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX2_FREE)) {
    NEORV32_SLINK.DATA[2] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Write data to TX stream link 3 (non-blocking)
 *
 * @param[in] tx_data Data to send to link.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx3_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX3_FREE)) {
    NEORV32_SLINK.DATA[3] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Write data to TX stream link 4 (non-blocking)
 *
 * @param[in] tx_data Data to send to link.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx4_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX4_FREE)) {
    NEORV32_SLINK.DATA[4] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Write data to TX stream link 5 (non-blocking)
 *
 * @param[in] tx_data Data to send to link.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx5_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX5_FREE)) {
    NEORV32_SLINK.DATA[5] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Write data to TX stream link 6 (non-blocking)
 *
 * @param[in] tx_data Data to send to link.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx6_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX6_FREE)) {
    NEORV32_SLINK.DATA[6] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Write data to TX stream link 7 (non-blocking)
 *
 * @param[in] tx_data Data to send to link.
 * @return 0 if data was send, 1 if link is still busy.
 **************************************************************************/
int neorv32_slink_tx7_nonblocking(uint32_t tx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX7_FREE)) {
    NEORV32_SLINK.DATA[7] = tx_data;
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 0 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx0_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX0_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[0];
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 1 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx1_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX1_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[1];
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 2 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx2_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX2_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[2];
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 3 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx3_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX3_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[3];
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 4 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx4_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX4_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[4];
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 5 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx5_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX5_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[5];
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 6 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx6_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX6_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[6];
    return 0;
  }
  return 1;
}
 
 
/**********************************************************************//**
 * Read data from RX stream link 7 (non-blocking)
 *
 * @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.
 * @return 0 if data was received, 1 if there is no data to fetch.
 **************************************************************************/
int neorv32_slink_rx7_nonblocking(uint32_t *rx_data) {
 
  if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX7_AVAIL)) {
    *rx_data = NEORV32_SLINK.DATA[7];
    return 0;
  }
  return 1;
}

Line No.	Rev	Author	Line
1	61	zero_gravi	`// #################################################################################################`
2			`// # << NEORV32: neorv32_slink.c - Stream Link Interface HW Driver >> #`
3			`// # ********************************************************************************************* #`
4			`// # BSD 3-Clause License #`
5			`// # #`
6			`// # Copyright (c) 2021, Stephan Nolting. All rights reserved. #`
7			`// # #`
8			`// # Redistribution and use in source and binary forms, with or without modification, are #`
9			`// # permitted provided that the following conditions are met: #`
10			`// # #`
11			`// # 1. Redistributions of source code must retain the above copyright notice, this list of #`
12			`// # conditions and the following disclaimer. #`
13			`// # #`
14			`// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of #`
15			`// # conditions and the following disclaimer in the documentation and/or other materials #`
16			`// # provided with the distribution. #`
17			`// # #`
18			`// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to #`
19			`// # endorse or promote products derived from this software without specific prior written #`
20			`// # permission. #`
21			`// # #`
22			`// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS #`
23			`// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF #`
24			`// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE #`
25			`// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, #`
26			`// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #`
27			`// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED #`
28			`// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING #`
29			`// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED #`
30			`// # OF THE POSSIBILITY OF SUCH DAMAGE. #`
31			`// # ********************************************************************************************* #`
32			`// # The NEORV32 Processor - https://github.com/stnolting/neorv32 (c) Stephan Nolting #`
33			`// #################################################################################################`
34
35
36			`/********************************************************************//`
37	66	zero_gravi	`* @file neorv32_slink.c`
38	61	zero_gravi	`* @brief Stream Link Interface HW driver source file.`
39			`**************************************************************************/`
40
41			`#include "neorv32.h"`
42			`#include "neorv32_slink.h"`
43
44
45			`/********************************************************************//`
46			`* Check if stream link interface was synthesized.`
47			`*`
48			`* @return 0 if SLINK was not synthesized, 1 if SLINK is available.`
49			`**************************************************************************/`
50			`int neorv32_slink_available(void) {`
51
52	64	zero_gravi	`if (NEORV32_SYSINFO.SOC & (1 << SYSINFO_SOC_IO_SLINK)) {`
53	61	zero_gravi	`return 1;`
54			`}`
55			`else {`
56			`return 0;`
57			`}`
58			`}`
59
60
61			`/********************************************************************//`
62			`* Activate stream link interface.`
63			`**************************************************************************/`
64			`void neorv32_slink_enable(void) {`
65
66	64	zero_gravi	`NEORV32_SLINK.CTRL \|= (uint32_t)(1 << SLINK_CTRL_EN);`
67	61	zero_gravi	`}`
68
69
70			`/********************************************************************//`
71			`* Deactivate stream link interface.`
72			`*`
73			`* @note This will also clear all link FIFOs.`
74			`**************************************************************************/`
75			`void neorv32_slink_disable(void) {`
76
77	64	zero_gravi	`NEORV32_SLINK.CTRL &= ~(uint32_t)(1 << SLINK_CTRL_EN);`
78	61	zero_gravi	`}`
79
80
81			`/********************************************************************//`
82	65	zero_gravi	`* Configure SLINK RX interrupt.`
83			`*`
84			`* @param[in] link_id Link id (0..7).`
85			`* @param[in] irq_en Link's IRQ enable (#NEORV32_SLINK_IRQ_EN_enum)`
86			`* @param[in] irq_type Link's IRQ type (#NEORV32_SLINK_IRQ_RX_TYPE_enum)`
87			`**************************************************************************/`
88			`void neorv32_slink_rx_irq_config(int link_id, int irq_en, int irq_type) {`
89
90			`link_id = link_id & 7;`
91
92			`uint32_t slink_irq_conf = NEORV32_SLINK.IRQ;`
93
94			`// enable IRQ`
95			`if (irq_en) {`
96			`slink_irq_conf \|= (1 << (SLINK_IRQ_RX_EN_LSB + link_id));`
97			`}`
98			`else {`
99			`slink_irq_conf &= ~(1 << (SLINK_IRQ_RX_EN_LSB + link_id));`
100			`}`
101
102			`// configure type`
103			`if (irq_type) {`
104			`slink_irq_conf \|= (1 << (SLINK_IRQ_RX_MODE_LSB + link_id));`
105			`}`
106			`else {`
107			`slink_irq_conf &= ~(1 << (SLINK_IRQ_RX_MODE_LSB + link_id));`
108			`}`
109
110			`NEORV32_SLINK.IRQ = slink_irq_conf;`
111			`}`
112
113
114			`/********************************************************************//`
115			`* Configure SLINK TX interrupt.`
116			`*`
117			`* @param[in] link_id Link id (0..7).`
118			`* @param[in] irq_en Link's IRQ enable (#NEORV32_SLINK_IRQ_EN_enum)`
119			`* @param[in] irq_type Link's IRQ type (#NEORV32_SLINK_IRQ_TX_TYPE_enum)`
120			`**************************************************************************/`
121			`void neorv32_slink_tx_irq_config(int link_id, int irq_en, int irq_type) {`
122
123			`link_id = link_id & 7;`
124
125			`uint32_t slink_irq_conf = NEORV32_SLINK.IRQ;`
126
127			`// enable IRQ`
128			`if (irq_en) {`
129			`slink_irq_conf \|= (1 << (SLINK_IRQ_TX_EN_LSB + link_id));`
130			`}`
131			`else {`
132			`slink_irq_conf &= ~(1 << (SLINK_IRQ_TX_EN_LSB + link_id));`
133			`}`
134
135			`// configure type`
136			`if (irq_type) {`
137			`slink_irq_conf \|= (1 << (SLINK_IRQ_TX_MODE_LSB + link_id));`
138			`}`
139			`else {`
140			`slink_irq_conf &= ~(1 << (SLINK_IRQ_TX_MODE_LSB + link_id));`
141			`}`
142
143			`NEORV32_SLINK.IRQ = slink_irq_conf;`
144			`}`
145
146
147			`/********************************************************************//`
148	61	zero_gravi	`* Get number of implemented RX links`
149			`*`
150			`* @return Number of implemented RX link (0..8).`
151			`**************************************************************************/`
152			`int neorv32_slink_get_rx_num(void) {`
153
154			`if (neorv32_slink_available()) {`
155	64	zero_gravi	`return (int)((NEORV32_SLINK.CTRL >> SLINK_CTRL_RX_NUM0) & 0xf);`
156	61	zero_gravi	`}`
157			`else {`
158			`return 0;`
159			`}`
160			`}`
161
162
163			`/********************************************************************//`
164			`* Get number of implemented TX links`
165			`*`
166			`* @return Number of implemented TX link (0..8).`
167			`**************************************************************************/`
168			`int neorv32_slink_get_tx_num(void) {`
169
170			`if (neorv32_slink_available()) {`
171	64	zero_gravi	`return (int)((NEORV32_SLINK.CTRL >> SLINK_CTRL_TX_NUM0) & 0xf);`
172	61	zero_gravi	`}`
173			`else {`
174			`return 0;`
175			`}`
176			`}`
177
178
179			`/********************************************************************//`
180			`* Get FIFO depth of RX links`
181			`*`
182			`* @return FIFO depth of RX links (1..32768); 0 if no RX links implemented.`
183			`**************************************************************************/`
184			`int neorv32_slink_get_rx_depth(void) {`
185
186			`if (neorv32_slink_available()) {`
187	64	zero_gravi	`uint32_t tmp = (NEORV32_SLINK.CTRL >> SLINK_CTRL_RX_FIFO_S0) & 0x0f;`
188	61	zero_gravi	`return (int)(1 << tmp);`
189			`}`
190			`else {`
191			`return 0;`
192			`}`
193			`}`
194
195
196			`/********************************************************************//`
197			`* Get FIFO depth of TX links`
198			`*`
199			`* @return FIFO depth of TX links (1..32768); 0 if no TX links implemented.`
200			`**************************************************************************/`
201			`int neorv32_slink_get_tx_depth(void) {`
202
203			`if (neorv32_slink_available()) {`
204	64	zero_gravi	`uint32_t tmp = (NEORV32_SLINK.CTRL >> SLINK_CTRL_TX_FIFO_S0) & 0x0f;`
205	61	zero_gravi	`return (int)(1 << tmp);`
206			`}`
207			`else {`
208			`return 0;`
209			`}`
210			`}`
211
212
213			`/********************************************************************//`
214	62	zero_gravi	`* Check if RX link FIFO fill level is >= half-full`
215			`*`
216			`* @param[in] link_id Link id (0..7).`
217			`* @return 1 if fill level is >= half-full.`
218			`**************************************************************************/`
219			`int neorv32_slink_check_rx_half_full(int link_id) {`
220
221			`const uint32_t mask = 1 << SLINK_STATUS_RX0_HALF;`
222
223	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (mask << (link_id & 0x7))) {`
224	62	zero_gravi	`return 1;`
225			`}`
226			`else {`
227			`return 0;`
228			`}`
229			`}`
230
231
232			`/********************************************************************//`
233			`* Check if TX link FIFO fill level is > half-full`
234			`*`
235			`* @param[in] link_id Link id (0..7).`
236			`* @return 1 if fill level is > half-full.`
237			`**************************************************************************/`
238			`int neorv32_slink_check_tx_half_full(int link_id) {`
239
240			`const uint32_t mask = 1 << SLINK_STATUS_TX0_HALF;`
241
242	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (mask << (link_id & 0x7))) {`
243	62	zero_gravi	`return 1;`
244			`}`
245			`else {`
246			`return 0;`
247			`}`
248			`}`
249
250
251			`/********************************************************************//`
252	61	zero_gravi	`* Write data to TX stream link 0 (non-blocking)`
253			`*`
254			`* @param[in] tx_data Data to send to link.`
255			`* @return 0 if data was send, 1 if link is still busy.`
256			`**************************************************************************/`
257			`int neorv32_slink_tx0_nonblocking(uint32_t tx_data) {`
258
259	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX0_FREE)) {`
260			`NEORV32_SLINK.DATA[0] = tx_data;`
261	61	zero_gravi	`return 0;`
262			`}`
263			`return 1;`
264			`}`
265
266
267			`/********************************************************************//`
268			`* Write data to TX stream link 1 (non-blocking)`
269			`*`
270			`* @param[in] tx_data Data to send to link.`
271			`* @return 0 if data was send, 1 if link is still busy.`
272			`**************************************************************************/`
273			`int neorv32_slink_tx1_nonblocking(uint32_t tx_data) {`
274
275	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX1_FREE)) {`
276			`NEORV32_SLINK.DATA[1] = tx_data;`
277	61	zero_gravi	`return 0;`
278			`}`
279			`return 1;`
280			`}`
281
282
283			`/********************************************************************//`
284			`* Write data to TX stream link 2 (non-blocking)`
285			`*`
286			`* @param[in] tx_data Data to send to link.`
287			`* @return 0 if data was send, 1 if link is still busy.`
288			`**************************************************************************/`
289			`int neorv32_slink_tx2_nonblocking(uint32_t tx_data) {`
290
291	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX2_FREE)) {`
292			`NEORV32_SLINK.DATA[2] = tx_data;`
293	61	zero_gravi	`return 0;`
294			`}`
295			`return 1;`
296			`}`
297
298
299			`/********************************************************************//`
300			`* Write data to TX stream link 3 (non-blocking)`
301			`*`
302			`* @param[in] tx_data Data to send to link.`
303			`* @return 0 if data was send, 1 if link is still busy.`
304			`**************************************************************************/`
305			`int neorv32_slink_tx3_nonblocking(uint32_t tx_data) {`
306
307	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX3_FREE)) {`
308			`NEORV32_SLINK.DATA[3] = tx_data;`
309	61	zero_gravi	`return 0;`
310			`}`
311			`return 1;`
312			`}`
313
314
315			`/********************************************************************//`
316			`* Write data to TX stream link 4 (non-blocking)`
317			`*`
318			`* @param[in] tx_data Data to send to link.`
319			`* @return 0 if data was send, 1 if link is still busy.`
320			`**************************************************************************/`
321			`int neorv32_slink_tx4_nonblocking(uint32_t tx_data) {`
322
323	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX4_FREE)) {`
324			`NEORV32_SLINK.DATA[4] = tx_data;`
325	61	zero_gravi	`return 0;`
326			`}`
327			`return 1;`
328			`}`
329
330
331			`/********************************************************************//`
332			`* Write data to TX stream link 5 (non-blocking)`
333			`*`
334			`* @param[in] tx_data Data to send to link.`
335			`* @return 0 if data was send, 1 if link is still busy.`
336			`**************************************************************************/`
337			`int neorv32_slink_tx5_nonblocking(uint32_t tx_data) {`
338
339	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX5_FREE)) {`
340			`NEORV32_SLINK.DATA[5] = tx_data;`
341	61	zero_gravi	`return 0;`
342			`}`
343			`return 1;`
344			`}`
345
346
347			`/********************************************************************//`
348			`* Write data to TX stream link 6 (non-blocking)`
349			`*`
350			`* @param[in] tx_data Data to send to link.`
351			`* @return 0 if data was send, 1 if link is still busy.`
352			`**************************************************************************/`
353			`int neorv32_slink_tx6_nonblocking(uint32_t tx_data) {`
354
355	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX6_FREE)) {`
356			`NEORV32_SLINK.DATA[6] = tx_data;`
357	61	zero_gravi	`return 0;`
358			`}`
359			`return 1;`
360			`}`
361
362
363			`/********************************************************************//`
364			`* Write data to TX stream link 7 (non-blocking)`
365			`*`
366			`* @param[in] tx_data Data to send to link.`
367			`* @return 0 if data was send, 1 if link is still busy.`
368			`**************************************************************************/`
369			`int neorv32_slink_tx7_nonblocking(uint32_t tx_data) {`
370
371	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_TX7_FREE)) {`
372			`NEORV32_SLINK.DATA[7] = tx_data;`
373	61	zero_gravi	`return 0;`
374			`}`
375			`return 1;`
376			`}`
377
378
379			`/********************************************************************//`
380			`* Read data from RX stream link 0 (non-blocking)`
381			`*`
382			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
383			`* @return 0 if data was received, 1 if there is no data to fetch.`
384			`**************************************************************************/`
385			`int neorv32_slink_rx0_nonblocking(uint32_t *rx_data) {`
386
387	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX0_AVAIL)) {`
388			`*rx_data = NEORV32_SLINK.DATA[0];`
389	61	zero_gravi	`return 0;`
390			`}`
391			`return 1;`
392			`}`
393
394
395			`/********************************************************************//`
396			`* Read data from RX stream link 1 (non-blocking)`
397			`*`
398			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
399			`* @return 0 if data was received, 1 if there is no data to fetch.`
400			`**************************************************************************/`
401			`int neorv32_slink_rx1_nonblocking(uint32_t *rx_data) {`
402
403	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX1_AVAIL)) {`
404			`*rx_data = NEORV32_SLINK.DATA[1];`
405	61	zero_gravi	`return 0;`
406			`}`
407			`return 1;`
408			`}`
409
410
411			`/********************************************************************//`
412			`* Read data from RX stream link 2 (non-blocking)`
413			`*`
414			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
415			`* @return 0 if data was received, 1 if there is no data to fetch.`
416			`**************************************************************************/`
417			`int neorv32_slink_rx2_nonblocking(uint32_t *rx_data) {`
418
419	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX2_AVAIL)) {`
420			`*rx_data = NEORV32_SLINK.DATA[2];`
421	61	zero_gravi	`return 0;`
422			`}`
423			`return 1;`
424			`}`
425
426
427			`/********************************************************************//`
428			`* Read data from RX stream link 3 (non-blocking)`
429			`*`
430			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
431			`* @return 0 if data was received, 1 if there is no data to fetch.`
432			`**************************************************************************/`
433			`int neorv32_slink_rx3_nonblocking(uint32_t *rx_data) {`
434
435	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX3_AVAIL)) {`
436			`*rx_data = NEORV32_SLINK.DATA[3];`
437	61	zero_gravi	`return 0;`
438			`}`
439			`return 1;`
440			`}`
441
442
443			`/********************************************************************//`
444			`* Read data from RX stream link 4 (non-blocking)`
445			`*`
446			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
447			`* @return 0 if data was received, 1 if there is no data to fetch.`
448			`**************************************************************************/`
449			`int neorv32_slink_rx4_nonblocking(uint32_t *rx_data) {`
450
451	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX4_AVAIL)) {`
452			`*rx_data = NEORV32_SLINK.DATA[4];`
453	61	zero_gravi	`return 0;`
454			`}`
455			`return 1;`
456			`}`
457
458
459			`/********************************************************************//`
460			`* Read data from RX stream link 5 (non-blocking)`
461			`*`
462			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
463			`* @return 0 if data was received, 1 if there is no data to fetch.`
464			`**************************************************************************/`
465			`int neorv32_slink_rx5_nonblocking(uint32_t *rx_data) {`
466
467	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX5_AVAIL)) {`
468			`*rx_data = NEORV32_SLINK.DATA[5];`
469	61	zero_gravi	`return 0;`
470			`}`
471			`return 1;`
472			`}`
473
474
475			`/********************************************************************//`
476			`* Read data from RX stream link 6 (non-blocking)`
477			`*`
478			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
479			`* @return 0 if data was received, 1 if there is no data to fetch.`
480			`**************************************************************************/`
481			`int neorv32_slink_rx6_nonblocking(uint32_t *rx_data) {`
482
483	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX6_AVAIL)) {`
484			`*rx_data = NEORV32_SLINK.DATA[6];`
485	61	zero_gravi	`return 0;`
486			`}`
487			`return 1;`
488			`}`
489
490
491			`/********************************************************************//`
492			`* Read data from RX stream link 7 (non-blocking)`
493			`*`
494			`* @param[in,out] rx_data Pointer to return read data. Only valid if function return value = 0.`
495			`* @return 0 if data was received, 1 if there is no data to fetch.`
496			`**************************************************************************/`
497			`int neorv32_slink_rx7_nonblocking(uint32_t *rx_data) {`
498
499	64	zero_gravi	`if (NEORV32_SLINK.STATUS & (1 << SLINK_STATUS_RX7_AVAIL)) {`
500			`*rx_data = NEORV32_SLINK.DATA[7];`

Browse

Tools

Subversion Repositories neorv32

[/] [neorv32/] [trunk/] [sw/] [lib/] [source/] [neorv32_slink.c] - Blame information for rev 74