libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[bsp][redv] formatting

This commit is contained in:
luhuadong 2021-12-20 16:07:35 +08:00
parent df71ffd87a
commit f7447a8dc5
18 changed files with 139 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bsp/sparkfun-redv/applications/led/led.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2006-2020, RT-Thread Development Team * Copyright (c) 2006-2021, RT-Thread Development Team
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
* *
@ -56,4 +56,4 @@ void led_set(rt_uint8_t val)
void led_toggle(void) void led_toggle(void)
{ {
_led_toggle(USER_LED_OFFSET); _led_toggle(USER_LED_OFFSET);
} }

2
bsp/sparkfun-redv/applications/led/led.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2006-2020, RT-Thread Development Team * Copyright (c) 2006-2021, RT-Thread Development Team
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
* *

6
bsp/sparkfun-redv/applications/main.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2006-2020, RT-Thread Development Team * Copyright (c) 2006-2021, RT-Thread Development Team
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
* *
@ -14,7 +14,7 @@
int main(void) int main(void)
{ {
rt_kprintf("Hello, World!\n"); rt_kprintf("Hello, World!\n");
led_init(); led_init();
while (1) while (1)
@ -60,4 +60,4 @@ static void give_me_five(void)
} }
#ifdef FINSH_USING_MSH #ifdef FINSH_USING_MSH
MSH_CMD_EXPORT(give_me_five, Show the SiFive logo) MSH_CMD_EXPORT(give_me_five, Show the SiFive logo)
#endif #endif

2
bsp/sparkfun-redv/drivers/drv_usart.c
View File

@ -37,7 +37,7 @@ static rt_err_t usart_configure(struct rt_serial_device *serial,
{ {
RT_ASSERT(serial != RT_NULL); RT_ASSERT(serial != RT_NULL);
RT_ASSERT(cfg != RT_NULL); RT_ASSERT(cfg != RT_NULL);
GPIO_REG(GPIO_IOF_SEL) &= ~IOF0_UART0_MASK; GPIO_REG(GPIO_IOF_SEL) &= ~IOF0_UART0_MASK;
GPIO_REG(GPIO_IOF_EN) |= IOF0_UART0_MASK; GPIO_REG(GPIO_IOF_EN) |= IOF0_UART0_MASK;

10
bsp/sparkfun-redv/drivers/interrupt.c
View File

@ -62,13 +62,13 @@ rt_isr_handler_t rt_hw_interrupt_handle(rt_uint32_t vector, void *param)
void rt_hw_interrupt_init(void) void rt_hw_interrupt_init(void)
{ {
int idx; int idx;
/* config interrupt vector*/ /* config interrupt vector*/
asm volatile( asm volatile(
"la t0, trap_entry\n" "la t0, trap_entry\n"
"csrw mtvec, t0" "csrw mtvec, t0"
); );
/* enable global interrupt*/ /* enable global interrupt*/
PLIC_init(&g_plic, PLIC_init(&g_plic,
PLIC_CTRL_ADDR, PLIC_CTRL_ADDR,
@ -86,8 +86,8 @@ void rt_hw_interrupt_init(void)
irq_desc[idx].counter = 0; irq_desc[idx].counter = 0;
#endif #endif
} }
// enable machine external interrupt // enable machine external interrupt
set_csr(mie, MIP_MEIP); set_csr(mie, MIP_MEIP);
} }
@ -132,7 +132,7 @@ rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler,
} }
/** /**
* This function will be call when external machine-level * This function will be call when external machine-level
* interrupt from PLIC occurred. * interrupt from PLIC occurred.
*/ */
void handle_m_ext_interrupt(void) void handle_m_ext_interrupt(void)

2
bsp/sparkfun-redv/drivers/interrupt.h
View File

@ -33,5 +33,5 @@ rt_uint32_t rt_hw_interrupt_get_active(rt_uint32_t fiq_irq);
void rt_hw_interrupt_ack(rt_uint32_t fiq_irq, rt_uint32_t id); void rt_hw_interrupt_ack(rt_uint32_t fiq_irq, rt_uint32_t id);
rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler, rt_isr_handler_t rt_hw_interrupt_install(int vector, rt_isr_handler_t handler,
void *param, const char *name); void *param, const char *name);
#endif #endif

