grml...

[seabios.git] / src / util.c

diff --git a/src/util.c b/src/util.c
index e146c9731bd9efa69df12cfb09bb8a0c59e8342f..53ef84ded96dfb230c3162b4bafded88fa3394cf 100644 (file)
--- a/src/util.c
+++ b/src/util.c
@@ -8,6 +8,22 @@
 #include "bregs.h" // struct bregs
 #include "config.h" // BUILD_STACK_ADDR
 
+void
+cpuid(u32 index, u32 *eax, u32 *ebx, u32 *ecx, u32 *edx)
+{
+    // Check for cpu id
+    u32 origflags = save_flags();
+    restore_flags(origflags ^ F_ID);
+    u32 newflags = save_flags();
+    restore_flags(origflags);
+
+    if (((origflags ^ newflags) & F_ID) != F_ID)
+        // no cpuid
+        *eax = *ebx = *ecx = *edx = 0;
+    else
+        __cpuid(index, eax, ebx, ecx, edx);
+}
+
 
 /****************************************************************
  * 16bit calls
@@ -57,35 +73,6 @@ __call16_int(struct bregs *callregs, u16 offset)
     call16(callregs);
 }
 
-// 16bit trampoline for enabling irqs from 32bit mode.
-ASM16(
-    "  .global trampoline_checkirqs\n"
-    "trampoline_checkirqs:\n"
-    "  rep ; nop\n"
-    "  lretw"
-    );
-
-void
-check_irqs(void)
-{
-    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
@@ -179,6 +166,15 @@ memset(void *s, int c, size_t n)
     return s;
 }
 
+void memset_fl(void *ptr, u8 val, size_t size)
+{
+    if (MODESEGMENT)
+        memset_far(FLATPTR_TO_SEG(ptr), (void*)(FLATPTR_TO_OFFSET(ptr)),
+                   val, size);
+    else
+        memset(ptr, val, size);
+}
+
 inline void
 memcpy_far(u16 d_seg, void *d_far, u16 s_seg, const void *s_far, size_t len)
 {
@@ -194,6 +190,17 @@ memcpy_far(u16 d_seg, void *d_far, u16 s_seg, const void *s_far, size_t len)
         : "cc", "memory");
 }
 
+inline void
+memcpy_fl(void *d_fl, const void *s_fl, size_t len)
+{
+    if (MODESEGMENT)
+        memcpy_far(FLATPTR_TO_SEG(d_fl), (void*)FLATPTR_TO_OFFSET(d_fl)
+                   , FLATPTR_TO_SEG(s_fl), (void*)FLATPTR_TO_OFFSET(s_fl)
+                   , len);
+    else
+        memcpy(d_fl, s_fl, len);
+}
+
 void *
 #undef memcpy
 memcpy(void *d1, const void *s1, size_t len)
@@ -220,24 +227,27 @@ 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.
+// Copy to/from memory mapped IO.  IO mem is very slow, so yield
+// periodically.
 void
 iomemcpy(void *d, const void *s, u32 len)
 {
     yield();
-    while (len) {
+    while (len > 3) {
         u32 copylen = len;
         if (copylen > 2048)
             copylen = 2048;
-        len -= copylen;
         copylen /= 4;
+        len -= copylen * 4;
         asm volatile(
             "rep movsl (%%esi),%%es:(%%edi)"
             : "+c"(copylen), "+S"(s), "+D"(d)
             : : "cc", "memory");
         yield();
     }
+    if (len)
+        // Copy any remaining bytes.
+        memcpy(d, s, len);
 }
 
 void *
@@ -268,24 +278,30 @@ strtcpy(char *dest, const char *src, size_t len)
     return dest;
 }
 
+// locate first occurance of character c in the string s
+char *
+strchr(const char *s, int c)
+{
+    for (; *s; s++)
+        if (*s == c)
+            return (char*)s;
+    return NULL;
+}
 
-/****************************************************************
- * Keyboard calls
- ****************************************************************/
-
-// Wait for 'usec' microseconds using (with irqs enabled) using int 1586.
+// Remove any trailing blank characters (spaces, new lines, carriage returns)
 void
-biosusleep(u32 usec)
+nullTrailingSpace(char *buf)
 {
-    struct bregs br;
-    memset(&br, 0, sizeof(br));
-    br.flags = F_IF;
-    br.ah = 0x86;
-    br.cx = usec >> 16;
-    br.dx = usec;
-    call16_int(0x15, &br);
+    int len = strlen(buf);
+    char *end = &buf[len-1];
+    while (end >= buf && *end <= ' ')
+        *(end--) = '\0';
 }
 
+/****************************************************************
+ * Keyboard calls
+ ****************************************************************/
+
 // See if a keystroke is pending in the keyboard buffer.
 static int
 check_for_keystroke(void)
@@ -294,9 +310,7 @@ check_for_keystroke(void)
     memset(&br, 0, sizeof(br));
     br.flags = F_IF;
     br.ah = 1;
-    start_preempt();
     call16_int(0x16, &br);
-    finish_preempt();
     return !(br.flags & F_ZF);
 }
 
@@ -307,9 +321,7 @@ get_raw_keystroke(void)
     struct bregs br;
     memset(&br, 0, sizeof(br));
     br.flags = F_IF;
-    start_preempt();
     call16_int(0x16, &br);
-    finish_preempt();
     return br.ah;
 }
 
@@ -317,14 +329,12 @@ get_raw_keystroke(void)
 int
 get_keystroke(int msec)
 {
+    u32 end = calc_future_timer(msec);
     for (;;) {
         if (check_for_keystroke())
             return get_raw_keystroke();
-        if (msec <= 0)
+        if (check_timer(end))
             return -1;
-        start_preempt();
-        biosusleep(50*1000);
-        finish_preempt();
-        msec -= 50;
+        wait_irq();
     }
 }