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