sysadmin/ipxe
1
0
Fork 0
mirror of https://github.com/ipxe/ipxe synced 2026-04-04 03:00:20 +03:00
Code Issues Packages Projects Releases Wiki Activity

[riscv] Add support for the RISC-V CPU architecture

Browse Source 
Add support for building iPXE as a 64-bit or 32-bit RISC-V binary, for
either UEFI or Linux userspace platforms.  For example:

  # RISC-V 64-bit UEFI
  make CROSS=riscv64-linux-gnu- bin-riscv64-efi/ipxe.efi

  # RISC-V 32-bit UEFI
  make CROSS=riscv64-linux-gnu- bin-riscv32-efi/ipxe.efi

  # RISC-V 64-bit Linux
  make CROSS=riscv64-linux-gnu- bin-riscv64-linux/tests.linux
  qemu-riscv64 -L /usr/riscv64-linux-gnu/sys-root \
               ./bin-riscv64-linux/tests.linux

  # RISC-V 32-bit Linux
  make CROSS=riscv64-linux-gnu- SYSROOT=/usr/riscv32-linux-gnu/sys-root \
       bin-riscv32-linux/tests.linux
  qemu-riscv32 -L /usr/riscv32-linux-gnu/sys-root \
               ./bin-riscv32-linux/tests.linux

Signed-off-by: Michael Brown <mcb30@ipxe.org>
This commit is contained in:
Michael Brown
2024-09-15 10:54:04 +01:00
parent 68db9a3cb3
commit c215048dda
42 changed files with 2405 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/arch/riscv/Makefile Normal file
View File

@@ -0,0 +1,20 @@
# Assembler section type character
#
ASM_TCHAR := @
ASM_TCHAR_OPS := @
# Include RISCV-specific headers
#
INCDIRS := arch/$(ARCH)/include arch/riscv/include $(INCDIRS)
# RISCV-specific directories containing source files
#
SRCDIRS += arch/riscv/core
# RISCV-specific flags
#
CFLAGS += -mno-strict-align -mno-plt
# EFI requires -fshort-wchar, and nothing else currently uses wchar_t
#
CFLAGS += -fshort-wchar

10
src/arch/riscv/Makefile.efi Normal file
View File

@@ -0,0 +1,10 @@
# -*- makefile -*- : Force emacs to use Makefile mode
# RISCV-specific flags
#
CFLAGS += -mcmodel=medany
# Include generic EFI Makefile
#
MAKEDEPS += Makefile.efi
include Makefile.efi

6
src/arch/riscv/Makefile.linux Normal file
View File

@@ -0,0 +1,6 @@
# -*- makefile -*- : Force emacs to use Makefile mode
# Include generic Linux Makefile
#
MAKEDEPS += Makefile.linux
include Makefile.linux

112
src/arch/riscv/core/riscv_bigint.c Normal file
View File

@@ -0,0 +1,112 @@
/*
* Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdint.h>
#include <string.h>
#include <ipxe/bigint.h>
/** @file
*
* Big integer support
*/
/**
* Multiply big integers
*
* @v multiplicand0 Element 0 of big integer to be multiplied
* @v multiplicand_size Number of elements in multiplicand
* @v multiplier0 Element 0 of big integer to be multiplied
* @v multiplier_size Number of elements in multiplier
* @v result0 Element 0 of big integer to hold result
*/
void bigint_multiply_raw ( const unsigned long *multiplicand0,
unsigned int multiplicand_size,
const unsigned long *multiplier0,
unsigned int multiplier_size,
unsigned long *result0 ) {
unsigned int result_size = ( multiplicand_size + multiplier_size );
const bigint_t ( multiplicand_size ) __attribute__ (( may_alias ))
*multiplicand = ( ( const void * ) multiplicand0 );
const bigint_t ( multiplier_size ) __attribute__ (( may_alias ))
*multiplier = ( ( const void * ) multiplier0 );
bigint_t ( result_size ) __attribute__ (( may_alias ))
*result = ( ( void * ) result0 );
unsigned int i;
unsigned int j;
unsigned long multiplicand_element;
unsigned long multiplier_element;
unsigned long *result_elements;
unsigned long discard_low;
unsigned long discard_high;
unsigned long discard_temp;
unsigned long discard_carry;
/* Zero result */
memset ( result, 0, sizeof ( *result ) );
/* Multiply integers one element at a time */
for ( i = 0 ; i < multiplicand_size ; i++ ) {
multiplicand_element = multiplicand->element[i];
for ( j = 0 ; j < multiplier_size ; j++ ) {
multiplier_element = multiplier->element[j];
result_elements = &result->element[ i + j ];
/* Perform a single multiply, and add the
* resulting double-element into the result,
* carrying as necessary. The carry can
* never overflow beyond the end of the
* result, since:
*
* a < 2^{n}, b < 2^{m} => ab < 2^{n+m}
*/
__asm__ __volatile__ ( /* Perform multiplication */
"mulhu %2, %6, %7\n\t"
"mul %1, %6, %7\n\t"
/* Accumulate low half */
LOADN " %3, (%0)\n\t"
"add %3, %3, %1\n\t"
"sltu %4, %3, %1\n\t"
STOREN " %3, 0(%0)\n\t"
/* Carry into high half */
"add %4, %4, %2\n\t"
/* Propagate as necessary */
"\n1:\n\t"
"addi %0, %0, %8\n\t"
LOADN " %3, 0(%0)\n\t"
"add %3, %3, %4\n\t"
"sltu %4, %3, %4\n\t"
STOREN " %3, 0(%0)\n\t"
"bnez %4, 1b\n\t"
: "+r" ( result_elements ),
"=r" ( discard_low ),
"=r" ( discard_high ),
"=r" ( discard_temp ),
"=r" ( discard_carry ),
"+m" ( *result )
: "r" ( multiplicand_element ),
"r" ( multiplier_element ),
"i" ( sizeof ( *result0 ) ) );
}
}
}

