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