Added page-coloring support to SPARC port
[akaros.git] / kern / arch / sparc / types.h
1 #ifndef ROS_INC_TYPES_H
2 #define ROS_INC_TYPES_H
3
4 #define BIG_ENDIAN
5
6 #ifndef NULL
7 #define NULL ((void*) 0)
8 #endif
9
10 #ifndef TRUE
11 #define TRUE    1
12 #endif
13
14 #ifndef FALSE
15 #define FALSE   0
16 #endif
17
18 #define CHECK_FLAG(flags,bit)   ((flags) & (1 << (bit)))
19
20 // Represents true-or-false values
21 typedef int bool;
22
23 // Explicitly-sized versions of integer types
24 typedef __signed char int8_t;
25 typedef unsigned char uint8_t;
26 typedef short int16_t;
27 typedef unsigned short uint16_t;
28 typedef int int32_t;
29 typedef unsigned int uint32_t;
30 typedef long long int64_t;
31 typedef unsigned long long uint64_t;
32
33 // Pointers and addresses are 32 bits long.
34 // We use pointer types to represent virtual addresses,
35 // uintptr_t to represent the numerical values of virtual addresses,
36 // and physaddr_t to represent physical addresses.
37 typedef int32_t intptr_t;
38 typedef uint32_t uintptr_t;
39 typedef uint32_t physaddr_t;
40
41 // Registers are 32 bits long
42 typedef int32_t intreg_t;
43 typedef uint32_t uintreg_t;
44
45 // Page numbers are 32 bits long.
46 typedef uint32_t ppn_t;
47
48 // size_t is used for memory object sizes.
49 typedef uint32_t size_t;
50 // ssize_t is a signed version of ssize_t, used in case there might be an
51 // error return.
52 typedef int32_t ssize_t;
53
54 // off_t is used for file offsets and lengths.
55 typedef int32_t off_t;
56
57 #define NUM_ADDR_BITS 32
58 #define MAX_VADDR     ((uint64_t)(~0) >> (64-NUM_ADDR_BITS))
59
60 //Constants for byte sizes
61 #define ONE_KILOBYTE  (1L<<10)
62 #define ONE_MEGABYTE  (1L<<20)
63 #define ONE_GIGABYTE  (1L<<30)
64
65 // Return the integer logarithm of the value provided rounded up
66 static inline uint32_t LOG2(uint32_t value)
67 {
68     uint32_t l = 0;
69     while( (value >> l) > 1 ) ++l;
70     return l;
71 }
72
73 // Efficient min and max operations
74 #define MIN(_a, _b)                                             \
75 ({                                                              \
76         typeof(_a) __a = (_a);                                  \
77         typeof(_b) __b = (_b);                                  \
78         __a <= __b ? __a : __b;                                 \
79 })
80 #define MAX(_a, _b)                                             \
81 ({                                                              \
82         typeof(_a) __a = (_a);                                  \
83         typeof(_b) __b = (_b);                                  \
84         __a >= __b ? __a : __b;                                 \
85 })
86
87 // Rounding operations (efficient when n is a power of 2)
88 // Round down to the nearest multiple of n
89 #define ROUNDDOWN(a, n)                                         \
90 ({                                                              \
91         uint32_t __a = (uint32_t) (a);                          \
92         (typeof(a)) (__a - __a % (n));                          \
93 })
94 // Round up to the nearest multiple of n
95 #define ROUNDUP(a, n)                                           \
96 ({                                                              \
97         uint32_t __n = (uint32_t) (n);                          \
98         (typeof(a)) (ROUNDDOWN((uint32_t) (a) + __n - 1, __n)); \
99 })
100
101 // Return the offset of 'member' relative to the beginning of a struct type
102 #ifndef offsetof
103 #define offsetof(type, member)  ((size_t) (&((type*)0)->member))
104 #endif
105
106 // Ivy currently can only handle 63 bits (OCaml thing), so use this to make
107 // a uint64_t programatically
108 #define UINT64(upper, lower) ( (((uint64_t)(upper)) << 32) | (lower) )
109
110 /*********************** Bitmask stuff **********************/
111 #define BYTES_FOR_BITMASK(size) (size)
112 #define BYTES_FOR_BITMASK_WITH_CHECK(size) (size)
113 #define DECL_BITMASK(name, size) uint8_t (name)[BYTES_FOR_BITMASK((size))]
114
115 #define GET_BITMASK_BIT(name, bit) ((name)[(bit)])
116 #define SET_BITMASK_BIT(name, bit) ((name)[(bit)] = 1)
117 #define CLR_BITMASK_BIT(name, bit) ((name)[(bit)] = 0)
118 #define SET_BITMASK_BIT_ATOMIC(name, bit) SET_BITMASK_BIT(name,bit)
119 #define CLR_BITMASK_BIT_ATOMIC(name, bit) CLR_BITMASK_BIT(name,bit)
120
121 #define CLR_BITMASK(name, size) \
122 ({ \
123         {TRUSTEDBLOCK \
124         memset((void*)((uintptr_t)(name)), 0, BYTES_FOR_BITMASK((size))); \
125         } \
126 })
127
128 #define FILL_BITMASK(name, size) \
129 ({ \
130         {TRUSTEDBLOCK \
131         memset((void*)((uintptr_t)(name)), 1, BYTES_FOR_BITMASK((size))); \
132         } \
133 }) 
134
135 #define COPY_BITMASK(newmask, oldmask, size) \
136 ({ \
137         {TRUSTEDBLOCK \
138         memcpy((void*)((uintptr_t)(newmask)), \
139            (void*)((uintptr_t)(oldmask)), \
140            BYTES_FOR_BITMASK((size))); \
141         } \
142 })
143
144 // this checks the entire last byte, so keep it 0 in the other macros
145 #define BITMASK_IS_CLEAR(name, size) ({ \
146         uint32_t __i; \
147         uint8_t __notclear = 0; \
148         for(__i = 0; __i < BYTES_FOR_BITMASK(size); __i++) \
149                 __notclear |= (name)[__i]; \
150         1-__notclear; })
151
152 #define PRINT_BITMASK(name, size) { \
153         int __i; \
154         for (__i = 0; __i < BYTES_FOR_BITMASK(size); __i++) \
155                 printk("%x", (name)[__i]); \
156         printk("\n"); \
157 }
158 /**************************************************************/
159
160 #endif /* !ROS_INC_TYPES_H */