int Set_csr (unsigned short pat, char *st)
{
unsigned short csr = 0;
unsigned short str1[20], str2[20];
if (log_print != 2)
sleep (1);
print (2, "Mise a 1 du BIT %s\r", st);
csr = pat;
if (set_csr (bc, rt, &csr, &status) == (-1)) {
print (1, "Probleme systeme [%d] avec set_csr", errno);
return (1);
}
if (get_csr (bc, rt, &csr, &status) == (-1)) {
print (1, "Probleme systeme [%d] avec get_csr", errno);
return (1);
}
if ((csr & pat) != pat) {
convbin (pat, (char *) str1);
convbin (csr, (char *) str2);
print (1, " Set bit of CSR faild. Pattern: [%s] CSR: [%s]\n", (char *) str1, (char *) str2);
return (1);
}
return (0);
}
uintptr_t mcall_set_timer(unsigned long long when)
{
write_csr(mtimecmp, when);
clear_csr(mip, MIP_STIP);
set_csr(mie, MIP_MTIP);
return 0;
}
/*------------------------------------------------------------------------------
* RISC-V interrupt handler for machine timer interrupts.
*/
void handle_m_timer_interrupt() {
uint32_t mhart_id = read_csr(mhartid);
clear_csr(mie, MIP_MTIP);
PRCI->MTIMECMP[mhart_id] = PRCI->MTIME + g_systick_increment;
SysTick_Handler();
set_csr(mie, MIP_MTIP);
}
void
os_tick_init(uint32_t os_ticks_per_sec, int prio)
{
ticks_per_ostick = RTC_FREQ / os_ticks_per_sec;
last_tick_time = get_timer_value();
set_mtimecmp(last_tick_time + ticks_per_ostick);
set_csr(mie, MIP_MTIP);
}
static void riscv_generic_clock_initialize(void)
{
uint32_t mtimecmp = TTMR_NUM_OF_CLOCK_TICKS_INTERRUPT;
uint64_t frequency = (1000000000 / RISCV_CLOCK_CYCLE_TIME_NANOSECONDS);
REG(MTIME_MM) = 0;
REG(MTIMECMP_MM) = TTMR_NUM_OF_CLOCK_TICKS_INTERRUPT;
/* Enable mtimer interrupts */
set_csr(mie, MIP_MTIP);
set_csr(mip, MIP_MTIP);
/* Initialize timecounter */
riscv_generic_tc.tc_get_timecount = riscv_generic_get_timecount;
riscv_generic_tc.tc_counter_mask = 0xffffffff;
riscv_generic_tc.tc_frequency = frequency;
riscv_generic_tc.tc_quality = RTEMS_TIMECOUNTER_QUALITY_CLOCK_DRIVER;
rtems_timecounter_install(&riscv_generic_tc);
}
uintptr_t htif_interrupt(uintptr_t mcause, uintptr_t* regs) {
uintptr_t fromhost = swap_csr(mfromhost, 0);
if (!fromhost)
return 0;
uintptr_t dev = FROMHOST_DEV(fromhost);
uintptr_t cmd = FROMHOST_CMD(fromhost);
uintptr_t data = FROMHOST_DATA(fromhost);
sbi_device_message* m = HLS()->device_request_queue_head;
sbi_device_message* prev = 0x0;
unsigned long i, n;
for (i = 0, n = HLS()->device_request_queue_size; i < n; i++) {
/*
if (!supervisor_paddr_valid(m, sizeof(*m))
&& EXTRACT_FIELD(read_csr(mstatus), MSTATUS_PRV1) != PRV_M)
panic("htif: page fault");
*/
sbi_device_message* next = (void*)m->sbi_private_data;
if (m->dev == dev && m->cmd == cmd) {
m->data = data;
// dequeue from request queue
if (prev)
prev->sbi_private_data = (uintptr_t)next;
else
HLS()->device_request_queue_head = next;
HLS()->device_request_queue_size = n-1;
m->sbi_private_data = 0;
// enqueue to response queue
if (HLS()->device_response_queue_tail)
{
HLS()->device_response_queue_tail->sbi_private_data = (uintptr_t)m;
}
else
{
HLS()->device_response_queue_head = m;
}
HLS()->device_response_queue_tail = m;
// signal software interrupt
set_csr(mip, MIP_SSIP);
return 0;
}
prev = m;
m = (void*)atomic_read(&m->sbi_private_data);
}
//HLT();
return 0;
//panic("htif: no record");
}
void boot_loader(uintptr_t dtb)
{
extern char trap_entry;
write_csr(stvec, &trap_entry);
write_csr(sscratch, 0);
write_csr(sie, 0);
set_csr(sstatus, SSTATUS_SUM | SSTATUS_FS);
file_init();
enter_supervisor_mode(rest_of_boot_loader, pk_vm_init(), 0);
}
int main ()
{
int i, q = 0, p = 0, r = 0;
for (i = 0; i < 20; i++)
{
set_csr ((volatile void *) 0xbf0100a8, 0xffff0002);
set_csr ((volatile void *) 0xbf0100a4, 0x80000008);
}
for (i = 0; i < 20; i++)
{
register int k, j;
k = get_csr ((volatile void *) 0xbf0100b8);
p += k;
j = get_csr ((volatile void *) 0xbf0100b4);
r += j;
q = j + k;
}
return q + r + p;
}
/*------------------------------------------------------------------------------
* Configure the machine timer to generate an interrupt.
*/
uint32_t SysTick_Config(uint32_t ticks) {
uint32_t ret_val = ERROR;
g_systick_increment = ticks / RTC_PRESCALER;
if (g_systick_increment > 0) {
uint32_t mhart_id = read_csr(mhartid);
PRCI->MTIMECMP[mhart_id] = PRCI->MTIME + g_systick_increment;
set_csr(mie, MIP_MTIP);
__enable_irq();
ret_val = SUCCESS;
}
return ret_val;
}
uintptr_t mcall_dev_resp(void)
{
htif_interrupt(0, 0);
sbi_device_message* m = HLS()->device_response_queue_head;
if (m) {
//printm("resp %p\n", m);
sbi_device_message* next = (void*)atomic_read(&m->sbi_private_data);
HLS()->device_response_queue_head = next;
if (!next) {
HLS()->device_response_queue_tail = 0;
// only clear SSIP if no other events are pending
clear_csr(mip, MIP_SSIP);
mb();
if (HLS()->ipi_pending) set_csr(mip, MIP_SSIP);
}
}
return (uintptr_t)m;
}
static void mstatus_init()
{
if (!supports_extension('S'))
panic("supervisor support is required");
uintptr_t ms = 0;
ms = INSERT_FIELD(ms, MSTATUS_PRV, PRV_M);
ms = INSERT_FIELD(ms, MSTATUS_PRV1, PRV_S);
ms = INSERT_FIELD(ms, MSTATUS_PRV2, PRV_U);
ms = INSERT_FIELD(ms, MSTATUS_IE2, 1);
ms = INSERT_FIELD(ms, MSTATUS_VM, VM_CHOICE);
ms = INSERT_FIELD(ms, MSTATUS_FS, 3);
ms = INSERT_FIELD(ms, MSTATUS_XS, 3);
write_csr(mstatus, ms);
ms = read_csr(mstatus);
if (EXTRACT_FIELD(ms, MSTATUS_VM) != VM_CHOICE)
have_vm = 0;
write_csr(mtimecmp, 0);
clear_csr(mip, MIP_MSIP);
set_csr(mie, MIP_MSIP);
}
void rt_systick_handler(void)
{
clear_csr(mie, MIP_MTIP);
// Reset the timer for 3s in the future.
// This also clears the existing timer interrupt.
volatile uint64_t * mtime = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIME);
volatile uint64_t * mtimecmp = (uint64_t*) (CLINT_CTRL_ADDR + CLINT_MTIMECMP);
uint64_t now = *mtime;
uint64_t then = now + 2 * RTC_FREQ/RT_TICK_PER_SECOND;
*mtimecmp = then;
rt_tick_increase();
// read the current value of the LEDS and invert them.
/*
GPIO_REG(GPIO_OUTPUT_VAL) ^= ((0x1 << RED_LED_OFFSET) |
(0x1 << GREEN_LED_OFFSET) |
(0x1 << BLUE_LED_OFFSET));
*/
// Re-enable the timer interrupt.
set_csr(mie, MIP_MTIP);
}
int bit_local (void)
{
unsigned short csr;
int delai;
csr = 0xFFFF;
print (2, "Clear du csr \r");
if (clr_csr (bc, rt, &csr, &status) == -1) {
print (1, "System error [%d] in clr_csr", errno);
erreur++;
if (t_err)
return t_err;
}
print (2, "Envoi d'une interruption\r");
csr = INT_BIT + INE_BIT;
if (set_csr (bc, rt, &csr, &status) == -1) {
print (1, "System error [%d] in set_csr", errno);
erreur++;
if (t_err)
return t_err;
}
csr = INE_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1) {
print (1, "System error [%d] in clr_csr", errno);
erreur++;
if (t_err)
return t_err;
}
print (2, "Set des bits LRR et LOCAL\r");
csr = LRREQ_BIT + LM_BIT;
if (set_csr (bc, rt, &csr, &status) == -1) {
print (1, "System error [%d] in set_csr", errno);
erreur++;
if (t_err)
return t_err;
}
delai = 60;
print (1, "Le G64 a %d secondes pour demarrer son test LOCAL\n", delai);
if (wait_for_csr (LRREQ_BIT + LM_BIT, LM_BIT, delai, 1) == 0)
return (++erreur);
print (1, "Le test LOCAL vient de demarrer sur le host.\n");
print (1, "\tAttente de fin des tests sur le host.\n");
if (wait_for_csr (LM_BIT, 0, 600, 1) == 0)
return (++erreur);
print (1, "Le test LOCAL vient de finir sur le host.");
if (get_csr (bc, rt, &csr, &status) == -1) {
print (1, "System error [%d] in get_csr", errno);
erreur++;
if (t_err)
return t_err;
}
if ((csr & INV_BIT) == INV_BIT) {
print (0,
"Le G64 a detecte une ou plusieurs erreurs au cours du test local.\n");
erreur++;
csr = INV_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1) {
print (1, "System error [%d] in clr_csr", errno);
erreur++;
}
if (t_err)
return t_err;
}
return (erreur);
}
int tst_rst_pointer (short flg, /* bit du csr (RRP ou RTP) */
int (*fun_wr) (short, short, short, char *, unsigned short *), /* ecrire dans le buffer (set_tx_buf ou set_rx_buf) */
int (*fun_rd) (short, short, short, char *, unsigned short *), /* lire dans le buffer (get_tx_buf ou get_rx_buf) */
int (*fun_rst) (short, short, unsigned short *,
unsigned short *))
{ /* faire reset pointer (set_csr ou clr_csr) */
unsigned short buf[4096], *pt, csr;
unsigned short i, seuil;
char str1[20], str2[20];
int Fl_buf = 0;
seuil = 128; /* size in 16-bits words */
if (flg & 0x80)
Fl_buf = 0;
/* Clear buffer */
for (pt = buf, i = 0; i < seuil; i++)
*pt++ = 0;
if (fun_wr (bc, rt, seuil * 2, (char *) buf, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in write_T_buf\n")
else
BAD1 ("\rtst_rst_pointer:System error in write_R_buf\n");
}
/* reset pointer */
csr = flg;
if (fun_rst (bc, rt, &csr, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in reset_T_pointer\n")
else
BAD1 ("\rtst_rst_pointer:System error in reset_R_pointer\n");
}
/* write 32 words */
for (pt = buf, i = 0; i < 32; i++)
*pt++ = i;
if (fun_wr (bc, rt, 64, (char *) buf, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in write_T_buf\n")
else
BAD1 ("\rtst_rst_pointer:System error in write_R_buf\n");
}
/* reset pointer */
csr = flg;
if (fun_rst (bc, rt, &csr, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in reset_T_pointer\n")
else
BAD1 ("\rtst_rst_pointer:System error in reset_R_pointer\n");
}
/* read 16 words and compare */
for (pt = buf, i = 0; i < 16; i++)
*pt++ = 0;
if (fun_rd (bc, rt, 32, (char *) buf, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in read_T_buf\n")
else
BAD1 ("\rtst_rst_pointer:System error in read_R_buf\n");
}
for (pt = buf, i = 0; i < 16; i++, pt++) {
if (*pt != i) {
convbin (*pt, str1);
convbin (i, str2);
print (1, "\nDATA error in tst_rst_pointer:\n read [%s] write [%s]\n", str1, str2);
erreur++;
if (t_err)
return (erreur);
}
}
/* Set local bit and play with the pointer */
csr = LM_BIT;
if (set_csr (bc, rt, &csr, &status) == (-1))
BAD1 ("\rtst_rst_pointer:System error in set LOCAL bit\n");
/* reset pointer */
csr = flg;
if (fun_rst (bc, rt, &csr, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in reset_T_pointer\n")
else
BAD1 ("\rtst_rst_pointer:System error in reset_R_pointer\n");
}
/* write 8 words */
for (pt = buf, i = 0; i < 8; i++)
*pt++ = (i * 4) + i; /* other pattern */
if (fun_wr (bc, rt, 16, (char *) buf, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in write_T_buf\n")
else
BAD1 ("\rtst_rst_pointer:System error in write_R_buf\n");
}
/* read 8 words and compare. They should be 0xFFFF */
for (pt = buf, i = 0; i < 8; i++)
*pt++ = 0;
if (fun_rd (bc, rt, 16, (char *) buf, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in read_T_buf\n")
else
BAD1 ("\rtst_rst_pointer:System error in read_R_buf\n");
}
for (pt = buf, i = 0; i < 8; i++, pt++) {
if (*pt != 0xFFFF) {
convbin (*pt, str1);
convbin (0xffff, str2);
print (1, "\nDATA error in tst_rst_pointer:\n read [%s] write [%s]\n", str1, str2);
erreur++;
if (t_err)
return (erreur);
}
}
/* Reset local bit and read again the buffer */
csr = LM_BIT;
if (clr_csr (bc, rt, &csr, &status) == (-1))
BAD1 ("\rtst_rst_pointer:System error in reset LOCAL bit\n");
/* read 16 words and compare */
for (pt = buf, i = 0; i < 16; i++)
*pt++ = 0;
if (fun_rd (bc, rt, 32, (char *) buf, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in read_T_buf\n")
else
BAD1 ("\rtst_rst_pointer:System error in read_R_buf\n");
}
for (pt = buf, i = 16; i < 32; i++, pt++) {
if (*pt != i) {
convbin (*pt, str1);
convbin (i, str2);
print (1, "\nDATA error in tst_rst_pointer:\n read [%s] write [%s]\n", str1, str2);
erreur++;
if (t_err)
return (erreur);
}
}
return 0;
}
int tst_buffer (short flg, /* bit du csr (RRP ou RTP) */
int (*fun_wr) (short, short, short, char *, unsigned short *), /* fonction pour ecrire dans le buffer (set_tx_buf ou set_rx_buf) */
int (*fun_rd) (short, short, short, char *, unsigned short *), /* fonction pour lire dans le buffer (get_tx_buf ou get_rx_buf) */
char *str)
{
unsigned short buf1[4096], buf2[4096], *pt, *pt1, csr;
short i;
char str1[20], str2[20];
int data_code, sycle_pass, lim, size_of_portion, Fl_buf = 0;
sycle_pass = 0;
data_code = 1;
if (flg & 0x80)
Fl_buf = 0;
do {
full_buff (data_code, buf1);
for (size_of_portion = 2; size_of_portion <= 256;
size_of_portion += 2) {
/* clear buffer */
print (2, "clear buffer\n");
for (pt = buf2, i = 0; i < 128; i++)
*pt++ = 0; /* clear buffer */
if (fun_wr (bc, rt, size_of_portion, (char *) buf2, &status) ==
(-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_rst_pointer:System error in write_T_buf\n")
else
BAD1 ("\rtst_rst_pointer:System error in write_R_buf\n");
}
/* reset pointer */
csr = flg;
print (2, "reset pointer; ");
if (set_csr (bc, rt, &csr, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_buffer:System error in reset_T_pointer\n")
else
BAD1 ("\rtst_buffer:System error in reset_R_pointer\n");
}
/* Send data in one chunk */
print (2, "writing %d words to the buffer\n", size_of_portion);
if (fun_wr (bc, rt, size_of_portion, (char *) buf1, &status) ==
(-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_buffer:System error in write_T_buf\n")
else
BAD1 ("\rtst_buffer:System error in write_R_buf\n");
}
/* reset pointer */
csr = flg;
print (2, "reset pointer; ");
if (set_csr (bc, rt, &csr, &status) == (-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_buffer:System error in reset_T_pointer\n")
else
BAD1 ("\rtst_buffer:System error in reset_R_pointer\n");
}
/* Read data in one chunk */
print (2, "reading %d words to the buffer\n", size_of_portion);
if (fun_rd (bc, rt, size_of_portion, (char *) buf2, &status) ==
(-1)) {
if (Fl_buf == 0)
BAD1 ("\rtst_buffer:System error in read_T_buf\n")
else
BAD1 ("\rtst_buffer:System error in read_R_buf\n");
}
/* compare data */
lim = size_of_portion / 2;
print (2, "compare data\n");
for (pt = buf1, pt1 = buf2, i = 0; i < lim; i++, pt++, pt1++)
if (*pt != *pt1) {
convbin (*pt, str1);
convbin (*pt1, str2);
print (1, "\rDATA error in tst_buffer:\tPointer %d\n read [%s]\n write [%s]\n", i, str1, str2);
erreur++;
}
if (data_code == 6)
size_of_portion += 8;
if (go_on == 0)
break;
}
if (data_code == 6) {
data_code--;
if (++sycle_pass == 16)
data_code++;
}
} while ((++data_code < 7) && (go_on != 0));
return (erreur);
}
int bounce (void)
{
unsigned short csr;
unsigned short buff[4096], data[4096], *pts, *ptd;
int i, l = 0, flag = 0;
int seuil = 0;
unsigned char str1[20], str2[20];
char dir;
seuil = 128;
dir = 8;
/* tell G64 to start bounce with LRR and NEM set */
csr = LRREQ_BIT + NEM_BIT;
if (set_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in set LRR+NEM");
/* reset bit TB et RB */
csr = TB_BIT + RB_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in clr RB+TB");
/* fill data */
for (i = 0; i < seuil; i++)
data[i] = (i * (0xffff / seuil)) + ((0xffff / seuil) * l + l);
l = 1;
while (go_on) {
print (1, "%c%c", '|' + (l & 0xfffe), dir);
print (2, "Test avec %4d mots\n", l);
/* reset receive pointer */
csr = RRP_BIT;
if (set_csr (bc, rt, &csr, &status) == -1)
BAD ("system error in set RRP");
/* fill buffer */
if (set_rx_buf (bc, rt, l * 2, (char *) data, &status) != 0)
BAD ("system error in set_rc_buf");
/* set bits RB */
csr = RB_BIT;
if (set_csr (bc, rt, &csr, &status) == -1)
BAD ("system error in set RB");
/* wait for reponse */
if (wait_for_csr (TB_BIT, TB_BIT, 20000, 0) == 0) {
print (1, "TIME_OUT a l'attente du Transmit Buffer plein.\n");
erreur++;
if (t_err)
continue;
}
/* reset transmit pointer */
csr = RTP_BIT;
if (set_csr (bc, rt, &csr, &status) == -1)
BAD ("system error in set RTP");
/* read reponse */
for (i = 0; i < l; i++)
buff[i] = 0;
if (get_tx_buf (bc, rt, l * 2, (char *) buff, &status) != 0)
BAD ("system error in get_tx_buf");
/* reset bit TB */
csr = TB_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1)
BAD ("system error in clr TB");
/* compare */
flag = 0;
i = l;
pts = data;
ptd = buff;
do {
if (*pts != *ptd) {
flag++;
erreur++;
convbin (*pts, (char *) str1);
convbin (*ptd, (char *) str2);
print (1, "DATA error in test_BOUNCE:\tPointer %d\n read [%s]\n write [%s]\n", i, str2, str1);
break;
}
pts++;
ptd++;
} while (--i);
if (++l > seuil)
break;
}
/* clear collision pattern LRR and NEM set */
csr = LRREQ_BIT + NEM_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in clr LRR+NEM");
if (get_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in get_csr");
if ((csr & INV_BIT) == INV_BIT) {
print (0, "Le G64 a detecte une ou plusieurs erreurs au cours du test collision\n");
erreur++;
csr = INV_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in clr INV");
if (t_err)
return t_err;
}
return (erreur);
}
int collision (void)
{
unsigned short csr, sta;
/* tell G64 to start bounce with LRR and BRD set */
print (2, "\rTest Remote collision:\n");
csr = LRREQ_BIT + BRDIS_BIT;
if (set_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in set LRR+BRD");
print (2, "LRR + BRD set in RT\r");
/* test first the receive buffer */
csr = RB_BIT;
if (set_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in set RB");
if (wait_for_csr (TB_BIT, TB_BIT, 60, 1) == 0) {
print (1, "Erreur de synchro. Le RT n'a pas mits son bit TB a 1\n");
erreur++;
return (1);
}
print (1, "Test du receive buffer");
rx_buf (); /* test receive buffer */
rx_buf (); /* test receive buffer */
rx_buf (); /* test receive buffer */
print (1, "\n");
csr = RB_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in clr RB");
/* Wait for the end of the G64 */
if (wait_for_csr (TB_BIT, 0, 60, 1) == 0) {
print (1, "Erreur de synchro. Le RT n'a pas mis son bit TB a 0\n");
erreur++;
return (1);
}
/* Then test the transmit buffer */
csr = TB_BIT;
if (set_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in set TB");
if (wait_for_csr (RB_BIT, RB_BIT, 60, 1) == 0) {
print (1, "Erreur de synchro. Le RT n'a pas mits son bit RB a 1\n");
erreur++;
return (1);
}
print (1, "Test du transmit buffer");
tx_buf (); /* test transmit buffer */
tx_buf (); /* test transmit buffer */
tx_buf (); /* test transmit buffer */
print (1, "\n");
csr = TB_BIT;
if (clr_csr (bc, rt, &csr, &sta) == -1)
BAD1 ("system error in clr TB");
/* Wait for the end of the G64 */
if (wait_for_csr (RB_BIT, 0, 60, 1) == 0) {
print (1, "Erreur de synchro. Le RT n'a pas mis son bit RB a 0\n");
return (1);
}
/* clear collision pattern LRR and BRD set */
csr = LRREQ_BIT + BRDIS_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in clr LRR+BRD");
if (get_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in get_csr");
if ((csr & INV_BIT) == INV_BIT) {
print (0, "Le G64 a detecte une ou plusieurs erreurs au cours du test collision\n");
erreur++;
csr = INV_BIT;
if (clr_csr (bc, rt, &csr, &status) == -1)
BAD1 ("system error in clr INV");
if (t_err)
return t_err;
}
return (erreur);
}
/*------------------------------------------------------------------------------
* Enabler all interrupts.
*/
void __enable_irq(void) {
set_csr(mstatus, MSTATUS_MIE);
}
