1 use core::{mem, slice}; 2 use core::ops::{Deref, DerefMut}; 3 4 use super::error::{Error, Result}; 5 6 macro_rules! syscall { 7 ($($name:ident($a:ident, $($b:ident, $($c:ident, $($d:ident, $($e:ident, $($f:ident, )?)?)?)?)?);)+) => { 8 $( 9 pub unsafe fn $name($a: usize, $($b: usize, $($c: usize, $($d: usize, $($e: usize, $($f: usize)?)?)?)?)?) -> Result<usize> { 10 let ret: usize; 11 12 asm!( 13 "svc 0", 14 in("x8") $a, 15 $( 16 in("x0") $b, 17 $( 18 in("x1") $c, 19 $( 20 in("x2") $d, 21 $( 22 in("x3") $e, 23 $( 24 in("x4") $f, 25 )? 26 )? 27 )? 28 )? 29 )? 30 lateout("x0") ret, 31 options(nostack), 32 ); 33 34 Error::demux(ret) 35 } 36 )+ 37 }; 38 } 39 40 syscall! { 41 syscall0(a,); 42 syscall1(a, b,); 43 syscall2(a, b, c,); 44 syscall3(a, b, c, d,); 45 syscall4(a, b, c, d, e,); 46 syscall5(a, b, c, d, e, f,); 47 } 48 49 #[derive(Copy, Clone, Debug, Default)] 50 #[repr(C)] 51 pub struct IntRegisters { 52 pub elr_el1: usize, 53 pub tpidr_el0: usize, 54 pub tpidrro_el0: usize, 55 pub spsr_el1: usize, 56 pub esr_el1: usize, 57 pub sp_el0: usize, // Shouldn't be used if interrupt occurred at EL1 58 pub padding: usize, // To keep the struct even number aligned 59 pub x30: usize, 60 pub x29: usize, 61 pub x28: usize, 62 pub x27: usize, 63 pub x26: usize, 64 pub x25: usize, 65 pub x24: usize, 66 pub x23: usize, 67 pub x22: usize, 68 pub x21: usize, 69 pub x20: usize, 70 pub x19: usize, 71 pub x18: usize, 72 pub x17: usize, 73 pub x16: usize, 74 pub x15: usize, 75 pub x14: usize, 76 pub x13: usize, 77 pub x12: usize, 78 pub x11: usize, 79 pub x10: usize, 80 pub x9: usize, 81 pub x8: usize, 82 pub x7: usize, 83 pub x6: usize, 84 pub x5: usize, 85 pub x4: usize, 86 pub x3: usize, 87 pub x2: usize, 88 pub x1: usize, 89 pub x0: usize 90 } 91 92 impl Deref for IntRegisters { 93 type Target = [u8]; deref(&self) -> &[u8]94 fn deref(&self) -> &[u8] { 95 unsafe { 96 slice::from_raw_parts(self as *const IntRegisters as *const u8, mem::size_of::<IntRegisters>()) 97 } 98 } 99 } 100 101 impl DerefMut for IntRegisters { deref_mut(&mut self) -> &mut [u8]102 fn deref_mut(&mut self) -> &mut [u8] { 103 unsafe { 104 slice::from_raw_parts_mut(self as *mut IntRegisters as *mut u8, mem::size_of::<IntRegisters>()) 105 } 106 } 107 } 108 109 #[derive(Clone, Copy, Debug, Default)] 110 #[repr(packed)] 111 pub struct FloatRegisters { 112 pub fp_simd_regs: [u128; 32], 113 pub fpsr: u32, 114 pub fpcr: u32 115 } 116 117 impl Deref for FloatRegisters { 118 type Target = [u8]; deref(&self) -> &[u8]119 fn deref(&self) -> &[u8] { 120 unsafe { 121 slice::from_raw_parts(self as *const FloatRegisters as *const u8, mem::size_of::<FloatRegisters>()) 122 } 123 } 124 } 125 126 impl DerefMut for FloatRegisters { deref_mut(&mut self) -> &mut [u8]127 fn deref_mut(&mut self) -> &mut [u8] { 128 unsafe { 129 slice::from_raw_parts_mut(self as *mut FloatRegisters as *mut u8, mem::size_of::<FloatRegisters>()) 130 } 131 } 132 } 133