46
src/arch/riscv/core/riscv_io.c Normal file
View File

@@ -0,0 +1,46 @@
/*
* Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <ipxe/io.h>
#include <ipxe/riscv_io.h>
/** @file
*
* iPXE I/O API for RISC-V
*
*/
PROVIDE_IOAPI_INLINE ( riscv, phys_to_bus );
PROVIDE_IOAPI_INLINE ( riscv, bus_to_phys );
PROVIDE_IOAPI_INLINE ( riscv, readb );
PROVIDE_IOAPI_INLINE ( riscv, readw );
PROVIDE_IOAPI_INLINE ( riscv, readl );
PROVIDE_IOAPI_INLINE ( riscv, writeb );
PROVIDE_IOAPI_INLINE ( riscv, writew );
PROVIDE_IOAPI_INLINE ( riscv, writel );
PROVIDE_IOAPI_INLINE ( riscv, readq );
PROVIDE_IOAPI_INLINE ( riscv, writeq );
PROVIDE_IOAPI_INLINE ( riscv, mb );
PROVIDE_DUMMY_PIO ( riscv );

272
src/arch/riscv/core/riscv_string.c Normal file
View File

@@ -0,0 +1,272 @@
/*
* Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
/** @file
*
* Optimised string operations
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <string.h>
/**
* Copy memory area
*
* @v dest Destination address
* @v src Source address
* @v len Length
* @ret dest Destination address
*/
void riscv_memcpy ( void *dest, const void *src, size_t len ) {
size_t len_pre;
size_t len_mid;
size_t len_post;
unsigned long discard_data;
/* Calculate pre-aligned, aligned, and post-aligned lengths.
* (Align on the destination address, on the assumption that
* misaligned stores are likely to be more expensive than
* misaligned loads.)
*/
len_pre = ( ( sizeof ( unsigned long ) - ( ( intptr_t ) dest ) ) &
( sizeof ( unsigned long ) - 1 ) );
if ( len_pre > len )
len_pre = len;
len -= len_pre;
len_mid = ( len & ~( sizeof ( unsigned long ) - 1 ) );
len -= len_mid;
len_post = len;
/* Copy pre-aligned section */
__asm__ __volatile__ ( "j 2f\n\t"
"\n1:\n\t"
"lb %2, (%1)\n\t"
"sb %2, (%0)\n\t"
"addi %0, %0, 1\n\t"
"addi %1, %1, 1\n\t"
"\n2:\n\t"
"bne %0, %3, 1b\n\t"
: "+r" ( dest ), "+r" ( src ),
"=&r" ( discard_data )
: "r" ( dest + len_pre )
: "memory" );
/* Copy aligned section */
__asm__ __volatile__ ( "j 2f\n\t"
"\n1:\n\t"
LOADN " %2, (%1)\n\t"
STOREN " %2, (%0)\n\t"
"addi %0, %0, %4\n\t"
"addi %1, %1, %4\n\t"
"\n2:\n\t"
"bne %0, %3, 1b\n\t"
: "+r" ( dest ), "+r" ( src ),
"=&r" ( discard_data )
: "r" ( dest + len_mid ),
"i" ( sizeof ( unsigned long ) )
: "memory" );
/* Copy post-aligned section */
__asm__ __volatile__ ( "j 2f\n\t"
"\n1:\n\t"
"lb %2, (%1)\n\t"
"sb %2, (%0)\n\t"
"addi %0, %0, 1\n\t"
"addi %1, %1, 1\n\t"
"\n2:\n\t"
"bne %0, %3, 1b\n\t"
: "+r" ( dest ), "+r" ( src ),
"=&r" ( discard_data )
: "r" ( dest + len_post )
: "memory" );
}
/**
* Zero memory region
*
* @v dest Destination region
* @v len Length
*/
void riscv_bzero ( void *dest, size_t len ) {
size_t len_pre;
size_t len_mid;
size_t len_post;
/* Calculate pre-aligned, aligned, and post-aligned lengths */
len_pre = ( ( sizeof ( unsigned long ) - ( ( intptr_t ) dest ) ) &
( sizeof ( unsigned long ) - 1 ) );
if ( len_pre > len )
len_pre = len;
len -= len_pre;
len_mid = ( len & ~( sizeof ( unsigned long ) - 1 ) );
len -= len_mid;
len_post = len;
/* Zero pre-aligned section */
__asm__ __volatile__ ( "j 2f\n\t"
"\n1:\n\t"
"sb zero, (%0)\n\t"
"addi %0, %0, 1\n\t"
"\n2:\n\t"
"bne %0, %1, 1b\n\t"
: "+r" ( dest )
: "r" ( dest + len_pre )
: "memory" );
/* Zero aligned section */
__asm__ __volatile__ ( "j 2f\n\t"
"\n1:\n\t"
STOREN " zero, (%0)\n\t"
"addi %0, %0, %2\n\t"
"\n2:\n\t"
"bne %0, %1, 1b\n\t"
: "+r" ( dest )
: "r" ( dest + len_mid ),
"i" ( sizeof ( unsigned long ) )
: "memory" );
/* Zero post-aligned section */
__asm__ __volatile__ ( "j 2f\n\t"
"\n1:\n\t"
"sb zero, (%0)\n\t"
"addi %0, %0, 1\n\t"
"\n2:\n\t"
"bne %0, %1, 1b\n\t"
: "+r" ( dest )
: "r" ( dest + len_post )
: "memory" );
}
/**
* Fill memory region
*
* @v dest Destination region
* @v len Length
* @v character Fill character
*
* The unusual parameter order is to allow for more efficient
* tail-calling to riscv_bzero() when zeroing a region.
*/
void riscv_memset ( void *dest, size_t len, int character ) {
/* Do nothing if length is zero */
if ( ! len )
return;
/* Use optimised zeroing code if applicable */
if ( character == 0 ) {
riscv_bzero ( dest, len );
return;
}
/* Fill one byte at a time. Calling memset() with a non-zero
* value is relatively rare and unlikely to be
* performance-critical.
*/
__asm__ __volatile__ ( "\n1:\n\t"
"sb %2, (%0)\n\t"
"addi %0, %0, 1\n\t"
"bne %0, %1, 1b\n\t"
: "+r" ( dest )
: "r" ( dest + len ), "r" ( character )
: "memory" );
}
/**
* Copy (possibly overlapping) memory region forwards
*
* @v dest Destination region
* @v src Source region
* @v len Length
*/
void riscv_memmove_forwards ( void *dest, const void *src, size_t len ) {
unsigned long discard_data;
/* Do nothing if length is zero */
if ( ! len )
return;
/* Assume memmove() is not performance-critical, and perform a
* bytewise copy for simplicity.
*/
__asm__ __volatile__ ( "\n1:\n\t"
"lb %2, (%1)\n\t"
"sb %2, (%0)\n\t"
"addi %1, %1, 1\n\t"
"addi %0, %0, 1\n\t"
"bne %0, %3, 1b\n\t"
: "+r" ( dest ), "+r" ( src ),
"=&r" ( discard_data )
: "r" ( dest + len )
: "memory" );
}
/**
* Copy (possibly overlapping) memory region backwards
*
* @v dest Destination region
* @v src Source region
* @v len Length
*/
void riscv_memmove_backwards ( void *dest, const void *src, size_t len ) {
void *orig_dest = dest;
unsigned long discard_data;
/* Do nothing if length is zero */
if ( ! len )
return;
/* Assume memmove() is not performance-critical, and perform a
* bytewise copy for simplicity.
*/
dest += len;
src += len;
__asm__ __volatile__ ( "\n1:\n\t"
"addi %1, %1, -1\n\t"
"addi %0, %0, -1\n\t"
"lb %2, (%1)\n\t"
"sb %2, (%0)\n\t"
"bne %0, %3, 1b\n\t"
: "+r" ( dest ), "+r" ( src ),
"=&r" ( discard_data )
: "r" ( orig_dest )
: "memory" );
}
/**
* Copy (possibly overlapping) memory region
*
* @v dest Destination region
* @v src Source region
* @v len Length
*/
void riscv_memmove ( void *dest, const void *src, size_t len ) {
if ( dest <= src ) {
riscv_memmove_forwards ( dest, src, len );
} else {
riscv_memmove_backwards ( dest, src, len );
}
}

