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
bios_text_mode(void)26 static void bios_text_mode(void)
27 {
28 syslinux_force_text_mode();
29 }
30
bios_get_mode(int * cols,int * rows)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
bios_get_cursor(uint8_t * x,uint8_t * y)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
bios_erase(int x0,int y0,int x1,int y1,uint8_t attribute)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
bios_showcursor(const struct term_state * st)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
bios_set_cursor(int x,int y,bool visible)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
bios_write_char(uint8_t ch,uint8_t attribute)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
bios_scroll_up(uint8_t cols,uint8_t rows,uint8_t attribute)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
bios_beep(void)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
bios_get_serial_console_info(uint16_t * iobase,uint16_t * divisor,uint16_t * flowctl)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
bios_adv_init(void)171 void bios_adv_init(void)
172 {
173 static com32sys_t reg;
174
175 memset(®, 0, sizeof(reg));
176 call16(adv_init, ®, NULL);
177 }
178
bios_adv_write(void)179 int bios_adv_write(void)
180 {
181 static com32sys_t reg;
182
183 memset(®, 0, sizeof(reg));
184 call16(adv_write, ®, ®);
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
is_power_of_2(unsigned int x)194 static int __constfunc is_power_of_2(unsigned int x)
195 {
196 return x && !(x & (x - 1));
197 }
198
vesacon_paged_mode_ok(const struct vesa_mode_info * mi)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
bios_vesacon_set_mode(struct vesa_info * vesa_info,int * px,int * py,enum vesa_pixel_format * bestpxf)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
set_window_pos(struct win_info * wi,size_t win_pos)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
bios_vesacon_screencpy(size_t dst,const uint32_t * src,size_t bytes,struct win_info * wi)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
bios_font_query(uint8_t ** font)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
check_escapes(void)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;
bios_timer_init(void)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
bios_scan_memory(scan_memory_callback_t callback,void * data)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
bios_init(void)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
bios_cleanup_hardware(void)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
syslinux_register_bios(void)716 void syslinux_register_bios(void)
717 {
718 firmware = &bios_fw;
719 }
720