src/output.c

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