70
src/arch/riscv/core/riscv_strings.S Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
/** @file
*
* Byte swapping
*
*/
.section ".note.GNU-stack", "", @progbits
.text
/**
* Find first (i.e. least significant) set bit
*
* @v value Value
* @ret lsb Least significant bit set in value (LSB=1), or zero
*/
.section ".text.riscv_ffs"
.globl riscv_ffs
riscv_ffs:
beqz a0, 2f
mv t0, a0
li a0, ( __riscv_xlen + 1 )
1: slli t0, t0, 1
addi a0, a0, -1
bnez t0, 1b
2: ret
.size riscv_ffs, . - riscv_ffs
/**
* Find last (i.e. most significant) set bit
*
* @v value Value
* @ret msb Most significant bit set in value (LSB=1), or zero
*/
.section ".text.riscv_fls"
.globl riscv_fls
riscv_fls:
beqz a0, 2f
mv t0, a0
li a0, __riscv_xlen
bltz t0, 2f
1: slli t0, t0, 1
addi a0, a0, -1
bgez t0, 1b
2: ret
.size riscv_fls, . - riscv_fls

105
src/arch/riscv/core/setjmp.S Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright (C) 2024 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
/** @file
*
* Long jumps
*
*/
.section ".note.GNU-stack", "", @progbits
.text
/* Must match jmp_buf structure layout */
.struct 0
env_ra: .space ( __riscv_xlen / 8 )
env_sp: .space ( __riscv_xlen / 8 )
env_s0: .space ( __riscv_xlen / 8 )
env_s1: .space ( __riscv_xlen / 8 )
env_s2: .space ( __riscv_xlen / 8 )
env_s3: .space ( __riscv_xlen / 8 )
env_s4: .space ( __riscv_xlen / 8 )
env_s5: .space ( __riscv_xlen / 8 )
env_s6: .space ( __riscv_xlen / 8 )
env_s7: .space ( __riscv_xlen / 8 )
env_s8: .space ( __riscv_xlen / 8 )
env_s9: .space ( __riscv_xlen / 8 )
env_s10: .space ( __riscv_xlen / 8 )
env_s11: .space ( __riscv_xlen / 8 )
.previous
/*
* Save stack context for non-local goto
*/
.section ".text.setjmp", "ax", @progbits
.globl setjmp
setjmp:
/* Save registers */
STOREN ra, env_ra(a0)
STOREN sp, env_sp(a0)
STOREN s0, env_s0(a0)
STOREN s1, env_s1(a0)
STOREN s2, env_s2(a0)
STOREN s3, env_s3(a0)
STOREN s4, env_s4(a0)
STOREN s5, env_s5(a0)
STOREN s6, env_s6(a0)
STOREN s7, env_s7(a0)
STOREN s8, env_s8(a0)
STOREN s9, env_s9(a0)
STOREN s10, env_s10(a0)
STOREN s11, env_s11(a0)
/* Return zero when returning as setjmp() */
mv a0, zero
ret
.size setjmp, . - setjmp
/*
* Non-local jump to a saved stack context
*/
.section ".text.longjmp", "ax", @progbits
.globl longjmp
longjmp:
/* Restore registers */
LOADN s11, env_s11(a0)
LOADN s10, env_s10(a0)
LOADN s9, env_s9(a0)
LOADN s8, env_s8(a0)
LOADN s7, env_s7(a0)
LOADN s6, env_s6(a0)
LOADN s5, env_s5(a0)
LOADN s4, env_s4(a0)
LOADN s3, env_s3(a0)
LOADN s2, env_s2(a0)
LOADN s1, env_s1(a0)
LOADN s0, env_s0(a0)
LOADN sp, env_sp(a0)
LOADN ra, env_ra(a0)
/* Force result to non-zero */
seqz a0, a1
or a0, a0, a1
/* Return to setjmp() caller */
ret
.size longjmp, . - longjmp

