src/output.c

   1 // Raw screen writing code.
   2 //
   3 // Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
   4 //
   5 // This file may be distributed under the terms of the GNU GPLv3 license.
   6
   7 #include <stdarg.h> // va_list
   8
   9 #include "farptr.h" // GET_VAR
  10 #include "util.h" // printf
  11 #include "biosvar.h" // struct bregs
  12
  13 static void
  14 screenc(u8 c)
  15 {
  16     struct bregs br;
  17     memset(&br, 0, sizeof(br));
  18     br.ah = 0x0e;
  19     br.al = c;
  20     call16_int(0x10, &br);
  21 }
  22
  23 // Write a charcter to the framebuffer.
  24 static void
  25 putc(u16 action, char c)
  26 {
  27     if (CONFIG_DEBUG_SERIAL)
  28         // Send character to serial port.
  29         debug_serial(c);
  30     else
  31         // Send character to debug port.
  32         outb(c, PORT_BIOS_DEBUG);
  33
  34     if (action) {
  35         // Send character to video screen.
  36         if (c == '\n')
  37             screenc('\r');
  38         screenc(c);
  39     }
  40 }
  41
  42 // Write a string to the framebuffer.
  43 static void
  44 puts(u16 action, const char *s)
  45 {
  46     for (; *s; s++)
  47         putc(action, *s);
  48 }
  49
  50 // Write a string to the framebuffer.
  51 static void
  52 puts_cs(u16 action, const char *s)
  53 {
  54     for (;; s++) {
  55         char c = GET_VAR(CS, *(u8*)s);
  56         if (!c)
  57             break;
  58         putc(action, c);
  59     }
  60 }
  61
  62 // Write an unsigned integer to the screen.
  63 static void
  64 putuint(u16 action, u32 val)
  65 {
  66     char buf[12];
  67     char *d = &buf[sizeof(buf) - 1];
  68     *d-- = '\0';
  69     for (;;) {
  70         *d = (val % 10) + '0';
  71         val /= 10;
  72         if (!val)
  73             break;
  74         d--;
  75     }
  76     puts(action, d);
  77 }
  78
  79 // Write a single digit hex character to the screen.
  80 static inline void
  81 putsinglehex(u16 action, u32 val)
  82 {
  83     if (val <= 9)
  84         val = '0' + val;
  85     else
  86         val = 'a' + val - 10;
  87     putc(action, val);
  88 }
  89
  90 // Write an integer in hexadecimal to the screen.
  91 static void
  92 puthex(u16 action, u32 val)
  93 {
  94     putsinglehex(action, (val >> 28) & 0xf);
  95     putsinglehex(action, (val >> 24) & 0xf);
  96     putsinglehex(action, (val >> 20) & 0xf);
  97     putsinglehex(action, (val >> 16) & 0xf);
  98     putsinglehex(action, (val >> 12) & 0xf);
  99     putsinglehex(action, (val >> 8) & 0xf);
 100     putsinglehex(action, (val >> 4) & 0xf);
 101     putsinglehex(action, (val >> 0) & 0xf);
 102 }
 103
 104 static inline int
 105 isdigit(u8 c)
 106 {
 107     return c - '0' < 10;
 108 }
 109
 110 static void
 111 bvprintf(u16 action, const char *fmt, va_list args)
 112 {
 113     const char *s = fmt;
 114     for (;; s++) {
 115         char c = GET_VAR(CS, *(u8*)s);
 116         if (!c)
 117             break;
 118         if (c != '%') {
 119             putc(action, c);
 120             continue;
 121         }
 122         const char *n = s+1;
 123         for (;;) {
 124             c = GET_VAR(CS, *(u8*)n);
 125             if (!isdigit(c))
 126                 break;
 127             n++;
 128         }
 129         if (c == 'l') {
 130             // Ignore long format indicator
 131             n++;
 132             c = GET_VAR(CS, *(u8*)n);
 133         }
 134         s32 val;
 135         const char *sarg;
 136         switch (c) {
 137         case '%':
 138             putc(action, '%');
 139             break;
 140         case 'd':
 141             val = va_arg(args, s32);
 142             if (val < 0) {
 143                 putc(action, '-');
 144                 val = -val;
 145             }
 146             putuint(action, val);
 147             break;
 148         case 'u':
 149             val = va_arg(args, s32);
 150             putuint(action, val);
 151             break;
 152         case 'p':
 153         case 'x':
 154             val = va_arg(args, s32);
 155             puthex(action, val);
 156             break;
 157         case 'c':
 158             val = va_arg(args, int);
 159             putc(action, val);
 160             break;
 161         case '.':
 162             // Hack to support "%.s" - meaning string on stack.
 163             if (GET_VAR(CS, *(u8*)(n+1)) != 's')
 164                 break;
 165             n++;
 166             sarg = va_arg(args, const char *);
 167             puts(action, sarg);
 168             break;
 169         case 's':
 170             sarg = va_arg(args, const char *);
 171             puts_cs(action, sarg);
 172             break;
 173         default:
 174             putc(action, '%');
 175             n = s;
 176         }
 177         s = n;
 178     }
 179 }
 180
 181 void
 182 BX_PANIC(const char *fmt, ...)
 183 {
 184     va_list args;
 185     va_start(args, fmt);
 186     bvprintf(0, fmt, args);
 187     va_end(args);
 188
 189     // XXX - use PANIC PORT.
 190     irq_disable();
 191     for (;;)
 192         hlt();
 193 }
 194
 195 void
 196 BX_INFO(const char *fmt, ...)
 197 {
 198     va_list args;
 199     va_start(args, fmt);
 200     bvprintf(0, fmt, args);
 201     va_end(args);
 202 }
 203
 204 void
 205 printf(const char *fmt, ...)
 206 {
 207     va_list args;
 208     va_start(args, fmt);
 209     bvprintf(1, fmt, args);
 210     va_end(args);
 211 }
 212
 213 static void
 214 dump_regs(const char *fname, const char *type, struct bregs *regs)
 215 {
 216     if (!regs) {
 217         BX_INFO("%s %s: NULL\n", type, fname);
 218         return;
 219     }
 220     BX_INFO("%s %s: a=%x b=%x c=%x d=%x si=%x di=%x\n"
 221             , type, fname, regs->eax, regs->ebx, regs->ecx, regs->edx
 222             , regs->esi, regs->edi);
 223     BX_INFO("  ds=%x es=%x ip=%x cs=%x f=%x r=%p\n"
 224             , regs->ds, regs->es, regs->ip, regs->cs, regs->flags, regs);
 225 }
 226
 227 void
 228 __debug_isr(const char *fname)
 229 {
 230     puts_cs(0, fname);
 231     putc(0, '\n');
 232 }
 233
 234 // Function called on handler startup.
 235 void
 236 __debug_enter(const char *fname, struct bregs *regs)
 237 {
 238     // XXX - implement run time suppression test
 239     dump_regs(fname, "enter", regs);
 240 }
 241
 242 void
 243 __debug_fail(const char *fname, struct bregs *regs)
 244 {
 245     dump_regs(fname, "fail", regs);
 246 }
 247
 248 void
 249 __debug_stub(const char *fname, struct bregs *regs)
 250 {
 251     dump_regs(fname, "stub", regs);
 252 }