74
bsp/sparkfun-redv/freedom-e-sdk/bsp/drivers/fe300prci/fe300prci_driver.c
View File

@ -6,15 +6,15 @@
#include "fe300prci/fe300prci_driver.h" #include "fe300prci/fe300prci_driver.h"
#include <unistd.h> #include <unistd.h>
#define rdmcycle(x) { \ #define rdmcycle(x) { \
uint32_t lo, hi, hi2; \ uint32_t lo, hi, hi2; \
__asm__ __volatile__ ("1:\n\t" \ __asm__ __volatile__ ("1:\n\t" \
"csrr %0, mcycleh\n\t" \ "csrr %0, mcycleh\n\t" \
"csrr %1, mcycle\n\t" \ "csrr %1, mcycle\n\t" \
"csrr %2, mcycleh\n\t" \ "csrr %2, mcycleh\n\t" \
"bne %0, %2, 1b\n\t" \ "bne %0, %2, 1b\n\t" \
: "=r" (hi), "=r" (lo), "=r" (hi2)) ; \ : "=r" (hi), "=r" (lo), "=r" (hi2)) ; \
*(x) = lo | ((uint64_t) hi << 32); \ *(x) = lo | ((uint64_t) hi << 32); \
} }
uint32_t PRCI_measure_mcycle_freq(uint32_t mtime_ticks, uint32_t mtime_freq) uint32_t PRCI_measure_mcycle_freq(uint32_t mtime_ticks, uint32_t mtime_freq)
@ -34,49 +34,49 @@ uint32_t PRCI_measure_mcycle_freq(uint32_t mtime_ticks, uint32_t mtime_freq)
do { do {
start_mtime = CLINT_REG(CLINT_MTIME); start_mtime = CLINT_REG(CLINT_MTIME);
} while (start_mtime == tmp); } while (start_mtime == tmp);
uint64_t start_mcycle; uint64_t start_mcycle;
rdmcycle(&start_mcycle); rdmcycle(&start_mcycle);
while (CLINT_REG(CLINT_MTIME) < end_mtime) ; while (CLINT_REG(CLINT_MTIME) < end_mtime) ;
uint64_t end_mcycle; uint64_t end_mcycle;
rdmcycle(&end_mcycle); rdmcycle(&end_mcycle);
uint32_t difference = (uint32_t) (end_mcycle - start_mcycle); uint32_t difference = (uint32_t) (end_mcycle - start_mcycle);
uint64_t freq = ((uint64_t) difference * mtime_freq) / mtime_ticks; uint64_t freq = ((uint64_t) difference * mtime_freq) / mtime_ticks;
return (uint32_t) freq & 0xFFFFFFFF; return (uint32_t) freq & 0xFFFFFFFF;
} }
void PRCI_use_hfrosc(int div, int trim) void PRCI_use_hfrosc(int div, int trim)
{ {
// Make sure the HFROSC is running at its default setting // Make sure the HFROSC is running at its default setting
// It is OK to change this even if we are running off of it. // It is OK to change this even if we are running off of it.
PRCI_REG(PRCI_HFROSCCFG) = (ROSC_DIV(div) | ROSC_TRIM(trim) | ROSC_EN(1)); PRCI_REG(PRCI_HFROSCCFG) = (ROSC_DIV(div) | ROSC_TRIM(trim) | ROSC_EN(1));
while ((PRCI_REG(PRCI_HFROSCCFG) & ROSC_RDY(1)) == 0); while ((PRCI_REG(PRCI_HFROSCCFG) & ROSC_RDY(1)) == 0);
PRCI_REG(PRCI_PLLCFG) &= ~PLL_SEL(1); PRCI_REG(PRCI_PLLCFG) &= ~PLL_SEL(1);
} }
void PRCI_use_pll(int refsel, int bypass, void PRCI_use_pll(int refsel, int bypass,
int r, int f, int q, int finaldiv, int r, int f, int q, int finaldiv,
int hfroscdiv, int hfrosctrim) int hfroscdiv, int hfrosctrim)
{ {
// Ensure that we aren't running off the PLL before we mess with it. // Ensure that we aren't running off the PLL before we mess with it.
if (PRCI_REG(PRCI_PLLCFG) & PLL_SEL(1)) { if (PRCI_REG(PRCI_PLLCFG) & PLL_SEL(1)) {
// Make sure the HFROSC is running at its default setting // Make sure the HFROSC is running at its default setting
PRCI_use_hfrosc(4, 16); PRCI_use_hfrosc(4, 16);
} }
// Set PLL Source to be HFXOSC if desired. // Set PLL Source to be HFXOSC if desired.
uint32_t config_value = 0; uint32_t config_value = 0;
config_value |= PLL_REFSEL(refsel); config_value |= PLL_REFSEL(refsel);
if (bypass) { if (bypass) {
// Bypass // Bypass
config_value |= PLL_BYPASS(1); config_value |= PLL_BYPASS(1);
@ -87,14 +87,14 @@ void PRCI_use_pll(int refsel, int bypass,
// Set our Final output divide to divide-by-1: // Set our Final output divide to divide-by-1:
PRCI_REG(PRCI_PLLDIV) = (PLL_FINAL_DIV_BY_1(1) | PLL_FINAL_DIV(0)); PRCI_REG(PRCI_PLLDIV) = (PLL_FINAL_DIV_BY_1(1) | PLL_FINAL_DIV(0));
} else { } else {
// To overclock, use the hfrosc // To overclock, use the hfrosc
if (hfrosctrim >= 0 && hfroscdiv >= 0) { if (hfrosctrim >= 0 && hfroscdiv >= 0) {
PRCI_use_hfrosc(hfroscdiv, hfrosctrim); PRCI_use_hfrosc(hfroscdiv, hfrosctrim);
} }
// Set DIV Settings for PLL // Set DIV Settings for PLL
// (Legal values of f_REF are 6-48MHz) // (Legal values of f_REF are 6-48MHz)
// Set DIVR to divide-by-2 to get 8MHz frequency // Set DIVR to divide-by-2 to get 8MHz frequency
@ -132,7 +132,7 @@ void PRCI_use_pll(int refsel, int bypass,
// So wait 4 ticks of RTC. // So wait 4 ticks of RTC.
uint32_t now = CLINT_REG(CLINT_MTIME); uint32_t now = CLINT_REG(CLINT_MTIME);
while (CLINT_REG(CLINT_MTIME) - now < 4) ; while (CLINT_REG(CLINT_MTIME) - now < 4) ;
// Now it is safe to check for PLL Lock // Now it is safe to check for PLL Lock
while ((PRCI_REG(PRCI_PLLCFG) & PLL_LOCK(1)) == 0); while ((PRCI_REG(PRCI_PLLCFG) & PLL_LOCK(1)) == 0);
@ -146,7 +146,7 @@ void PRCI_use_pll(int refsel, int bypass,
if (refsel) { if (refsel) {
PRCI_REG(PRCI_HFROSCCFG) &= ~ROSC_EN(1); PRCI_REG(PRCI_HFROSCCFG) &= ~ROSC_EN(1);
} }
} }
void PRCI_use_default_clocks() void PRCI_use_default_clocks()
@ -160,15 +160,15 @@ void PRCI_use_default_clocks()
void PRCI_use_hfxosc(uint32_t finaldiv) void PRCI_use_hfxosc(uint32_t finaldiv)
{ {
PRCI_use_pll(1, // Use HFXTAL PRCI_use_pll(1, // Use HFXTAL
1, // Bypass = 1 1, // Bypass = 1
0, // PLL settings don't matter 0, // PLL settings don't matter
0, // PLL settings don't matter 0, // PLL settings don't matter
0, // PLL settings don't matter 0, // PLL settings don't matter
finaldiv, finaldiv,
-1, -1,
-1); -1);
} }
// This is a generic function, which // This is a generic function, which
@ -199,20 +199,20 @@ uint32_t PRCI_set_hfrosctrim_for_f_cpu(uint32_t f_cpu, PRCI_freq_target target )
uint32_t desired_hfrosc_freq = (f_cpu/ 16); uint32_t desired_hfrosc_freq = (f_cpu/ 16);
PRCI_use_hfrosc(hfroscdiv, hfrosctrim); PRCI_use_hfrosc(hfroscdiv, hfrosctrim);
// Ignore the first run (for icache reasons) // Ignore the first run (for icache reasons)
uint32_t cpu_freq = PRCI_measure_mcycle_freq(3000, RTC_FREQ); uint32_t cpu_freq = PRCI_measure_mcycle_freq(3000, RTC_FREQ);
cpu_freq = PRCI_measure_mcycle_freq(3000, RTC_FREQ); cpu_freq = PRCI_measure_mcycle_freq(3000, RTC_FREQ);
uint32_t prev_freq = cpu_freq; uint32_t prev_freq = cpu_freq;
while ((cpu_freq < desired_hfrosc_freq) && (hfrosctrim < 0x1F)){ while ((cpu_freq < desired_hfrosc_freq) && (hfrosctrim < 0x1F)){
prev_trim = hfrosctrim; prev_trim = hfrosctrim;
prev_freq = cpu_freq; prev_freq = cpu_freq;
hfrosctrim ++; hfrosctrim ++;
PRCI_use_hfrosc(hfroscdiv, hfrosctrim); PRCI_use_hfrosc(hfroscdiv, hfrosctrim);
cpu_freq = PRCI_measure_mcycle_freq(3000, RTC_FREQ); cpu_freq = PRCI_measure_mcycle_freq(3000, RTC_FREQ);
} }
// We couldn't go low enough // We couldn't go low enough
if (prev_freq > desired_hfrosc_freq){ if (prev_freq > desired_hfrosc_freq){
@ -220,7 +220,7 @@ uint32_t PRCI_set_hfrosctrim_for_f_cpu(uint32_t f_cpu, PRCI_freq_target target )
cpu_freq = PRCI_measure_mcycle_freq(1000, RTC_FREQ); cpu_freq = PRCI_measure_mcycle_freq(1000, RTC_FREQ);
return cpu_freq; return cpu_freq;
} }
// We couldn't go high enough // We couldn't go high enough
if (cpu_freq < desired_hfrosc_freq){ if (cpu_freq < desired_hfrosc_freq){
PRCI_use_pll(0, 0, 1, 31, 1, 1, hfroscdiv, prev_trim); PRCI_use_pll(0, 0, 1, 31, 1, 1, hfroscdiv, prev_trim);

34
bsp/sparkfun-redv/freedom-e-sdk/bsp/drivers/fe300prci/fe300prci_driver.h
View File

@ -8,15 +8,15 @@
#include <unistd.h> #include <unistd.h>
typedef enum prci_freq_target { typedef enum prci_freq_target {
PRCI_FREQ_OVERSHOOT, PRCI_FREQ_OVERSHOOT,
PRCI_FREQ_CLOSEST, PRCI_FREQ_CLOSEST,
PRCI_FREQ_UNDERSHOOT PRCI_FREQ_UNDERSHOOT
} PRCI_freq_target; } PRCI_freq_target;
/* Measure and return the approximate frequency of the /* Measure and return the approximate frequency of the
* CPU, as given by measuring the mcycle counter against * CPU, as given by measuring the mcycle counter against
* the mtime ticks. * the mtime ticks.
*/ */
uint32_t PRCI_measure_mcycle_freq(uint32_t mtime_ticks, uint32_t mtime_freq); uint32_t PRCI_measure_mcycle_freq(uint32_t mtime_ticks, uint32_t mtime_freq);
@ -34,7 +34,7 @@ void PRCI_use_hfxosc(uint32_t finaldiv);
/* Safely switch over to the PLL using the given /* Safely switch over to the PLL using the given
* settings. * settings.
* *
* Note that not all combinations of the inputs are actually * Note that not all combinations of the inputs are actually
* legal, and this function does not check for their * legal, and this function does not check for their
* legality ("safely" means that this function won't turn off * legality ("safely" means that this function won't turn off
@ -43,30 +43,30 @@ void PRCI_use_hfxosc(uint32_t finaldiv);
*/ */
void PRCI_use_pll(int refsel, int bypass, void PRCI_use_pll(int refsel, int bypass,
int r, int f, int q, int finaldiv, int r, int f, int q, int finaldiv,
int hfroscdiv, int hfrosctrim); int hfroscdiv, int hfrosctrim);
/* Use the default clocks configured at reset. /* Use the default clocks configured at reset.
* This is ~16Mhz HFROSC and turns off the LFROSC * This is ~16Mhz HFROSC and turns off the LFROSC
* (on the current FE310 Dev Platforms, an external LFROSC is * (on the current FE310 Dev Platforms, an external LFROSC is
* used as it is more power efficient). * used as it is more power efficient).
*/ */
void PRCI_use_default_clocks(); void PRCI_use_default_clocks();
/* This routine will adjust the HFROSC trim /* This routine will adjust the HFROSC trim
* while using HFROSC as the clock source, * while using HFROSC as the clock source,
* measure the resulting frequency, then * measure the resulting frequency, then
* use it as the PLL clock source, * use it as the PLL clock source,
* in an attempt to get over, under, or close to the * in an attempt to get over, under, or close to the
* requested frequency. It returns the actual measured * requested frequency. It returns the actual measured
* frequency. * frequency.
* *
* Note that the requested frequency must be within the * Note that the requested frequency must be within the
* range supported by the PLL so not all values are * range supported by the PLL so not all values are
* achievable with this function, and not all * achievable with this function, and not all
* are guaranteed to actually work. The PLL * are guaranteed to actually work. The PLL
* is rated higher than the hardware. * is rated higher than the hardware.
* *
* There is no check on the desired f_cpu frequency, it * There is no check on the desired f_cpu frequency, it
* is up to the user to specify something reasonable. * is up to the user to specify something reasonable.
*/ */
@ -76,4 +76,4 @@ uint32_t PRCI_set_hfrosctrim_for_f_cpu(uint32_t f_cpu, PRCI_freq_target target);
//__END_DECLS //__END_DECLS
#endif #endif

26
bsp/sparkfun-redv/freedom-e-sdk/bsp/drivers/plic/plic_driver.c
View File

@ -25,18 +25,18 @@ void PLIC_init (
uint32_t num_priorities uint32_t num_priorities
) )
{ {
this_plic->base_addr = base_addr; this_plic->base_addr = base_addr;
this_plic->num_sources = num_sources; this_plic->num_sources = num_sources;
this_plic->num_priorities = num_priorities; this_plic->num_priorities = num_priorities;
// Disable all interrupts (don't assume that these registers are reset). // Disable all interrupts (don't assume that these registers are reset).
unsigned long hart_id = read_csr(mhartid); unsigned long hart_id = read_csr(mhartid);
volatile_memzero((uint8_t*) (this_plic->base_addr + volatile_memzero((uint8_t*) (this_plic->base_addr +
PLIC_ENABLE_OFFSET + PLIC_ENABLE_OFFSET +
(hart_id << PLIC_ENABLE_SHIFT_PER_TARGET)), (hart_id << PLIC_ENABLE_SHIFT_PER_TARGET)),
(num_sources + 8) / 8); (num_sources + 8) / 8);
// Set all priorities to 0 (equal priority -- don't assume that these are reset). // Set all priorities to 0 (equal priority -- don't assume that these are reset).
volatile_memzero ((uint8_t *)(this_plic->base_addr + volatile_memzero ((uint8_t *)(this_plic->base_addr +
PLIC_PRIORITY_OFFSET), PLIC_PRIORITY_OFFSET),
@ -49,13 +49,13 @@ void PLIC_init (
(hart_id << PLIC_THRESHOLD_SHIFT_PER_TARGET)); (hart_id << PLIC_THRESHOLD_SHIFT_PER_TARGET));
*threshold = 0; *threshold = 0;
} }
void PLIC_set_threshold (plic_instance_t * this_plic, void PLIC_set_threshold (plic_instance_t * this_plic,
plic_threshold threshold){ plic_threshold threshold){
unsigned long hart_id = read_csr(mhartid); unsigned long hart_id = read_csr(mhartid);
volatile plic_threshold* threshold_ptr = (plic_threshold*) (this_plic->base_addr + volatile plic_threshold* threshold_ptr = (plic_threshold*) (this_plic->base_addr +
PLIC_THRESHOLD_OFFSET + PLIC_THRESHOLD_OFFSET +
(hart_id << PLIC_THRESHOLD_SHIFT_PER_TARGET)); (hart_id << PLIC_THRESHOLD_SHIFT_PER_TARGET));
@ -63,7 +63,7 @@ void PLIC_set_threshold (plic_instance_t * this_plic,
*threshold_ptr = threshold; *threshold_ptr = threshold;
} }
void PLIC_enable_interrupt (plic_instance_t * this_plic, plic_source source){ void PLIC_enable_interrupt (plic_instance_t * this_plic, plic_source source){
@ -79,7 +79,7 @@ void PLIC_enable_interrupt (plic_instance_t * this_plic, plic_source source){
} }
void PLIC_disable_interrupt (plic_instance_t * this_plic, plic_source source){ void PLIC_disable_interrupt (plic_instance_t * this_plic, plic_source source){
unsigned long hart_id = read_csr(mhartid); unsigned long hart_id = read_csr(mhartid);
volatile uint8_t * current_ptr = (volatile uint8_t *) (this_plic->base_addr + volatile uint8_t * current_ptr = (volatile uint8_t *) (this_plic->base_addr +
PLIC_ENABLE_OFFSET + PLIC_ENABLE_OFFSET +
@ -88,7 +88,7 @@ void PLIC_disable_interrupt (plic_instance_t * this_plic, plic_source source){
uint8_t current = *current_ptr; uint8_t current = *current_ptr;
current = current & ~(( 1 << (source & 0x7))); current = current & ~(( 1 << (source & 0x7)));
*current_ptr = current; *current_ptr = current;
} }
void PLIC_set_priority (plic_instance_t * this_plic, plic_source source, plic_priority priority){ void PLIC_set_priority (plic_instance_t * this_plic, plic_source source, plic_priority priority){
@ -103,7 +103,7 @@ void PLIC_set_priority (plic_instance_t * this_plic, plic_source source, plic_pr
} }
plic_source PLIC_claim_interrupt(plic_instance_t * this_plic){ plic_source PLIC_claim_interrupt(plic_instance_t * this_plic){
unsigned long hart_id = read_csr(mhartid); unsigned long hart_id = read_csr(mhartid);
volatile plic_source * claim_addr = (volatile plic_source * ) volatile plic_source * claim_addr = (volatile plic_source * )
@ -112,16 +112,16 @@ plic_source PLIC_claim_interrupt(plic_instance_t * this_plic){
(hart_id << PLIC_CLAIM_SHIFT_PER_TARGET)); (hart_id << PLIC_CLAIM_SHIFT_PER_TARGET));
return *claim_addr; return *claim_addr;
} }
void PLIC_complete_interrupt(plic_instance_t * this_plic, plic_source source){ void PLIC_complete_interrupt(plic_instance_t * this_plic, plic_source source){
unsigned long hart_id = read_csr(mhartid); unsigned long hart_id = read_csr(mhartid);
volatile plic_source * claim_addr = (volatile plic_source *) (this_plic->base_addr + volatile plic_source * claim_addr = (volatile plic_source *) (this_plic->base_addr +
PLIC_CLAIM_OFFSET + PLIC_CLAIM_OFFSET +
(hart_id << PLIC_CLAIM_SHIFT_PER_TARGET)); (hart_id << PLIC_CLAIM_SHIFT_PER_TARGET));
*claim_addr = source; *claim_addr = source;
} }

18
bsp/sparkfun-redv/freedom-e-sdk/bsp/drivers/plic/plic_driver.h
View File

@ -14,7 +14,7 @@ typedef struct __plic_instance_t
uint32_t num_sources; uint32_t num_sources;
uint32_t num_priorities; uint32_t num_priorities;
} plic_instance_t; } plic_instance_t;
typedef uint32_t plic_source; typedef uint32_t plic_source;
@ -29,22 +29,22 @@ void PLIC_init (
); );
void PLIC_set_threshold (plic_instance_t * this_plic, void PLIC_set_threshold (plic_instance_t * this_plic,
plic_threshold threshold); plic_threshold threshold);
void PLIC_enable_interrupt (plic_instance_t * this_plic, void PLIC_enable_interrupt (plic_instance_t * this_plic,
plic_source source); plic_source source);
void PLIC_disable_interrupt (plic_instance_t * this_plic, void PLIC_disable_interrupt (plic_instance_t * this_plic,
plic_source source); plic_source source);
void PLIC_set_priority (plic_instance_t * this_plic, void PLIC_set_priority (plic_instance_t * this_plic,
plic_source source, plic_source source,
plic_priority priority); plic_priority priority);
plic_source PLIC_claim_interrupt(plic_instance_t * this_plic); plic_source PLIC_claim_interrupt(plic_instance_t * this_plic);
void PLIC_complete_interrupt(plic_instance_t * this_plic, void PLIC_complete_interrupt(plic_instance_t * this_plic,
plic_source source); plic_source source);
//__END_DECLS //__END_DECLS

4
bsp/sparkfun-redv/freedom-e-sdk/bsp/env/coreplexip-arty.h vendored
View File

@ -78,9 +78,9 @@
// This gives the mapping from inputs to LOCAL interrupts. // This gives the mapping from inputs to LOCAL interrupts.
#define LOCAL_INT_SW_0 0 #define LOCAL_INT_SW_0 0
#define LOCAL_INT_SW_1 1 #define LOCAL_INT_SW_1 1
#define LOCAL_INT_SW_2 2 #define LOCAL_INT_SW_2 2
#define LOCAL_INT_SW_3 3 #define LOCAL_INT_SW_3 3
#define LOCAL_INT_BTN_0 4 #define LOCAL_INT_BTN_0 4
#define LOCAL_INT_BTN_1 5 #define LOCAL_INT_BTN_1 5

2
bsp/sparkfun-redv/freedom-e-sdk/bsp/env/coreplexip-e51-arty/init.c vendored
View File

@ -1 +1 @@
../coreplexip-e31-arty/init.c ../coreplexip-e31-arty/init.c

2
bsp/sparkfun-redv/freedom-e-sdk/bsp/env/coreplexip-e51-arty/platform.h vendored
View File

@ -1 +1 @@
../coreplexip-e31-arty/platform.h ../coreplexip-e31-arty/platform.h

12
bsp/sparkfun-redv/freedom-e-sdk/bsp/env/hifive1.h vendored
View File

@ -47,16 +47,16 @@
#define PIN_SPI1_MISO (12u) #define PIN_SPI1_MISO (12u)
#define PIN_SPI1_MOSI (11u) #define PIN_SPI1_MOSI (11u)
#define PIN_SPI1_SS0 (10u) #define PIN_SPI1_SS0 (10u)
#define PIN_SPI1_SS1 (14u) #define PIN_SPI1_SS1 (14u)
#define PIN_SPI1_SS2 (15u) #define PIN_SPI1_SS2 (15u)
#define PIN_SPI1_SS3 (16u) #define PIN_SPI1_SS3 (16u)
#define SS_PIN_TO_CS_ID(x) \ #define SS_PIN_TO_CS_ID(x) \
((x==PIN_SPI1_SS0 ? 0 : \ ((x==PIN_SPI1_SS0 ? 0 : \
(x==PIN_SPI1_SS1 ? 1 : \ (x==PIN_SPI1_SS1 ? 1 : \
(x==PIN_SPI1_SS2 ? 2 : \ (x==PIN_SPI1_SS2 ? 2 : \
(x==PIN_SPI1_SS3 ? 3 : \ (x==PIN_SPI1_SS3 ? 3 : \
-1))))) -1)))))
// These buttons are present only on the Freedom E300 Arty Dev Kit. // These buttons are present only on the Freedom E300 Arty Dev Kit.

2
bsp/sparkfun-redv/freedom-e-sdk/bsp/include/sifive/devices/clint.h
View File

@ -11,4 +11,4 @@
#define CLINT_MTIME 0xBFF8 #define CLINT_MTIME 0xBFF8
#define CLINT_MTIME_size 0x8 #define CLINT_MTIME_size 0x8
#endif /* _SIFIVE_CLINT_H */ #endif /* _SIFIVE_CLINT_H */

4
bsp/sparkfun-redv/freedom-e-sdk/bsp/include/sifive/devices/prci.h
View File

@ -12,9 +12,9 @@
#define PRCI_PROCMONCFG (0x00F0) #define PRCI_PROCMONCFG (0x00F0)
/* Fields */ /* Fields */
#define ROSC_DIV(x) (((x) & 0x2F) << 0 ) #define ROSC_DIV(x) (((x) & 0x2F) << 0 )
#define ROSC_TRIM(x) (((x) & 0x1F) << 16) #define ROSC_TRIM(x) (((x) & 0x1F) << 16)
#define ROSC_EN(x) (((x) & 0x1 ) << 30) #define ROSC_EN(x) (((x) & 0x1 ) << 30)
#define ROSC_RDY(x) (((x) & 0x1 ) << 31) #define ROSC_RDY(x) (((x) & 0x1 ) << 31)
#define XOSC_EN(x) (((x) & 0x1) << 30) #define XOSC_EN(x) (((x) & 0x1) << 30)

4
bsp/sparkfun-redv/freedom-e-sdk/bsp/include/sifive/devices/spi.h
View File

@ -57,8 +57,8 @@
#define SPI_INSN_CMD_CODE(x) (((x) & 0xff) << 16) #define SPI_INSN_CMD_CODE(x) (((x) & 0xff) << 16)
#define SPI_INSN_PAD_CODE(x) (((x) & 0xff) << 24) #define SPI_INSN_PAD_CODE(x) (((x) & 0xff) << 24)
#define SPI_TXFIFO_FULL (1 << 31) #define SPI_TXFIFO_FULL (1 << 31)
#define SPI_RXFIFO_EMPTY (1 << 31) #define SPI_RXFIFO_EMPTY (1 << 31)
/* Values */ /* Values */

70
bsp/sparkfun-redv/freedom-e-sdk/bsp/include/sifive/smp.h
View File

@ -12,16 +12,16 @@
#define NONSMP_HART 0 #define NONSMP_HART 0
#endif #endif
/* If your test cannot handle multiple-threads, use this: /* If your test cannot handle multiple-threads, use this:
* smp_disable(reg1) * smp_disable(reg1)
*/ */
#define smp_disable(reg1, reg2) \ #define smp_disable(reg1, reg2) \
csrr reg1, mhartid ;\ csrr reg1, mhartid ;\
li reg2, NONSMP_HART ;\ li reg2, NONSMP_HART ;\
beq reg1, reg2, hart0_entry ;\ beq reg1, reg2, hart0_entry ;\
42: ;\ 42: ;\
wfi ;\ wfi ;\
j 42b ;\ j 42b ;\
hart0_entry: hart0_entry:
/* If your test needs to temporarily block multiple-threads, do this: /* If your test needs to temporarily block multiple-threads, do this:
@ -31,35 +31,35 @@ hart0_entry:
* ... multi-threaded work ... * ... multi-threaded work ...
*/ */
#define smp_pause(reg1, reg2) \ #define smp_pause(reg1, reg2) \
li reg2, 0x8 ;\ li reg2, 0x8 ;\
csrw mie, reg2 ;\ csrw mie, reg2 ;\
csrr reg2, mhartid ;\ csrr reg2, mhartid ;\
bnez reg2, 42f bnez reg2, 42f
#define smp_resume(reg1, reg2) \ #define smp_resume(reg1, reg2) \
li reg1, CLINT_CTRL_ADDR ;\ li reg1, CLINT_CTRL_ADDR ;\
41: ;\ 41: ;\
li reg2, 1 ;\ li reg2, 1 ;\
sw reg2, 0(reg1) ;\ sw reg2, 0(reg1) ;\
addi reg1, reg1, 4 ;\ addi reg1, reg1, 4 ;\
li reg2, CLINT_END_HART_IPI ;\ li reg2, CLINT_END_HART_IPI ;\
blt reg1, reg2, 41b ;\ blt reg1, reg2, 41b ;\
42: ;\ 42: ;\
wfi ;\ wfi ;\
csrr reg2, mip ;\ csrr reg2, mip ;\
andi reg2, reg2, 0x8 ;\ andi reg2, reg2, 0x8 ;\
beqz reg2, 42b ;\ beqz reg2, 42b ;\
li reg1, CLINT_CTRL_ADDR ;\ li reg1, CLINT_CTRL_ADDR ;\
csrr reg2, mhartid ;\ csrr reg2, mhartid ;\
slli reg2, reg2, 2 ;\ slli reg2, reg2, 2 ;\
add reg2, reg2, reg1 ;\ add reg2, reg2, reg1 ;\
sw zero, 0(reg2) ;\ sw zero, 0(reg2) ;\
41: ;\ 41: ;\
lw reg2, 0(reg1) ;\ lw reg2, 0(reg1) ;\
bnez reg2, 41b ;\ bnez reg2, 41b ;\
addi reg1, reg1, 4 ;\ addi reg1, reg1, 4 ;\
li reg2, CLINT_END_HART_IPI ;\ li reg2, CLINT_END_HART_IPI ;\
blt reg1, reg2, 41b blt reg1, reg2, 41b
#endif #endif