362
src/arch/riscv/include/bits/bigint.h Normal file
View File

@@ -0,0 +1,362 @@
#ifndef _BITS_BIGINT_H
#define _BITS_BIGINT_H
/** @file
*
* Big integer support
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdint.h>
#include <string.h>
#include <strings.h>
/** Element of a big integer */
typedef unsigned long bigint_element_t;
/**
* Initialise big integer
*
* @v value0 Element 0 of big integer to initialise
* @v size Number of elements
* @v data Raw data
* @v len Length of raw data
*/
static inline __attribute__ (( always_inline )) void
bigint_init_raw ( unsigned long *value0, unsigned int size,
const void *data, size_t len ) {
size_t pad_len = ( sizeof ( bigint_t ( size ) ) - len );
uint8_t *value_byte = ( ( void * ) value0 );
const uint8_t *data_byte = ( data + len );
/* Copy raw data in reverse order, padding with zeros */
while ( len-- )
*(value_byte++) = *(--data_byte);
while ( pad_len-- )
*(value_byte++) = 0;
}
/**
* Add big integers
*
* @v addend0 Element 0 of big integer to add
* @v value0 Element 0 of big integer to be added to
* @v size Number of elements
*/
static inline __attribute__ (( always_inline )) void
bigint_add_raw ( const unsigned long *addend0, unsigned long *value0,
unsigned int size ) {
bigint_t ( size ) __attribute__ (( may_alias )) *value =
( ( void * ) value0 );
unsigned long *valueN = ( value0 + size );
unsigned long *discard_addend;
unsigned long *discard_value;
unsigned long discard_addend_i;
unsigned long discard_value_i;
unsigned long discard_carry;
unsigned long discard_temp;
__asm__ __volatile__ ( "\n1:\n\t"
/* Load addend[i] and value[i] */
LOADN " %2, (%0)\n\t"
LOADN " %3, (%1)\n\t"
/* Add carry flag and addend */
"add %3, %3, %4\n\t"
"sltu %5, %3, %4\n\t"
"add %3, %3, %2\n\t"
"sltu %4, %3, %2\n\t"
"or %4, %4, %5\n\t"
/* Store value[i] */
STOREN " %3, (%1)\n\t"
/* Loop */
"addi %0, %0, %8\n\t"
"addi %1, %1, %8\n\t"
"bne %1, %7, 1b\n\t"
: "=&r" ( discard_addend ),
"=&r" ( discard_value ),
"=&r" ( discard_addend_i ),
"=&r" ( discard_value_i ),
"=&r" ( discard_carry ),
"=&r" ( discard_temp ),
"+m" ( *value )
: "r" ( valueN ),
"i" ( sizeof ( unsigned long ) ),
"0" ( addend0 ), "1" ( value0 ), "4" ( 0 ) );
}
/**
* Subtract big integers
*
* @v subtrahend0 Element 0 of big integer to subtract
* @v value0 Element 0 of big integer to be subtracted from
* @v size Number of elements
*/
static inline __attribute__ (( always_inline )) void
bigint_subtract_raw ( const unsigned long *subtrahend0, unsigned long *value0,
unsigned int size ) {
bigint_t ( size ) __attribute__ (( may_alias )) *value =
( ( void * ) value0 );
unsigned long *valueN = ( value0 + size );
unsigned long *discard_subtrahend;
unsigned long *discard_value;
unsigned long discard_subtrahend_i;
unsigned long discard_value_i;
unsigned long discard_carry;
unsigned long discard_temp;
__asm__ __volatile__ ( "\n1:\n\t"
/* Load subtrahend[i] and value[i] */
LOADN " %2, (%0)\n\t"
LOADN " %3, (%1)\n\t"
/* Subtract carry flag and subtrahend */
"sltu %5, %3, %4\n\t"
"sub %3, %3, %4\n\t"
"sltu %4, %3, %2\n\t"
"sub %3, %3, %2\n\t"
"or %4, %4, %5\n\t"
/* Store value[i] */
STOREN " %3, (%1)\n\t"
/* Loop */
"addi %0, %0, %8\n\t"
"addi %1, %1, %8\n\t"
"bne %1, %7, 1b\n\t"
: "=&r" ( discard_subtrahend ),
"=&r" ( discard_value ),
"=&r" ( discard_subtrahend_i ),
"=&r" ( discard_value_i ),
"=&r" ( discard_carry ),
"=&r" ( discard_temp ),
"+m" ( *value )
: "r" ( valueN ),
"i" ( sizeof ( unsigned long ) ),
"0" ( subtrahend0 ), "1" ( value0 ),
"4" ( 0 ) );
}
/**
* Rotate big integer left
*
* @v value0 Element 0 of big integer
* @v size Number of elements
*/
static inline __attribute__ (( always_inline )) void
bigint_rol_raw ( unsigned long *value0, unsigned int size ) {
bigint_t ( size ) __attribute__ (( may_alias )) *value =
( ( void * ) value0 );
unsigned long *valueN = ( value0 + size );
unsigned long *discard_value;
unsigned long discard_value_i;
unsigned long discard_carry;
unsigned long discard_temp;
__asm__ __volatile__ ( "\n1:\n\t"
/* Load value[i] */
LOADN " %1, (%0)\n\t"
/* Shift left */
"slli %3, %1, 1\n\t"
"or %3, %3, %2\n\t"
"srli %2, %1, %7\n\t"
/* Store value[i] */
STOREN " %3, (%0)\n\t"
/* Loop */
"addi %0, %0, %6\n\t"
"bne %0, %5, 1b\n\t"
: "=&r" ( discard_value ),
"=&r" ( discard_value_i ),
"=&r" ( discard_carry ),
"=&r" ( discard_temp ),
"+m" ( *value )
: "r" ( valueN ),
"i" ( sizeof ( unsigned long ) ),
"i" ( ( 8 * sizeof ( unsigned long ) - 1 ) ),
"0" ( value0 ), "2" ( 0 ) );
}
/**
* Rotate big integer right
*
* @v value0 Element 0 of big integer
* @v size Number of elements
*/
static inline __attribute__ (( always_inline )) void
bigint_ror_raw ( unsigned long *value0, unsigned int size ) {
bigint_t ( size ) __attribute__ (( may_alias )) *value =
( ( void * ) value0 );
unsigned long *valueN = ( value0 + size );
unsigned long *discard_value;
unsigned long discard_value_i;
unsigned long discard_carry;
unsigned long discard_temp;
__asm__ __volatile__ ( "\n1:\n\t"
/* Load value[i] */
LOADN " %1, %6(%0)\n\t"
/* Shift right */
"srli %3, %1, 1\n\t"
"or %3, %3, %2\n\t"
"slli %2, %1, %7\n\t"
/* Store value[i] */
STOREN " %3, %6(%0)\n\t"
/* Loop */
"addi %0, %0, %6\n\t"
"bne %0, %5, 1b\n\t"
: "=&r" ( discard_value ),
"=&r" ( discard_value_i ),
"=&r" ( discard_carry ),
"=&r" ( discard_temp ),
"+m" ( *value )
: "r" ( value0 ),
"i" ( -( sizeof ( unsigned long ) ) ),
"i" ( ( 8 * sizeof ( unsigned long ) - 1 ) ),
"0" ( valueN ), "2" ( 0 ) );
}
/**
* Test if big integer is equal to zero
*
* @v value0 Element 0 of big integer
* @v size Number of elements
* @ret is_zero Big integer is equal to zero
*/
static inline __attribute__ (( always_inline, pure )) int
bigint_is_zero_raw ( const unsigned long *value0, unsigned int size ) {
const unsigned long *value = value0;
unsigned long value_i;
do {
value_i = *(value++);
if ( value_i )
break;
} while ( --size );
return ( value_i == 0 );
}
/**
* Compare big integers
*
* @v value0 Element 0 of big integer
* @v reference0 Element 0 of reference big integer
* @v size Number of elements
* @ret geq Big integer is greater than or equal to the reference
*/
static inline __attribute__ (( always_inline, pure )) int
bigint_is_geq_raw ( const unsigned long *value0,
const unsigned long *reference0, unsigned int size ) {
const unsigned long *value = ( value0 + size );
const unsigned long *reference = ( reference0 + size );
unsigned long value_i;
unsigned long reference_i;
do {
value_i = *(--value);
reference_i = *(--reference);
if ( value_i != reference_i )
break;
} while ( --size );
return ( value_i >= reference_i );
}
/**
* Test if bit is set in big integer
*
* @v value0 Element 0 of big integer
* @v size Number of elements
* @v bit Bit to test
* @ret is_set Bit is set
*/
static inline __attribute__ (( always_inline )) int
bigint_bit_is_set_raw ( const unsigned long *value0, unsigned int size,
unsigned int bit ) {
const bigint_t ( size ) __attribute__ (( may_alias )) *value =
( ( const void * ) value0 );
unsigned int index = ( bit / ( 8 * sizeof ( *value0 ) ) );
unsigned int subindex = ( bit % ( 8 * sizeof ( *value0 ) ) );
return ( !! ( value->element[index] & ( 1UL << subindex ) ) );
}
/**
* Find highest bit set in big integer
*
* @v value0 Element 0 of big integer
* @v size Number of elements
* @ret max_bit Highest bit set + 1 (or 0 if no bits set)
*/
static inline __attribute__ (( always_inline )) int
bigint_max_set_bit_raw ( const unsigned long *value0, unsigned int size ) {
const unsigned long *value = ( value0 + size );
int max_bit = ( 8 * sizeof ( bigint_t ( size ) ) );
unsigned long value_i;
do {
value_i = *(--value);
max_bit -= ( ( 8 * sizeof ( *value0 ) ) - fls ( value_i ) );
if ( value_i )
break;
} while ( --size );
return max_bit;
}
/**
* Grow big integer
*
* @v source0 Element 0 of source big integer
* @v source_size Number of elements in source big integer
* @v dest0 Element 0 of destination big integer
* @v dest_size Number of elements in destination big integer
*/
static inline __attribute__ (( always_inline )) void
bigint_grow_raw ( const unsigned long *source0, unsigned int source_size,
unsigned long *dest0, unsigned int dest_size ) {
unsigned int pad_size = ( dest_size - source_size );
memcpy ( dest0, source0, sizeof ( bigint_t ( source_size ) ) );
memset ( ( dest0 + source_size ), 0, sizeof ( bigint_t ( pad_size ) ) );
}
/**
* Shrink big integer
*
* @v source0 Element 0 of source big integer
* @v source_size Number of elements in source big integer
* @v dest0 Element 0 of destination big integer
* @v dest_size Number of elements in destination big integer
*/
static inline __attribute__ (( always_inline )) void
bigint_shrink_raw ( const unsigned long *source0,
unsigned int source_size __unused,
unsigned long *dest0, unsigned int dest_size ) {
memcpy ( dest0, source0, sizeof ( bigint_t ( dest_size ) ) );
}
/**
* Finalise big integer
*
* @v value0 Element 0 of big integer to finalise
* @v size Number of elements
* @v out Output buffer
* @v len Length of output buffer
*/
static inline __attribute__ (( always_inline )) void
bigint_done_raw ( const unsigned long *value0, unsigned int size __unused,
void *out, size_t len ) {
const uint8_t *value_byte = ( ( const void * ) value0 );
uint8_t *out_byte = ( out + len );
/* Copy raw data in reverse order */
while ( len-- )
*(--out_byte) = *(value_byte++);
}
extern void bigint_multiply_raw ( const unsigned long *multiplicand0,
unsigned int multiplicand_size,
const unsigned long *multiplier0,
unsigned int multiplier_size,
unsigned long *value0 );
#endif /* _BITS_BIGINT_H */

