Be sure to add "void" to all function prototypes that take no args.

[seabios.git] / src / util.c

diff --git a/src/util.c b/src/util.c
index 1faca26053c5019a30dccafec130db6799db8938..b89a2b5b756f589634040455a351f6d8b221083d 100644 (file)
--- a/src/util.c
+++ b/src/util.c
@@ -6,14 +6,20 @@
 
 #include "util.h" // call16
 #include "bregs.h" // struct bregs
-#include "farptr.h" // GET_FLATPTR
-#include "biosvar.h" // get_ebda_seg
+#include "config.h" // BUILD_STACK_ADDR
+
+
+/****************************************************************
+ * 16bit calls
+ ****************************************************************/
 
 // Call a function with a specified register state.  Note that on
 // return, the interrupt enable/disable flag may be altered.
 inline void
 call16(struct bregs *callregs)
 {
+    if (!MODESEGMENT && getesp() > BUILD_STACK_ADDR)
+        panic("call16 with invalid stack\n");
     asm volatile(
 #if MODE16 == 1
         "calll __call16\n"
@@ -30,7 +36,9 @@ call16(struct bregs *callregs)
 inline void
 call16big(struct bregs *callregs)
 {
-    ASSERT32();
+    ASSERT32FLAT();
+    if (getesp() > BUILD_STACK_ADDR)
+        panic("call16 with invalid stack\n");
     asm volatile(
         "calll __call16big_from32"
         : "+a" (callregs), "+m" (*callregs)
@@ -41,41 +49,48 @@ call16big(struct bregs *callregs)
 inline void
 __call16_int(struct bregs *callregs, u16 offset)
 {
-    if (MODE16)
-        callregs->cs = GET_SEG(CS);
+    if (MODESEGMENT)
+        callregs->code.seg = GET_SEG(CS);
     else
-        callregs->cs = SEG_BIOS;
-    callregs->ip = offset;
+        callregs->code.seg = SEG_BIOS;
+    callregs->code.offset = offset;
     call16(callregs);
 }
 
-// Switch to the extra stack in ebda and call a function.
-inline u32
-stack_hop(u32 eax, u32 edx, u32 ecx, void *func)
+// 16bit trampoline for enabling irqs from 32bit mode.
+ASM16(
+    "  .global trampoline_checkirqs\n"
+    "trampoline_checkirqs:\n"
+    "  rep ; nop\n"
+    "  lretw"
+    );
+
+void
+check_irqs(void)
 {
-    ASSERT16();
-    u16 ebda_seg = get_ebda_seg(), bkup_ss;
-    u32 bkup_esp;
-    asm volatile(
-        // Backup current %ss/%esp values.
-        "movw %%ss, %w3\n"
-        "movl %%esp, %4\n"
-        // Copy ebda seg to %ds/%ss and set %esp
-        "movw %w6, %%ds\n"
-        "movw %w6, %%ss\n"
-        "movl %5, %%esp\n"
-        // Call func
-        "calll %7\n"
-        // Restore segments and stack
-        "movw %w3, %%ds\n"
-        "movw %w3, %%ss\n"
-        "movl %4, %%esp"
-        : "+a" (eax), "+d" (edx), "+c" (ecx), "=&r" (bkup_ss), "=&r" (bkup_esp)
-        : "i" (EBDA_OFFSET_TOP_STACK), "r" (ebda_seg), "m" (*(u8*)func)
-        : "cc", "memory");
-    return eax;
+    if (MODE16) {
+        asm volatile(
+            "sti\n"
+            "nop\n"
+            "rep ; nop\n"
+            "cli\n"
+            "cld\n"
+            : : :"memory");
+    } else {
+        extern void trampoline_checkirqs();
+        struct bregs br;
+        br.flags = F_IF;
+        br.code.seg = SEG_BIOS;
+        br.code.offset = (u32)&trampoline_checkirqs;
+        call16big(&br);
+    }
 }
 
+
+/****************************************************************
+ * String ops
+ ****************************************************************/
+
 // Sum the bytes in the specified area.
 u8
 checksum_far(u16 buf_seg, void *buf_far, u32 len)
@@ -182,8 +197,11 @@ memcpy_far(u16 d_seg, void *d_far, u16 s_seg, const void *s_far, size_t len)
 void *
 #undef memcpy
 memcpy(void *d1, const void *s1, size_t len)
+#if MODESEGMENT == 0
 #define memcpy __builtin_memcpy
+#endif
 {
+    SET_SEG(ES, GET_SEG(SS));
     void *d = d1;
     if (((u32)d1 | (u32)s1 | len) & 3) {
         // non-aligned memcpy
@@ -202,6 +220,26 @@ memcpy(void *d1, const void *s1, size_t len)
     return d1;
 }
 
+// Copy from memory mapped IO.  IO mem is very slow, so yield
+// periodically.  'len' must be 4 byte aligned.
+void
+iomemcpy(void *d, const void *s, u32 len)
+{
+    yield();
+    while (len) {
+        u32 copylen = len;
+        if (copylen > 2048)
+            copylen = 2048;
+        len -= copylen;
+        copylen /= 4;
+        asm volatile(
+            "rep movsl (%%esi),%%es:(%%edi)"
+            : "+c"(copylen), "+S"(s), "+D"(d)
+            : : "cc", "memory");
+        yield();
+    }
+}
+
 void *
 memmove(void *d, const void *s, size_t len)
 {
@@ -230,12 +268,18 @@ strtcpy(char *dest, const char *src, size_t len)
     return dest;
 }
 
-// Wait for 'usec' microseconds with irqs enabled.
+
+/****************************************************************
+ * Keyboard calls
+ ****************************************************************/
+
+// Wait for 'usec' microseconds using (with irqs enabled) using int 1586.
 void
-usleep(u32 usec)
+biosusleep(u32 usec)
 {
     struct bregs br;
     memset(&br, 0, sizeof(br));
+    br.flags = F_IF;
     br.ah = 0x86;
     br.cx = usec >> 16;
     br.dx = usec;
@@ -244,10 +288,11 @@ usleep(u32 usec)
 
 // See if a keystroke is pending in the keyboard buffer.
 static int
-check_for_keystroke()
+check_for_keystroke(void)
 {
     struct bregs br;
     memset(&br, 0, sizeof(br));
+    br.flags = F_IF;
     br.ah = 1;
     call16_int(0x16, &br);
     return !(br.flags & F_ZF);
@@ -255,10 +300,11 @@ check_for_keystroke()
 
 // Return a keystroke - waiting forever if necessary.
 static int
-get_raw_keystroke()
+get_raw_keystroke(void)
 {
     struct bregs br;
     memset(&br, 0, sizeof(br));
+    br.flags = F_IF;
     call16_int(0x16, &br);
     return br.ah;
 }
@@ -272,7 +318,7 @@ get_keystroke(int msec)
             return get_raw_keystroke();
         if (msec <= 0)
             return -1;
-        usleep(50*1000);
+        biosusleep(50*1000);
         msec -= 50;
     }
 }