GNUBoot
/
coreboot-kgpe-d16
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

riscv: Clean up {qemu,spike}_util 

spike_util.h:
 - (LOG_)REGBYTES and STORE are already defined in
   arch/riscv/include/bits.h.
 - TOHOST_CMD, FROMHOST_* are helper macros for the deprecated
   Host-Target Interface (HTIF).

qemu_util.c:
 - mcall_query_memory now uses mprv_write_ulong instead of first
   translating the address and then accessing it normally. Thus,
   translate_address isn't used anymore.
 - Several functions used the deprecated HTIF CSRs mtohost/mfromhost.
   They have mostly been replaced by stub implementations.
 - htif_interrupt and testPrint were unused and have been deleted.

spike_util.c:
 - translate_address and testPrint were unused and have been deleted.

After this commit, spike_util.c and qemu_util.c are exactly the same and
can be moved to a common location.

Change-Id: I1789bad8bbab964c3f2f0480de8d97588c68ceaf
Signed-off-by: Jonathan Neuschäfer <j.neuschaefer@gmx.net>
Reviewed-on: https://review.coreboot.org/16985
Tested-by: build bot (Jenkins)
Reviewed-by: Ronald G. Minnich <rminnich@gmail.com>
This commit is contained in:
Jonathan Neuschäfer 2016-10-12 00:18:00 +02:00 committed by Ronald G. Minnich
parent 2af174a7dc
commit e2e40cc17e
3 changed files with 13 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/arch/riscv/include/spike_util.h
View File