82
src/arch/riscv/include/bits/bitops.h Normal file
View File

@@ -0,0 +1,82 @@
#ifndef _BITS_BITOPS_H
#define _BITS_BITOPS_H
/** @file
*
* RISC-V bit operations
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdint.h>
/**
* Test and set bit atomically
*
* @v bit Bit to set
* @v bits Bit field
* @ret old Old value of bit (zero or non-zero)
*/
static inline __attribute__ (( always_inline )) int
test_and_set_bit ( unsigned int bit, volatile void *bits ) {
unsigned int index = ( bit / 32 );
unsigned int offset = ( bit % 32 );
volatile uint32_t *word = ( ( ( volatile uint32_t * ) bits ) + index );
uint32_t mask = ( 1U << offset );
uint32_t old;
__asm__ __volatile__ ( "amoor.w %0, %2, %1"
: "=r" ( old ), "+A" ( *word )
: "r" ( mask ) );
return ( !! ( old & mask ) );
}
/**
* Test and clear bit atomically
*
* @v bit Bit to set
* @v bits Bit field
* @ret old Old value of bit (zero or non-zero)
*/
static inline __attribute__ (( always_inline )) int
test_and_clear_bit ( unsigned int bit, volatile void *bits ) {
unsigned int index = ( bit / 32 );
unsigned int offset = ( bit % 32 );
volatile uint32_t *word = ( ( ( volatile uint32_t * ) bits ) + index );
uint32_t mask = ( 1U << offset );
uint32_t old;
__asm__ __volatile__ ( "amoand.w %0, %2, %1"
: "=r" ( old ), "+A" ( *word )
: "r" ( ~mask ) );
return ( !! ( old & mask ) );
}
/**
* Set bit atomically
*
* @v bit Bit to set
* @v bits Bit field
*/
static inline __attribute__ (( always_inline )) void
set_bit ( unsigned int bit, volatile void *bits ) {
test_and_set_bit ( bit, bits );
}
/**
* Clear bit atomically
*
* @v bit Bit to set
* @v bits Bit field
*/
static inline __attribute__ (( always_inline )) void
clear_bit ( unsigned int bit, volatile void *bits ) {
test_and_clear_bit ( bit, bits );
}
#endif /* _BITS_BITOPS_H */

