core/bios.c

   1 #include <sys/ansi.h>
   2 #include <sys/io.h>
   3 #include <fs.h>
   4 #include <bios.h>
   5 #include <com32.h>
   6 #include <graphics.h>
   7 #include <syslinux/memscan.h>
   8 #include <syslinux/firmware.h>
   9 #include <syslinux/video.h>
  10
  11 #include <sys/vesa/vesa.h>
  12 #include <sys/vesa/video.h>
  13 #include <sys/vesa/debug.h>
  14 #include <minmax.h>
  15 #include "core.h"
  16
  17 __export struct firmware *firmware = NULL;
  18
  19 extern struct ansi_ops bios_ansi_ops;
  20
  21 #define BIOS_CURXY ((struct curxy *)0x450)      /* Array for each page */
  22 #define BIOS_ROWS (*(uint8_t *)0x484)   /* Minus one; if zero use 24 (= 25 lines) */
  23 #define BIOS_COLS (*(uint16_t *)0x44A)
  24 #define BIOS_PAGE (*(uint8_t *)0x462)
  25
  26 static void bios_text_mode(void)
  27 {
  28     syslinux_force_text_mode();
  29 }
  30
  31 static void bios_get_mode(int *cols, int *rows)
  32 {
  33     *rows = BIOS_ROWS ? BIOS_ROWS + 1 : 25;
  34     *cols = BIOS_COLS;
  35 }
  36
  37 static uint16_t cursor_type;    /* Saved cursor pattern */
  38
  39 static void bios_get_cursor(uint8_t *x, uint8_t *y)
  40 {
  41     com32sys_t ireg, oreg;
  42
  43     memset(&ireg, 0, sizeof(ireg));
  44
  45     ireg.eax.b[1] = 0x03;
  46     ireg.ebx.b[1] = BIOS_PAGE;
  47     __intcall(0x10, &ireg, &oreg);
  48     cursor_type = oreg.ecx.w[0];
  49     *x = oreg.edx.b[0];
  50     *y = oreg.edx.b[1];
  51 }
  52
  53 static void bios_erase(int x0, int y0, int x1, int y1, uint8_t attribute)
  54 {
  55     static com32sys_t ireg;
  56     memset(&ireg, 0, sizeof(ireg));
  57
  58     ireg.eax.w[0] = 0x0600;     /* Clear window */
  59     ireg.ebx.b[1] = attribute;
  60     ireg.ecx.b[0] = x0;
  61     ireg.ecx.b[1] = y0;
  62     ireg.edx.b[0] = x1;
  63     ireg.edx.b[1] = y1;
  64     __intcall(0x10, &ireg, NULL);
  65 }
  66
  67 static void bios_showcursor(const struct term_state *st)
  68 {
  69     static com32sys_t ireg;
  70     uint16_t cursor = st->cursor ? cursor_type : 0x2020;
  71
  72     memset(&ireg, 0, sizeof(ireg));
  73
  74     ireg.eax.b[1] = 0x01;
  75     ireg.ecx.w[0] = cursor;
  76     __intcall(0x10, &ireg, NULL);
  77 }
  78
  79 static void bios_set_cursor(int x, int y, bool visible)
  80 {
  81     const int page = BIOS_PAGE;
  82     struct curxy xy = BIOS_CURXY[page];
  83     static com32sys_t ireg;
  84
  85     memset(&ireg, 0, sizeof(ireg));
  86
  87     (void)visible;
  88
  89     if (xy.x != x || xy.y != y) {
  90         ireg.eax.b[1] = 0x02;
  91         ireg.ebx.b[1] = page;
  92         ireg.edx.b[1] = y;
  93         ireg.edx.b[0] = x;
  94         __intcall(0x10, &ireg, NULL);
  95     }
  96 }
  97
  98 static void bios_write_char(uint8_t ch, uint8_t attribute)
  99 {
 100     static com32sys_t ireg;
 101
 102     memset(&ireg, 0, sizeof(ireg));
 103
 104     ireg.eax.b[1] = 0x09;
 105     ireg.eax.b[0] = ch;
 106     ireg.ebx.b[1] = BIOS_PAGE;
 107     ireg.ebx.b[0] = attribute;
 108     ireg.ecx.w[0] = 1;
 109     __intcall(0x10, &ireg, NULL);
 110 }
 111
 112 static void bios_scroll_up(uint8_t cols, uint8_t rows, uint8_t attribute)
 113 {
 114     static com32sys_t ireg;
 115
 116     memset(&ireg, 0, sizeof(ireg));
 117
 118     ireg.eax.w[0] = 0x0601;
 119     ireg.ebx.b[1] = attribute;
 120     ireg.ecx.w[0] = 0;
 121     ireg.edx.b[1] = rows;
 122     ireg.edx.b[0] = cols;
 123     __intcall(0x10, &ireg, NULL);       /* Scroll */
 124 }
 125
 126 static void bios_beep(void)
 127 {
 128     static com32sys_t ireg;
 129
 130     memset(&ireg, 0, sizeof(ireg));
 131
 132     ireg.eax.w[0] = 0x0e07;
 133     ireg.ebx.b[1] = BIOS_PAGE;
 134     __intcall(0x10, &ireg, NULL);
 135 }
 136
 137 struct output_ops bios_output_ops = {
 138         .erase = bios_erase,
 139         .write_char = bios_write_char,
 140         .showcursor = bios_showcursor,
 141         .set_cursor = bios_set_cursor,
 142         .scroll_up = bios_scroll_up,
 143         .beep = bios_beep,
 144         .get_mode = bios_get_mode,
 145         .text_mode = bios_text_mode,
 146         .get_cursor = bios_get_cursor,
 147 };
 148
 149 extern char bios_getchar(char *);
 150 extern int bios_pollchar(void);
 151 extern uint8_t bios_shiftflags(void);
 152
 153 struct input_ops bios_input_ops = {
 154         .getchar = bios_getchar,
 155         .pollchar = bios_pollchar,
 156         .shiftflags = bios_shiftflags,
 157 };
 158
 159 static void bios_get_serial_console_info(uint16_t *iobase, uint16_t *divisor,
 160                                          uint16_t *flowctl)
 161 {
 162     *iobase = SerialPort;
 163     *divisor = BaudDivisor;
 164
 165     *flowctl = FlowOutput | FlowInput | (FlowIgnore << 4);
 166
 167     if (!DisplayCon)
 168         *flowctl |= (0x80 << 8);
 169 }
 170
 171 void bios_adv_init(void)
 172 {
 173     static com32sys_t reg;
 174
 175     memset(&reg, 0, sizeof(reg));
 176     call16(adv_init, &reg, NULL);
 177 }
 178
 179 int bios_adv_write(void)
 180 {
 181     static com32sys_t reg;
 182
 183     memset(&reg, 0, sizeof(reg));
 184     call16(adv_write, &reg, &reg);
 185     return (reg.eflags.l & EFLAGS_CF) ? -1 : 0;
 186 }
 187
 188 struct adv_ops bios_adv_ops = {
 189         .init = bios_adv_init,
 190         .write = bios_adv_write,
 191 };
 192
 193
 194 static int __constfunc is_power_of_2(unsigned int x)
 195 {
 196     return x && !(x & (x - 1));
 197 }
 198
 199 static int vesacon_paged_mode_ok(const struct vesa_mode_info *mi)
 200 {
 201     int i;
 202
 203     if (!is_power_of_2(mi->win_size) ||
 204         !is_power_of_2(mi->win_grain) || mi->win_grain > mi->win_size)
 205         return 0;               /* Impossible... */
 206
 207     for (i = 0; i < 2; i++) {
 208         if ((mi->win_attr[i] & 0x05) == 0x05 && mi->win_seg[i])
 209             return 1;           /* Usable window */
 210     }
 211
 212     return 0;                   /* Nope... */
 213 }
 214
 215 static int bios_vesacon_set_mode(struct vesa_info *vesa_info, int *px, int *py,
 216                                  enum vesa_pixel_format *bestpxf)
 217 {
 218     com32sys_t rm;
 219     uint16_t mode, bestmode, *mode_ptr;
 220     struct vesa_info *vi;
 221     struct vesa_general_info *gi;
 222     struct vesa_mode_info *mi;
 223     enum vesa_pixel_format pxf;
 224     int x = *px, y = *py;
 225     int err = 0;
 226
 227     /* Allocate space in the bounce buffer for these structures */
 228     vi = lzalloc(sizeof *vi);
 229     if (!vi) {
 230         err = 10;               /* Out of memory */
 231         goto exit;
 232     }
 233     gi = &vi->gi;
 234     mi = &vi->mi;
 235
 236     memset(&rm, 0, sizeof rm);
 237
 238     gi->signature = VBE2_MAGIC; /* Get VBE2 extended data */
 239     rm.eax.w[0] = 0x4F00;       /* Get SVGA general information */
 240     rm.edi.w[0] = OFFS(gi);
 241     rm.es = SEG(gi);
 242     __intcall(0x10, &rm, &rm);
 243
 244     if (rm.eax.w[0] != 0x004F) {
 245         err = 1;                /* Function call failed */
 246         goto exit;
 247     }
 248     if (gi->signature != VESA_MAGIC) {
 249         err = 2;                /* No magic */
 250         goto exit;
 251     }
 252     if (gi->version < 0x0102) {
 253         err = 3;                /* VESA 1.2+ required */
 254         goto exit;
 255     }
 256
 257     /* Copy general info */
 258     memcpy(&vesa_info->gi, gi, sizeof *gi);
 259
 260     /* Search for the proper mode with a suitable color and memory model... */
 261
 262     mode_ptr = GET_PTR(gi->video_mode_ptr);
 263     bestmode = 0;
 264     *bestpxf = PXF_NONE;
 265
 266     while ((mode = *mode_ptr++) != 0xFFFF) {
 267         mode &= 0x1FF;          /* The rest are attributes of sorts */
 268
 269         debug("Found mode: 0x%04x\r\n", mode);
 270
 271         memset(&rm, 0, sizeof rm);
 272         memset(mi, 0, sizeof *mi);
 273         rm.eax.w[0] = 0x4F01;   /* Get SVGA mode information */
 274         rm.ecx.w[0] = mode;
 275         rm.edi.w[0] = OFFS(mi);
 276         rm.es = SEG(mi);
 277         __intcall(0x10, &rm, &rm);
 278
 279         /* Must be a supported mode */
 280         if (rm.eax.w[0] != 0x004f)
 281             continue;
 282
 283         debug
 284             ("mode_attr 0x%04x, h_res = %4d, v_res = %4d, bpp = %2d, layout = %d (%d,%d,%d)\r\n",
 285              mi->mode_attr, mi->h_res, mi->v_res, mi->bpp, mi->memory_layout,
 286              mi->rpos, mi->gpos, mi->bpos);
 287
 288         /* Must be an LFB color graphics mode supported by the hardware.
 289
 290            The bits tested are:
 291            4 - graphics mode
 292            3 - color mode
 293            1 - mode information available (mandatory in VBE 1.2+)
 294            0 - mode supported by hardware
 295          */
 296         if ((mi->mode_attr & 0x001b) != 0x001b)
 297             continue;
 298
 299         /* Must be the chosen size */
 300         if (mi->h_res != x || mi->v_res != y)
 301             continue;
 302
 303         /* We don't support multibank (interlaced memory) modes */
 304         /*
 305          *  Note: The Bochs VESA BIOS (vbe.c 1.58 2006/08/19) violates the
 306          * specification which states that banks == 1 for unbanked modes;
 307          * fortunately it does report bank_size == 0 for those.
 308          */
 309         if (mi->banks > 1 && mi->bank_size) {
 310             debug("bad: banks = %d, banksize = %d, pages = %d\r\n",
 311                   mi->banks, mi->bank_size, mi->image_pages);
 312             continue;
 313         }
 314
 315         /* Must be either a flat-framebuffer mode, or be an acceptable
 316            paged mode */
 317         if (!(mi->mode_attr & 0x0080) && !vesacon_paged_mode_ok(mi)) {
 318             debug("bad: invalid paged mode\r\n");
 319             continue;
 320         }
 321
 322         /* Must either be a packed-pixel mode or a direct color mode
 323            (depending on VESA version ); must be a supported pixel format */
 324         pxf = PXF_NONE;         /* Not usable */
 325
 326         if (mi->bpp == 32 &&
 327             (mi->memory_layout == 4 ||
 328              (mi->memory_layout == 6 && mi->rpos == 16 && mi->gpos == 8 &&
 329               mi->bpos == 0)))
 330             pxf = PXF_BGRA32;
 331         else if (mi->bpp == 24 &&
 332                  (mi->memory_layout == 4 ||
 333                   (mi->memory_layout == 6 && mi->rpos == 16 && mi->gpos == 8 &&
 334                    mi->bpos == 0)))
 335             pxf = PXF_BGR24;
 336         else if (mi->bpp == 16 &&
 337                  (mi->memory_layout == 4 ||
 338                   (mi->memory_layout == 6 && mi->rpos == 11 && mi->gpos == 5 &&
 339                    mi->bpos == 0)))
 340             pxf = PXF_LE_RGB16_565;
 341         else if (mi->bpp == 15 &&
 342                  (mi->memory_layout == 4 ||
 343                   (mi->memory_layout == 6 && mi->rpos == 10 && mi->gpos == 5 &&
 344                    mi->bpos == 0)))
 345             pxf = PXF_LE_RGB15_555;
 346
 347         if (pxf < *bestpxf) {
 348             debug("Best mode so far, pxf = %d\r\n", pxf);
 349
 350             /* Best mode so far... */
 351             bestmode = mode;
 352             *bestpxf = pxf;
 353
 354             /* Copy mode info */
 355             memcpy(&vesa_info->mi, mi, sizeof *mi);
 356         }
 357     }
 358
 359     if (*bestpxf == PXF_NONE) {
 360         err = 4;                /* No mode found */
 361         goto exit;
 362     }
 363
 364     mi = &vesa_info->mi;
 365     mode = bestmode;
 366
 367     memset(&rm, 0, sizeof rm);
 368     /* Now set video mode */
 369     rm.eax.w[0] = 0x4F02;       /* Set SVGA video mode */
 370     if (mi->mode_attr & 0x0080)
 371         mode |= 0x4000;         /* Request linear framebuffer if supported */
 372     rm.ebx.w[0] = mode;
 373     __intcall(0x10, &rm, &rm);
 374     if (rm.eax.w[0] != 0x004F) {
 375         err = 9;                /* Failed to set mode */
 376         goto exit;
 377     }
 378
 379 exit:
 380     if (vi)
 381         lfree(vi);
 382
 383     return err;
 384 }
 385
 386 static void set_window_pos(struct win_info *wi, size_t win_pos)
 387 {
 388     static com32sys_t ireg;
 389
 390     wi->win_pos = win_pos;
 391
 392     if (wi->win_num < 0)
 393         return;                 /* This should never happen... */
 394
 395     memset(&ireg, 0, sizeof ireg);
 396     ireg.eax.w[0] = 0x4F05;
 397     ireg.ebx.b[0] = wi->win_num;
 398     ireg.edx.w[0] = win_pos >> wi->win_gshift;
 399
 400     __intcall(0x10, &ireg, NULL);
 401 }
 402
 403 static void bios_vesacon_screencpy(size_t dst, const uint32_t * src,
 404                                    size_t bytes, struct win_info *wi)
 405 {
 406     size_t win_pos, win_off;
 407     size_t win_size = wi->win_size;
 408     size_t omask = win_size - 1;
 409     char *win_base = wi->win_base;
 410     const char *s = (const char *)src;
 411     size_t l;
 412
 413     while (bytes) {
 414         win_off = dst & omask;
 415         win_pos = dst & ~omask;
 416
 417         if (__unlikely(win_pos != wi->win_pos))
 418             set_window_pos(wi, win_pos);
 419
 420         l = min(bytes, win_size - win_off);
 421         memcpy(win_base + win_off, s, l);
 422
 423         bytes -= l;
 424         s += l;
 425         dst += l;
 426     }
 427 }
 428
 429 static int bios_font_query(uint8_t **font)
 430 {
 431     com32sys_t rm;
 432
 433     /* Get BIOS 8x16 font */
 434
 435     memset(&rm, 0, sizeof rm);
 436
 437     rm.eax.w[0] = 0x1130;       /* Get Font Information */
 438     rm.ebx.w[0] = 0x0600;       /* Get 8x16 ROM font */
 439     __intcall(0x10, &rm, &rm);
 440     *font = MK_PTR(rm.es, rm.ebp.w[0]);
 441
 442     return 16;
 443
 444 }
 445 struct vesa_ops bios_vesa_ops = {
 446         .set_mode  = bios_vesacon_set_mode,
 447         .screencpy = bios_vesacon_screencpy,
 448         .font_query = bios_font_query,
 449 };
 450
 451 static uint32_t min_lowmem_heap = 65536;
 452 extern char __lowmem_heap[];
 453 uint8_t KbdFlags;               /* Check for keyboard escapes */
 454 __export uint8_t KbdMap[256];   /* Keyboard map */
 455
 456 __export uint16_t PXERetry;
 457
 458 static inline void check_escapes(void)
 459 {
 460         com32sys_t ireg, oreg;
 461
 462         memset(&ireg, 0, sizeof ireg);
 463         ireg.eax.b[1] = 0x02;   /* Check keyboard flags */
 464         __intcall(0x16, &ireg, &oreg);
 465
 466         KbdFlags = oreg.eax.b[0];
 467
 468         /* Ctrl->skip 386 check */
 469         if (!(oreg.eax.b[0] & 0x04)) {
 470                 /*
 471                  * Now check that there is sufficient low (DOS) memory
 472                  *
 473                  * NOTE: Linux doesn't use all of real_mode_seg, but we use
 474                  * the same segment for COMBOOT images, which can use all 64K.
 475                  */
 476                 uint32_t mem;
 477
 478                 __intcall(0x12, &ireg, &oreg);
 479
 480                 mem = ((uint32_t)__lowmem_heap) + min_lowmem_heap + 1023;
 481                 mem = mem >> 10;
 482
 483                 if (oreg.eax.w[0] < mem) {
 484                         char buf[256];
 485
 486                         snprintf(buf, sizeof(buf),
 487                                  "It appears your computer has only "
 488                                  "%dK of low (\"DOS\") RAM.\n"
 489                                  "This version of Syslinux needs "
 490                                  "%dK to boot.  "
 491                                  "If you get this\nmessage in error, "
 492                                  "hold down the Ctrl key while booting, "
 493                                  "and I\nwill take your word for it.\n",
 494                                  oreg.eax.w[0], mem);
 495                         writestr(buf);
 496                         kaboom();
 497                 }
 498         }
 499 }
 500
 501 extern uint32_t BIOS_timer_next;
 502 extern uint32_t timer_irq;
 503 static inline void bios_timer_init(void)
 504 {
 505         unsigned long next;
 506         uint32_t *hook = (uint32_t *)BIOS_timer_hook;
 507
 508         next = *hook;
 509         BIOS_timer_next = next;
 510         *hook = (uint32_t)&timer_irq;
 511 }
 512
 513 extern uint16_t *bios_free_mem;
 514
 515 struct e820_entry {
 516     uint64_t start;
 517     uint64_t len;
 518     uint32_t type;
 519 };
 520
 521 static int bios_scan_memory(scan_memory_callback_t callback, void *data)
 522 {
 523     static com32sys_t ireg;
 524     com32sys_t oreg;
 525     struct e820_entry *e820buf;
 526     uint64_t start, len, maxlen;
 527     int memfound = 0;
 528     int rv;
 529     addr_t dosmem;
 530     const addr_t bios_data = 0x510;     /* Amount to reserve for BIOS data */
 531
 532     /* Use INT 12h to get DOS memory */
 533     __intcall(0x12, &__com32_zero_regs, &oreg);
 534     dosmem = oreg.eax.w[0] << 10;
 535     if (dosmem < 32 * 1024 || dosmem > 640 * 1024) {
 536         /* INT 12h reports nonsense... now what? */
 537         uint16_t ebda_seg = *(uint16_t *) 0x40e;
 538         if (ebda_seg >= 0x8000 && ebda_seg < 0xa000)
 539             dosmem = ebda_seg << 4;
 540         else
 541             dosmem = 640 * 1024;        /* Hope for the best... */
 542     }
 543     rv = callback(data, bios_data, dosmem - bios_data, SMT_FREE);
 544     if (rv)
 545         return rv;
 546
 547     /* First try INT 15h AX=E820h */
 548     e820buf = lzalloc(sizeof *e820buf);
 549     if (!e820buf)
 550         return -1;
 551
 552     memset(&ireg, 0, sizeof ireg);
 553     ireg.eax.l = 0xe820;
 554     ireg.edx.l = 0x534d4150;
 555     ireg.ebx.l = 0;
 556     ireg.ecx.l = sizeof(*e820buf);
 557     ireg.es = SEG(e820buf);
 558     ireg.edi.w[0] = OFFS(e820buf);
 559
 560     do {
 561         __intcall(0x15, &ireg, &oreg);
 562
 563         if ((oreg.eflags.l & EFLAGS_CF) ||
 564             (oreg.eax.l != 0x534d4150) || (oreg.ecx.l < 20))
 565             break;
 566
 567         start = e820buf->start;
 568         len = e820buf->len;
 569
 570         if (start < 0x100000000ULL) {
 571             /* Don't rely on E820 being valid for low memory.  Doing so
 572                could mean stuff like overwriting the PXE stack even when
 573                using "keeppxe", etc. */
 574             if (start < 0x100000ULL) {
 575                 if (len > 0x100000ULL - start)
 576                     len -= 0x100000ULL - start;
 577                 else
 578                     len = 0;
 579                 start = 0x100000ULL;
 580             }
 581
 582             maxlen = 0x100000000ULL - start;
 583             if (len > maxlen)
 584                 len = maxlen;
 585
 586             if (len) {
 587                 enum syslinux_memmap_types type;
 588
 589                 type = e820buf->type == 1 ? SMT_FREE : SMT_RESERVED;
 590                 rv = callback(data, (addr_t) start, (addr_t) len, type);
 591                 if (rv)
 592                     return rv;
 593                 memfound = 1;
 594             }
 595         }
 596
 597         ireg.ebx.l = oreg.ebx.l;
 598     } while (oreg.ebx.l);
 599
 600     lfree(e820buf);
 601
 602     if (memfound)
 603         return 0;
 604
 605     /* Next try INT 15h AX=E801h */
 606     memset(&ireg, 0, sizeof ireg);
 607     ireg.eax.w[0] = 0xe801;
 608     __intcall(0x15, &ireg, &oreg);
 609
 610     if (!(oreg.eflags.l & EFLAGS_CF) && oreg.ecx.w[0]) {
 611         rv = callback(data, (addr_t) 1 << 20, oreg.ecx.w[0] << 10, SMT_FREE);
 612         if (rv)
 613             return rv;
 614
 615         if (oreg.edx.w[0]) {
 616             rv = callback(data, (addr_t) 16 << 20,
 617                           oreg.edx.w[0] << 16, SMT_FREE);
 618             if (rv)
 619                 return rv;
 620         }
 621
 622         return 0;
 623     }
 624
 625     /* Finally try INT 15h AH=88h */
 626     memset(&ireg, 0, sizeof ireg);
 627     ireg.eax.w[0] = 0x8800;
 628     __intcall(0x15, &ireg, &oreg);
 629     if (!(oreg.eflags.l & EFLAGS_CF) && oreg.eax.w[0]) {
 630         rv = callback(data, (addr_t) 1 << 20, oreg.ecx.w[0] << 10, SMT_FREE);
 631         if (rv)
 632             return rv;
 633     }
 634
 635     return 0;
 636 }
 637
 638 static struct syslinux_memscan bios_memscan = {
 639     .func = bios_scan_memory,
 640 };
 641
 642 void bios_init(void)
 643 {
 644         int i;
 645
 646         /* Initialize timer */
 647         bios_timer_init();
 648
 649         for (i = 0; i < 256; i++)
 650                 KbdMap[i] = i;
 651
 652         bios_adjust_screen();
 653
 654         /* Init the memory subsystem */
 655         bios_free_mem = (uint16_t *)0x413;
 656         syslinux_memscan_add(&bios_memscan);
 657         mem_init();
 658
 659         dprintf("%s%s", syslinux_banner, copyright_str);
 660
 661         /* CPU-dependent initialization and related checks. */
 662         check_escapes();
 663
 664         /*
 665          * Scan the DMI tables for interesting information.
 666          */
 667         dmi_init();
 668 }
 669
 670 extern void bios_timer_cleanup(void);
 671
 672 extern uint32_t OrigFDCTabPtr;
 673
 674 static void bios_cleanup_hardware(void)
 675 {
 676         /* Restore the original pointer to the floppy descriptor table */
 677         if (OrigFDCTabPtr)
 678                 *((uint32_t *)(4 * 0x1e)) = OrigFDCTabPtr;
 679
 680         /*
 681          * Linux wants the floppy motor shut off before starting the
 682          * kernel, at least bootsect.S seems to imply so.  If we don't
 683          * load the floppy driver, this is *definitely* so!
 684          */
 685         __intcall(0x13, &zero_regs, NULL);
 686
 687         call16(bios_timer_cleanup, &zero_regs, NULL);
 688
 689         /* If we enabled serial port interrupts, clean them up now */
 690         sirq_cleanup();
 691 }
 692
 693 extern void *bios_malloc(size_t, enum heap, size_t);
 694 extern void *bios_realloc(void *, size_t);
 695 extern void bios_free(void *);
 696
 697 struct mem_ops bios_mem_ops = {
 698         .malloc = bios_malloc,
 699         .realloc = bios_realloc,
 700         .free = bios_free,
 701 };
 702
 703 struct firmware bios_fw = {
 704         .init = bios_init,
 705         .adjust_screen = bios_adjust_screen,
 706         .cleanup = bios_cleanup_hardware,
 707         .disk_init = bios_disk_init,
 708         .o_ops = &bios_output_ops,
 709         .i_ops = &bios_input_ops,
 710         .get_serial_console_info = bios_get_serial_console_info,
 711         .adv_ops = &bios_adv_ops,
 712         .vesa = &bios_vesa_ops,
 713         .mem = &bios_mem_ops,
 714 };
 715
 716 void syslinux_register_bios(void)
 717 {
 718         firmware = &bios_fw;
 719 }