5 * - General arch-specific stuff
8 #include <threads_int.h>
13 #define DEBUG_TO_SERIAL 1
14 #define SERIAL_PORT 0x3F8
15 #define GDB_SERIAL_PORT 0x2F8
19 extern struct sShortSpinlock glDebug_Lock;
20 extern struct sShortSpinlock glThreadListLock;
22 extern int GetCPUNum(void);
25 Uint64 __udivdi3(Uint64 Num, Uint64 Den);
26 Uint64 __umoddi3(Uint64 Num, Uint64 Den);
29 int gbDebug_SerialSetup = 0;
30 int gbGDB_SerialSetup = 0;
34 * \brief Determine if a short spinlock is locked
35 * \param Lock Lock pointer
37 int IS_LOCKED(struct sShortSpinlock *Lock)
43 * \brief Check if the current CPU has the lock
44 * \param Lock Lock pointer
46 int CPU_HAS_LOCK(struct sShortSpinlock *Lock)
48 return Lock->Lock == GetCPUNum() + 1;
52 * \brief Acquire a Short Spinlock
53 * \param Lock Lock pointer
55 * This type of mutex should only be used for very short sections of code,
56 * or in places where a Mutex_* would be overkill, such as appending
57 * an element to linked list (usually two assignement lines in C)
59 * \note This type of lock halts interrupts, so ensure that no timing
60 * functions are called while it is held. As a matter of fact, spend as
61 * little time as possible with this lock held
62 * \note If \a STACKED_LOCKS is set, this type of spinlock can be nested
64 void SHORTLOCK(struct sShortSpinlock *Lock)
68 int cpu = GetCPUNum() + 1;
70 // Save interrupt state
71 __ASM__ ("pushf;\n\tpop %0" : "=r"(IF));
72 IF &= 0x200; // AND out all but the interrupt flag
75 if( Lock != &glDebug_Lock && Lock != &glThreadListLock )
77 //Log_Log("LOCK", "%p locked by %p", Lock, __builtin_return_address(0));
78 Debug("%p obtaining %p (Called by %p)", __builtin_return_address(0), Lock, __builtin_return_address(1));
84 // Wait for another CPU to release
86 "1: lock cmpxchgl %2, (%3)\n\t"
89 : "a"(0), "r"(cpu), "r"(&Lock->Lock)
95 if( Lock != &glDebug_Lock && Lock != &glThreadListLock )
97 //Log_Log("LOCK", "%p locked by %p", Lock, __builtin_return_address(0));
98 //Debug("Lock %p locked by %p\t%p", Lock, __builtin_return_address(0), __builtin_return_address(1));
104 * \brief Release a short lock
105 * \param Lock Lock pointer
107 void SHORTREL(struct sShortSpinlock *Lock)
110 if( Lock != &glDebug_Lock && Lock != &glThreadListLock )
112 //Log_Log("LOCK", "%p released by %p", Lock, __builtin_return_address(0));
113 Debug("Lock %p released by %p\t%p", Lock, __builtin_return_address(0), __builtin_return_address(1));
117 // Lock->IF can change anytime once Lock->Lock is zeroed
129 int putDebugChar(char ch)
131 if(!gbGDB_SerialSetup) {
132 outb(GDB_SERIAL_PORT + 1, 0x00); // Disable all interrupts
133 outb(GDB_SERIAL_PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
134 outb(GDB_SERIAL_PORT + 0, 0x0C); // Set divisor to 12 (lo byte) 9600 baud
135 outb(GDB_SERIAL_PORT + 1, 0x00); // (base is (hi byte)
136 outb(GDB_SERIAL_PORT + 3, 0x03); // 8 bits, no parity, one stop bit (8N1)
137 outb(GDB_SERIAL_PORT + 2, 0xC7); // Enable FIFO with 14-byte threshold and clear it
138 outb(GDB_SERIAL_PORT + 4, 0x0B); // IRQs enabled, RTS/DSR set
139 gbGDB_SerialSetup = 1;
141 while( (inb(GDB_SERIAL_PORT + 5) & 0x20) == 0 );
142 outb(GDB_SERIAL_PORT, ch);
145 int getDebugChar(void)
147 if(!gbGDB_SerialSetup) {
148 outb(GDB_SERIAL_PORT + 1, 0x00); // Disable all interrupts
149 outb(GDB_SERIAL_PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
150 outb(GDB_SERIAL_PORT + 0, 0x0C); // Set divisor to 12 (lo byte) 9600 baud
151 outb(GDB_SERIAL_PORT + 1, 0x00); // (hi byte)
152 outb(GDB_SERIAL_PORT + 3, 0x03); // 8 bits, no parity, one stop bit
153 outb(GDB_SERIAL_PORT + 2, 0xC7); // Enable FIFO with 14-byte threshold and clear it
154 outb(GDB_SERIAL_PORT + 4, 0x0B); // IRQs enabled, RTS/DSR set
155 gbGDB_SerialSetup = 1;
157 while( (inb(GDB_SERIAL_PORT + 5) & 1) == 0) ;
158 return inb(GDB_SERIAL_PORT);
160 #endif /* USE_GDB_STUB */
162 void Debug_PutCharDebug(char ch)
165 __asm__ __volatile__ ( "outb %%al, $0xe9" :: "a"(((Uint8)ch)) );
169 if(!gbDebug_SerialSetup) {
170 outb(SERIAL_PORT + 1, 0x00); // Disable all interrupts
171 outb(SERIAL_PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
172 outb(SERIAL_PORT + 0, 0x0C); // Set divisor to 12 (lo byte) 9600 baud
173 outb(SERIAL_PORT + 1, 0x00); // (hi byte)
174 outb(SERIAL_PORT + 3, 0x03); // 8 bits, no parity, one stop bit
175 outb(SERIAL_PORT + 2, 0xC7); // Enable FIFO with 14-byte threshold and clear it
176 outb(SERIAL_PORT + 4, 0x0B); // IRQs enabled, RTS/DSR set
177 gbDebug_SerialSetup = 1;
179 while( (inb(SERIAL_PORT + 5) & 0x20) == 0 );
180 outb(SERIAL_PORT, ch);
184 void Debug_PutStringDebug(const char *String)
187 Debug_PutCharDebug(*String++);
190 // === IO Commands ===
191 void outb(Uint16 Port, Uint8 Data)
193 __asm__ __volatile__ ("outb %%al, %%dx"::"d"(Port),"a"(Data));
195 void outw(Uint16 Port, Uint16 Data)
197 __asm__ __volatile__ ("outw %%ax, %%dx"::"d"(Port),"a"(Data));
199 void outd(Uint16 Port, Uint32 Data)
201 __asm__ __volatile__ ("outl %%eax, %%dx"::"d"(Port),"a"(Data));
203 Uint8 inb(Uint16 Port)
206 __asm__ __volatile__ ("inb %%dx, %%al":"=a"(ret):"d"(Port));
209 Uint16 inw(Uint16 Port)
212 __asm__ __volatile__ ("inw %%dx, %%ax":"=a"(ret):"d"(Port));
215 Uint32 ind(Uint16 Port)
218 __asm__ __volatile__ ("inl %%dx, %%eax":"=a"(ret):"d"(Port));
223 * \fn void *memset(void *Dest, int Val, size_t Num)
224 * \brief Do a byte granuality set of Dest
226 void *memset(void *Dest, int Val, size_t Num)
228 Uint32 val = Val&0xFF;
231 __asm__ __volatile__ (
235 :: "D" (Dest), "a" (val), "c" (Num/4), "r" (Num&3));
239 * \brief Set double words
241 void *memsetd(void *Dest, Uint32 Val, size_t Num)
243 __asm__ __volatile__ ("rep stosl" :: "D" (Dest), "a" (Val), "c" (Num));
248 * \fn int memcmp(const void *m1, const void *m2, size_t Num)
249 * \brief Compare two pieces of memory
251 int memcmp(const void *m1, const void *m2, size_t Num)
253 const Uint8 *d1 = m1;
254 const Uint8 *d2 = m2;
255 if( Num == 0 ) return 0; // No bytes are always identical
268 * \fn void *memcpy(void *Dest, const void *Src, size_t Num)
269 * \brief Copy \a Num bytes from \a Src to \a Dest
271 void *memcpy(void *Dest, const void *Src, size_t Num)
273 tVAddr dst = (tVAddr)Dest;
274 tVAddr src = (tVAddr)Src;
275 if( (dst & 3) != (src & 3) )
277 __asm__ __volatile__ ("rep movsb" :: "D" (dst), "S" (src), "c" (Num));
278 // Debug("\nmemcpy:Num=0x%x by %p (UA)", Num, __builtin_return_address(0));
281 else if( Num > 128 && (dst & 15) == (src & 15) )
283 char tmp[16+15]; // Note, this is a hack to save/restor xmm0
284 int count = 16 - (dst & 15);
285 // Debug("\nmemcpy:Num=0x%x by %p (SSE)", Num, __builtin_return_address(0));
289 __asm__ __volatile__ ("rep movsb" : "=D"(dst),"=S"(src): "0"(dst), "1"(src), "c"(count));
293 __asm__ __volatile__ (
294 "movdqa 0(%5), %%xmm0;\n\t"
296 "movdqa 0(%1), %%xmm0;\n\t"
297 "movdqa %%xmm0, 0(%0);\n\t"
301 "movdqa %%xmm0, 0(%5);\n\t"
302 : "=r"(dst),"=r"(src)
303 : "0"(dst), "1"(src), "c"(count), "r" (((tVAddr)tmp+15)&~15)
308 __asm__ __volatile__ ("rep movsb" :: "D"(dst), "S"(src), "c"(count));
313 // Debug("\nmemcpy:Num=0x%x by %p", Num, __builtin_return_address(0));
314 __asm__ __volatile__ (
318 :: "D" (Dest), "S" (Src), "c" (Num/4), "r" (Num&3));
324 * \fn void *memcpyd(void *Dest, const void *Src, size_t Num)
325 * \brief Copy \a Num DWORDs from \a Src to \a Dest
327 void *memcpyd(void *Dest, const void *Src, size_t Num)
329 __asm__ __volatile__ ("rep movsl" :: "D" (Dest), "S" (Src), "c" (Num));
333 Uint64 DivMod64U(Uint64 Num, Uint64 Div, Uint64 *Rem)
336 if( Div < 0x100000000ULL && Num < 0xFFFFFFFF * Div ) {
338 __asm__ __volatile__(
340 : "=a" (ret_32), "=d" (rem)
341 : "a" ( (Uint32)(Num & 0xFFFFFFFF) ), "d" ((Uint32)(Num >> 32)), "r" (Div)
347 ret = __udivdi3(Num, Div);
348 if(Rem) *Rem = __umoddi3(Num, Div);
353 * \fn Uint64 __udivdi3(Uint64 Num, Uint64 Den)
354 * \brief Divide two 64-bit integers
356 Uint64 __udivdi3(Uint64 Num, Uint64 Den)
362 if(Den == 0) __asm__ __volatile__ ("int $0x0");
364 if(Num <= 0xFFFFFFFF && Den <= 0xFFFFFFFF)
365 return (Uint32)Num / (Uint32)Den;
366 if(Den == 1) return Num;
367 if(Den == 2) return Num >> 1; // Speed Hacks
368 if(Den == 4) return Num >> 2; // Speed Hacks
369 if(Den == 8) return Num >> 3; // Speed Hacks
370 if(Den == 16) return Num >> 4; // Speed Hacks
371 if(Den == 32) return Num >> 5; // Speed Hacks
372 if(Den == 1024) return Num >> 10; // Speed Hacks
373 if(Den == 2048) return Num >> 11; // Speed Hacks
374 if(Den == 4096) return Num >> 12;
375 if(Num < Den) return 0;
376 if(Num < Den*2) return 1;
377 if(Num == Den*2) return 2;
383 __asm__ __volatile__ (
384 "fildq %2\n\t" // Num
385 "fildq %1\n\t" // Den
389 : "m" (P[0]), "m" (P[1])
392 //Log("%llx / %llx = %llx\n", Num, Den, q);
394 // Restoring division, from wikipedia
395 // http://en.wikipedia.org/wiki/Division_(digital)
396 P[0] = Num; P[1] = 0;
400 P[1] = (P[1] << 1) | (P[0] >> 63);
407 if( !(P[1] & (1ULL<<63)) ) {
408 q |= (Uint64)1 << (63-i);
421 * \fn Uint64 __umoddi3(Uint64 Num, Uint64 Den)
422 * \brief Get the modulus of two 64-bit integers
424 Uint64 __umoddi3(Uint64 Num, Uint64 Den)
426 if(Den == 0) __asm__ __volatile__ ("int $0x0"); // Call Div by Zero Error
427 if(Den == 1) return 0; // Speed Hacks
428 if(Den == 2) return Num & 1; // Speed Hacks
429 if(Den == 4) return Num & 3; // Speed Hacks
430 if(Den == 8) return Num & 7; // Speed Hacks
431 if(Den == 16) return Num & 15; // Speed Hacks
432 if(Den == 32) return Num & 31; // Speed Hacks
433 if(Den == 1024) return Num & 1023; // Speed Hacks
434 if(Den == 2048) return Num & 2047; // Speed Hacks
435 if(Den == 4096) return Num & 4095; // Speed Hacks
437 if(Num >> 32 == 0 && Den >> 32 == 0)
438 return (Uint32)Num % (Uint32)Den;
440 return Num - __udivdi3(Num, Den) * Den;
445 EXPORT(memcpy); EXPORT(memset);
447 //EXPORT(memcpyw); EXPORT(memsetw);
448 EXPORT(memcpyd); EXPORT(memsetd);
449 EXPORT(inb); EXPORT(inw); EXPORT(ind);
450 EXPORT(outb); EXPORT(outw); EXPORT(outd);
451 EXPORT(__udivdi3); EXPORT(__umoddi3);