48
src/arch/riscv/include/bits/byteswap.h Normal file
View File

@@ -0,0 +1,48 @@
#ifndef _BITS_BYTESWAP_H
#define _BITS_BYTESWAP_H
/** @file
*
* Byte-order swapping functions
*
*/
#include <stdint.h>
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
extern __asmcall uint64_t riscv_swap_word ( uint64_t x );
extern __asmcall unsigned long riscv_swap_half ( unsigned long x );
extern __asmcall unsigned long riscv_swap_byte ( unsigned long x );
static inline __attribute__ (( always_inline, const )) uint16_t
__bswap_variable_16 ( uint16_t x ) {
return riscv_swap_byte ( x );
}
static inline __attribute__ (( always_inline )) void
__bswap_16s ( uint16_t *x ) {
*x = riscv_swap_byte ( *x );
}
static inline __attribute__ (( always_inline, const )) uint32_t
__bswap_variable_32 ( uint32_t x ) {
return riscv_swap_half ( x );
}
static inline __attribute__ (( always_inline )) void
__bswap_32s ( uint32_t *x ) {
*x = riscv_swap_half ( *x );
}
static inline __attribute__ (( always_inline, const )) uint64_t
__bswap_variable_64 ( uint64_t x ) {
return riscv_swap_word ( x );
}
static inline __attribute__ (( always_inline )) void
__bswap_64s ( uint64_t *x ) {
*x = riscv_swap_word ( *x );
}
#endif /* _BITS_BYTESWAP_H */

40
src/arch/riscv/include/bits/compiler.h Normal file
View File

@@ -0,0 +1,40 @@
#ifndef _BITS_COMPILER_H
#define _BITS_COMPILER_H
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** Dummy relocation type */
#define RELOC_TYPE_NONE R_RISCV_NONE
/* Determine load/store instructions for natural bit width */
#if __riscv_xlen == 128
#define NATURAL_SUFFIX q
#elif __riscv_xlen == 64
#define NATURAL_SUFFIX d
#elif __riscv_xlen == 32
#define NATURAL_SUFFIX w
#else
#error "Unsupported bit width"
#endif
#ifdef ASSEMBLY
#define LOADN _C2 ( L, NATURAL_SUFFIX )
#define STOREN _C2 ( S, NATURAL_SUFFIX )
#else
#define LOADN "L" _S2 ( NATURAL_SUFFIX )
#define STOREN "S" _S2 ( NATURAL_SUFFIX )
#endif
#ifndef ASSEMBLY
/** Unprefixed constant operand modifier */
#define ASM_NO_PREFIX ""
/** Declare a function with standard calling conventions */
#define __asmcall
/** Declare a function with libgcc implicit linkage */
#define __libgcc
#endif /* ASSEMBLY */
#endif /* _BITS_COMPILER_H */

