• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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(&reg, 0, sizeof(reg));
176     call16(adv_init, &reg, NULL);
177 }
178 
bios_adv_write(void)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 
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