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