8
src/arch/riscv/include/bits/endian.h Normal file
View File

@@ -0,0 +1,8 @@
#ifndef _BITS_ENDIAN_H
#define _BITS_ENDIAN_H
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#define __BYTE_ORDER __LITTLE_ENDIAN
#endif /* _BITS_ENDIAN_H */

19
src/arch/riscv/include/bits/errfile.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef _BITS_ERRFILE_H
#define _BITS_ERRFILE_H
/** @file
*
* RISC-V error file identifiers
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/**
* @addtogroup errfile Error file identifiers
* @{
*/
/** @} */
#endif /* _BITS_ERRFILE_H */

17
src/arch/riscv/include/bits/io.h Normal file
View File

@@ -0,0 +1,17 @@
#ifndef _BITS_IO_H
#define _BITS_IO_H
/** @file
*
* RISCV-specific I/O API implementations
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** Page shift */
#define PAGE_SHIFT 12
#include <ipxe/riscv_io.h>
#endif /* _BITS_IO_H */

20
src/arch/riscv/include/bits/nap.h Normal file
View File

@@ -0,0 +1,20 @@
#ifndef _BITS_NAP_H
#define _BITS_NAP_H
/** @file
*
* RISCV-specific CPU sleeping API implementations
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/**
* Sleep until next CPU interrupt
*
*/
static inline __attribute__ (( always_inline )) void cpu_halt ( void ) {
__asm__ __volatile__ ( "wfi" );
}
#endif /* _BITS_NAP_H */

16
src/arch/riscv/include/bits/setjmp.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef _BITS_SETJMP_H
#define _BITS_SETJMP_H
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** A jump buffer */
typedef struct {
/** Return address (ra) */
unsigned long ra;
/** Stack pointer (sp) */
unsigned long sp;
/** Callee-saved registers (s0-s11) */
unsigned long s[12];
} jmp_buf[1];
#endif /* _BITS_SETJMP_H */

23
src/arch/riscv/include/bits/stdint.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef _BITS_STDINT_H
#define _BITS_STDINT_H
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
typedef __SIZE_TYPE__ size_t;
typedef signed long ssize_t;
typedef signed long off_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef signed char int8_t;
typedef signed short int16_t;
typedef signed int int32_t;
typedef signed long long int64_t;
typedef unsigned long physaddr_t;
typedef unsigned long intptr_t;
#endif /* _BITS_STDINT_H */

89
src/arch/riscv/include/bits/string.h Normal file
View File

@@ -0,0 +1,89 @@
#ifndef _BITS_STRING_H
#define _BITS_STRING_H
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
/** @file
*
* String functions
*
*/
extern void riscv_bzero ( void *dest, size_t len );
extern void riscv_memset ( void *dest, size_t len, int character );
extern void riscv_memcpy ( void *dest, const void *src, size_t len );
extern void riscv_memmove_forwards ( void *dest, const void *src, size_t len );
extern void riscv_memmove_backwards ( void *dest, const void *src, size_t len );
extern void riscv_memmove ( void *dest, const void *src, size_t len );
/**
* Fill memory region
*
* @v dest Destination region
* @v character Fill character
* @v len Length
* @ret dest Destination region
*/
static inline __attribute__ (( always_inline )) void *
memset ( void *dest, int character, size_t len ) {
/* For zeroing larger or non-constant lengths, use the
* optimised variable-length zeroing code.
*/
if ( __builtin_constant_p ( character ) && ( character == 0 ) ) {
riscv_bzero ( dest, len );
return dest;
}
/* Not necessarily zeroing: use basic variable-length code */
riscv_memset ( dest, len, character );
return dest;
}
/**
* Copy memory region
*
* @v dest Destination region
* @v src Source region
* @v len Length
* @ret dest Destination region
*/
static inline __attribute__ (( always_inline )) void *
memcpy ( void *dest, const void *src, size_t len ) {
/* Otherwise, use variable-length code */
riscv_memcpy ( dest, src, len );
return dest;
}
/**
* Copy (possibly overlapping) memory region
*
* @v dest Destination region
* @v src Source region
* @v len Length
* @ret dest Destination region
*/
static inline __attribute__ (( always_inline )) void *
memmove ( void *dest, const void *src, size_t len ) {
ssize_t offset = ( dest - src );
/* If required direction of copy is known at build time, then
* use the appropriate forwards/backwards copy directly.
*/
if ( __builtin_constant_p ( offset ) ) {
if ( offset <= 0 ) {
riscv_memmove_forwards ( dest, src, len );
return dest;
} else {
riscv_memmove_backwards ( dest, src, len );
return dest;
}
}
/* Otherwise, use ambidirectional copy */
riscv_memmove ( dest, src, len );
return dest;
}
#endif /* _BITS_STRING_H */

91
src/arch/riscv/include/bits/strings.h Normal file
View File