@ -16,25 +16,13 @@
#ifndef _SPIKE_UTIL_H #ifndef _SPIKE_UTIL_H
#define _SPIKE_UTIL_H #define _SPIKE_UTIL_H
#include <stdint.h>
//#include <string.h>
//#include <errno.h>
#include <arch/encoding.h> #include <arch/encoding.h>
#include <atomic.h> #include <atomic.h>
#include <stdint.h>
#define LOG_REGBYTES 3
#define REGBYTES (1 << LOG_REGBYTES)
#define STORE sd
#define HLS_SIZE 64 #define HLS_SIZE 64
#define MENTRY_FRAME_SIZE HLS_SIZE #define MENTRY_FRAME_SIZE HLS_SIZE
#define TOHOST_CMD(dev, cmd, payload) \
(((uint64_t)(dev) << 56) | ((uint64_t)(cmd) << 48) | (uint64_t)(payload))
#define FROMHOST_DEV(fromhost_value) ((uint64_t)(fromhost_value) >> 56)
#define FROMHOST_CMD(fromhost_value) ((uint64_t)(fromhost_value) << 8 >> 56)
#define FROMHOST_DATA(fromhost_value) ((uint64_t)(fromhost_value) << 16 >> 16)
typedef struct { typedef struct {
unsigned long base; unsigned long base;
unsigned long size; unsigned long size;
@ -69,12 +57,8 @@ typedef struct {
#define MACHINE_STACK_SIZE RISCV_PGSIZE #define MACHINE_STACK_SIZE RISCV_PGSIZE
uintptr_t translate_address(uintptr_t vAddr);
uintptr_t mcall_query_memory(uintptr_t id, memory_block_info *p); uintptr_t mcall_query_memory(uintptr_t id, memory_block_info *p);
uintptr_t mcall_hart_id(void);
uintptr_t htif_interrupt(uintptr_t mcause, uintptr_t* regs);
uintptr_t mcall_console_putchar(uint8_t ch); uintptr_t mcall_console_putchar(uint8_t ch);
void testPrint(void);
uintptr_t mcall_dev_req(sbi_device_message *m); uintptr_t mcall_dev_req(sbi_device_message *m);
uintptr_t mcall_dev_resp(void); uintptr_t mcall_dev_resp(void);
uintptr_t mcall_set_timer(unsigned long long when); uintptr_t mcall_set_timer(unsigned long long when);

136
src/mainboard/emulation/qemu-riscv/qemu_util.c
View File

@ -31,23 +31,15 @@
#include <console/console.h> #include <console/console.h>
#include <spike_util.h> #include <spike_util.h>
#include <string.h> #include <string.h>
#include <vm.h>
uintptr_t translate_address(uintptr_t vAddr) { uintptr_t mcall_query_memory(uintptr_t id, memory_block_info *info)
// TODO: implement the page table translation algorithm
//uintptr_t pageTableRoot = read_csr(sptbr);
uintptr_t physAddrMask = 0xfffffff;
uintptr_t translationResult = vAddr & physAddrMask;
printk(BIOS_DEBUG, "Translated virtual address 0x%llx to physical address 0x%llx\n", vAddr, translationResult);
return translationResult;
}
uintptr_t mcall_query_memory(uintptr_t id, memory_block_info *p)
{ {
uintptr_t physicalAddr = translate_address((uintptr_t) p);
memory_block_info *info = (memory_block_info*) physicalAddr;
if (id == 0) { if (id == 0) {
info->base = 0x1000000; // hard coded for now, but we can put these values somewhere later mprv_write_ulong(&info->base, 2U*GiB);
info->size = 0x7F000000 - info->base;
/* TODO: Return the correct value */
mprv_write_ulong(&info->size, 1*GiB);
return 0; return 0;
} }
@ -73,55 +65,26 @@ uintptr_t mcall_clear_ipi(void)
uintptr_t mcall_shutdown(void) uintptr_t mcall_shutdown(void)
{ {
while (1) write_csr(mtohost, 1); die("mcall_shutdown is currently not implemented");
return 0; return 0;
} }
uintptr_t mcall_set_timer(unsigned long long when) uintptr_t mcall_set_timer(unsigned long long when)
{ {
write_csr(mtimecmp, when); printk(BIOS_DEBUG, "mcall_set_timer is currently not implemented, ignoring\n");
clear_csr(mip, MIP_STIP);
set_csr(mie, MIP_MTIP);
return 0; return 0;
} }
uintptr_t mcall_dev_req(sbi_device_message *m) uintptr_t mcall_dev_req(sbi_device_message *m)
{ {
if ((m->dev > 0xFFU) | (m->cmd > 0xFFU) | (m->data > 0x0000FFFFFFFFFFFFU)) return -EINVAL; die("mcall_dev_req is currently not implemented");
while (swap_csr(mtohost, TOHOST_CMD(m->dev, m->cmd, m->data)) != 0);
m->sbi_private_data = (uintptr_t)HLS()->device_request_queue_head;
HLS()->device_request_queue_head = m;
HLS()->device_request_queue_size++;
return 0; return 0;
} }
uintptr_t mcall_dev_resp(void) uintptr_t mcall_dev_resp(void)
{ {
htif_interrupt(0, 0); die("mcall_dev_resp is currently not implemented");
return 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;
}
uintptr_t mcall_hart_id(void)
{
return HLS()->hart_id;
} }
void hls_init(uint32_t hart_id) void hls_init(uint32_t hart_id)
@ -130,83 +93,8 @@ void hls_init(uint32_t hart_id)
HLS()->hart_id = hart_id; HLS()->hart_id = hart_id;
} }
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");
}
uintptr_t mcall_console_putchar(uint8_t ch) uintptr_t mcall_console_putchar(uint8_t ch)
{ {
while (swap_csr(mtohost, TOHOST_CMD(1, 1, ch)) != 0); do_putchar(ch);
while (1) {
uintptr_t fromhost = read_csr(mfromhost);
if (FROMHOST_DEV(fromhost) != 1 || FROMHOST_CMD(fromhost) != 1) {
if (fromhost)
htif_interrupt(0, 0);
continue;
}
write_csr(mfromhost, 0);
break;
}
return 0; return 0;
} }
void testPrint(void) {
/* Print a test command to check Spike console output */
mcall_console_putchar('h');
mcall_console_putchar('e');
mcall_console_putchar('l');
mcall_console_putchar('l');
mcall_console_putchar('o');
mcall_console_putchar('\n');
}

19
src/mainboard/emulation/spike-riscv/spike_util.c
View File

@ -33,15 +33,6 @@
#include <string.h> #include <string.h>
#include <vm.h> #include <vm.h>
uintptr_t translate_address(uintptr_t vAddr) {
// TODO: implement the page table translation algorithm
//uintptr_t pageTableRoot = read_csr(sptbr);
uintptr_t physAddrMask = 0xfffffff;
uintptr_t translationResult = vAddr & physAddrMask;
printk(BIOS_DEBUG, "Translated virtual address 0x%llx to physical address 0x%llx\n", vAddr, translationResult);
return translationResult;
}
uintptr_t mcall_query_memory(uintptr_t id, memory_block_info *info) uintptr_t mcall_query_memory(uintptr_t id, memory_block_info *info)
{ {
if (id == 0) { if (id == 0) {
@ -107,13 +98,3 @@ uintptr_t mcall_console_putchar(uint8_t ch)
do_putchar(ch); do_putchar(ch);
return 0; return 0;
} }
void testPrint(void) {
/* Print a test command to check Spike console output */
mcall_console_putchar('h');
mcall_console_putchar('e');
mcall_console_putchar('l');
mcall_console_putchar('l');
mcall_console_putchar('o');
mcall_console_putchar('\n');
}