@@ -0,0 +1,91 @@
#ifndef _BITS_STRINGS_H
#define _BITS_STRINGS_H
/** @file
*
* String functions
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
extern __asmcall unsigned long riscv_ffs ( unsigned long value );
extern __asmcall unsigned long riscv_fls ( unsigned long value );
/**
* Find first (i.e. least significant) set bit
*
* @v value Value
* @ret lsb Least significant bit set in value (LSB=1), or zero
*/
static inline __attribute__ (( always_inline )) int __ffsl ( long value ) {
return riscv_ffs ( value );
}
/**
* Find first (i.e. least significant) set bit
*
* @v value Value
* @ret lsb Least significant bit set in value (LSB=1), or zero
*/
static inline __attribute__ (( always_inline )) int __ffsll ( long long value ){
unsigned long low = value;
unsigned long high;
/* Check machine word size */
if ( sizeof ( value ) > sizeof ( low ) ) {
/* 32-bit */
high = ( value >> 32 );
if ( low ) {
return ( __ffsl ( low ) );
} else if ( high ) {
return ( 32 + __ffsl ( high ) );
} else {
return 0;
}
} else {
/* 64-bit */
return ( __ffsl ( low ) );
}
}
/**
* Find last (i.e. most significant) set bit
*
* @v value Value
* @ret msb Most significant bit set in value (LSB=1), or zero
*/
static inline __attribute__ (( always_inline )) int __flsl ( long value ) {
return riscv_fls ( value );
}
/**
* Find last (i.e. most significant) set bit
*
* @v value Value
* @ret msb Most significant bit set in value (LSB=1), or zero
*/
static inline __attribute__ (( always_inline )) int __flsll ( long long value ){
unsigned long low = value;
unsigned long high;
/* Check machine word size */
if ( sizeof ( value ) > sizeof ( low ) ) {
/* 32-bit */
high = ( value >> 32 );
if ( high ) {
return ( 32 + __flsl ( high ) );
} else if ( low ) {
return ( __flsl ( low ) );
} else {
return 0;
}
} else {
/* 64-bit */
return ( __flsl ( low ) );
}
}
#endif /* _BITS_STRINGS_H */

137
src/arch/riscv/include/ipxe/riscv_io.h Normal file
View File

@@ -0,0 +1,137 @@
#ifndef _IPXE_RISCV_IO_H
#define _IPXE_RISCV_IO_H
/** @file
*
* iPXE I/O API for RISC-V
*
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#ifdef IOAPI_RISCV
#define IOAPI_PREFIX_riscv
#else
#define IOAPI_PREFIX_riscv __riscv_
#endif
#include <ipxe/dummy_pio.h>
/*
* Memory space mappings
*
*/
/*
* Physical<->Bus address mappings
*
*/
static inline __always_inline unsigned long
IOAPI_INLINE ( riscv, phys_to_bus ) ( unsigned long phys_addr ) {
return phys_addr;
}
static inline __always_inline unsigned long
IOAPI_INLINE ( riscv, bus_to_phys ) ( unsigned long bus_addr ) {
return bus_addr;
}
/*
* MMIO reads and writes
*
*/
/* Single-register read */
#define RISCV_READX( _suffix, _type, _insn_suffix ) \
static inline __always_inline _type \
IOAPI_INLINE ( riscv, read ## _suffix ) ( volatile _type *io_addr ) { \
unsigned long data; \
__asm__ __volatile__ ( "l" _insn_suffix " %0, %1" \
: "=r" ( data ) : "m" ( *io_addr ) ); \
return data; \
}
/* Single-register write */
#define RISCV_WRITEX( _suffix, _type, _insn_suffix) \
static inline __always_inline void \
IOAPI_INLINE ( riscv, write ## _suffix ) ( _type data, \
volatile _type *io_addr ) { \
__asm__ __volatile__ ( "s" _insn_suffix " %0, %1" \
: : "r" ( data ), "m" ( *io_addr ) ); \
}
/* Double-register hopefully-fused read */
#define RISCV_READX_FUSED( _suffix, _type, _insn_suffix ) \
static inline __always_inline _type \
IOAPI_INLINE ( riscv, read ## _suffix ) ( volatile _type *io_addr ) { \
union { \
unsigned long half[2]; \
_type data; \
} u; \
__asm__ __volatile__ ( "l" _insn_suffix " %0, 0(%2)\n\t" \
"l" _insn_suffix " %1, %3(%2)\n\t" \
: "=&r" ( u.half[0] ), \
"=&r" ( u.half[1] ) \
: "r" ( io_addr ), \
"i" ( sizeof ( u.half[0] ) ) ); \
return u.data; \
}
/* Double-register hopefully-fused write */
#define RISCV_WRITEX_FUSED( _suffix, _type, _insn_suffix ) \
static inline __always_inline void \
IOAPI_INLINE ( riscv, write ## _suffix ) ( _type data, \
volatile _type *io_addr ) { \
union { \
unsigned long half[2]; \
_type data; \
} u = { .data = data }; \
__asm__ __volatile__ ( "s" _insn_suffix " %0, 0(%2)\n\t" \
"s" _insn_suffix " %1, %3(%2)\n\t" : \
: "r" ( u.half[0] ), \
"r" ( u.half[1] ), \
"r" ( io_addr ), \
"i" ( sizeof ( u.half[0] ) ) ); \
}
RISCV_READX ( b, uint8_t, "bu" );
RISCV_WRITEX ( b, uint8_t, "b" );
RISCV_READX ( w, uint16_t, "hu" );
RISCV_WRITEX ( w, uint16_t, "h" );
#if __riscv_xlen > 32
RISCV_READX ( l, uint32_t, "wu" );
RISCV_WRITEX ( l, uint32_t, "w" );
#else
RISCV_READX ( l, uint32_t, "w" );
RISCV_WRITEX ( l, uint32_t, "w" );
#endif
#if __riscv_xlen >= 64
#if __riscv_xlen > 64
RISCV_READX ( q, uint64_t, "du" );
RISCV_WRITEX ( q, uint64_t, "d" );
#else
RISCV_READX ( q, uint64_t, "d" );
RISCV_WRITEX ( q, uint64_t, "d" );
#endif
#else
RISCV_READX_FUSED ( q, uint64_t, "w" );
RISCV_WRITEX_FUSED ( q, uint64_t, "w" );
#endif
/*
* Memory barrier
*
*/
static inline __always_inline void
IOAPI_INLINE ( riscv, mb ) ( void ) {
__asm__ __volatile__ ( "fence rw, rw" );
}
/* Dummy PIO */
DUMMY_PIO ( riscv );
#endif /* _IPXE_RISCV_IO_H */