![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to biosemu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / app / biosemu|
Return to biosemu.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / app / biosemu |
1.1 root 1: /******************************************************************************
2: * Copyright (c) 2004, 2008 IBM Corporation
3: * All rights reserved.
4: * This program and the accompanying materials
5: * are made available under the terms of the BSD License
6: * which accompanies this distribution, and is available at
7: * http://www.opensource.org/licenses/bsd-license.php
8: *
9: * Contributors:
10: * IBM Corporation - initial implementation
11: *****************************************************************************/
12:
13:
14: #include <stdio.h>
15: #include <stdlib.h>
16: #include <string.h>
17:
18: #include <stdint.h>
19: #include <cpu.h>
20:
21: #include "debug.h"
22:
23: #include <x86emu/x86emu.h>
24: #include <x86emu/regs.h>
25: #include <x86emu/prim_ops.h> // for push_word
26:
27: #include "biosemu.h"
28: #include "io.h"
29: #include "mem.h"
30: #include "interrupt.h"
31: #include "device.h"
32:
33: #include <rtas.h>
34:
35:
36: static X86EMU_memFuncs my_mem_funcs = {
37: my_rdb, my_rdw, my_rdl,
38: my_wrb, my_wrw, my_wrl
39: };
40:
41: static X86EMU_pioFuncs my_pio_funcs = {
42: my_inb, my_inw, my_inl,
43: my_outb, my_outw, my_outl
44: };
45:
46: void dump(uint8_t * addr, uint32_t len);
47:
48: uint32_t
49: biosemu(char argc, char **argv)
50: {
51: uint8_t *rom_image;
52: int i = 0;
53: uint8_t *biosmem;
54: uint32_t biosmem_size;
55: #ifdef DEBUG
56: //debug_flags = DEBUG_PRINT_INT10 | DEBUG_PNP;// | DEBUG_PMM;// | DEBUG_INTR | DEBUG_CHECK_VMEM_ACCESS | DEBUG_MEM | DEBUG_IO;// | DEBUG_TRACE_X86EMU | DEBUG_JMP;
57: #endif
58: if (argc < 4) {
59: printf("Usage %s <vmem_base> <vmem_size> <device_path> [<debug_flags>]\n", argv[0]);
60: for (i = 0; i < argc; i++) {
61: printf("argv[%d]: %s\n", i, argv[i]);
62: }
63: return -1;
64: }
65: // argv[1] is address of virtual BIOS mem...
66: // argv[2] is the size
67: biosmem = (uint8_t *) strtoul(argv[1], 0, 16);
68: biosmem_size = strtoul(argv[2], 0, 16);
69: if (biosmem_size < MIN_REQUIRED_VMEM_SIZE) {
70: printf("Error: Not enough virtual memory: %x, required: %x!\n",
71: biosmem_size, MIN_REQUIRED_VMEM_SIZE);
72: return -1;
73: }
74: // argv[3] is the device to open and use...
75: if (dev_init(argv[3]) != 0) {
76: printf("Error initializing device!\n");
77: return -1;
78: }
79: if (dev_check_exprom() != 0) {
80: printf("Error: Device Expansion ROM invalid!\n");
81: return -1;
82: }
83: // argv[4] if set, is additional debug_flags
84: if (argc >= 5) {
85: debug_flags |= strtoul(argv[4], 0, 16);
86: printf("debug_flags: %x\n", debug_flags);
87: }
88: rom_image = (uint8_t *) bios_device.img_addr;
89: DEBUG_PRINTF("executing rom_image from %p\n", rom_image);
90: DEBUG_PRINTF("biosmem at %p\n", biosmem);
91:
92: DEBUG_PRINTF("Image Size: %d\n", bios_device.img_size);
93:
94: // in case we jump somewhere unexpected, or execution is finished,
95: // fill the biosmem with hlt instructions (0xf4)
96: memset(biosmem, 0xf4, biosmem_size);
97:
98: M.mem_base = (long) biosmem;
99: M.mem_size = biosmem_size;
100: DEBUG_PRINTF("membase set: %08x, size: %08x\n", (int) M.mem_base,
101: (int) M.mem_size);
102:
103: // copy expansion ROM image to segment OPTION_ROM_CODE_SEGMENT
104: // NOTE: this sometimes fails, some bytes are 0x00... so we compare
105: // after copying and do some retries...
106: uint8_t *mem_img = biosmem + (OPTION_ROM_CODE_SEGMENT << 4);
107: uint8_t copy_count = 0;
108: uint8_t cmp_result = 0;
109: do {
110: #if 0
111: set_ci();
112: memcpy(mem_img, rom_image, len);
113: clr_ci();
114: #else
115: // memcpy fails... try copy byte-by-byte with set/clr_ci
116: uint8_t c;
117: for (i = 0; i < bios_device.img_size; i++) {
118: set_ci();
119: c = *(rom_image + i);
120: if (c != *(rom_image + i)) {
121: clr_ci();
122: printf("Copy failed at: %x/%x\n", i,
123: bios_device.img_size);
124: printf("rom_image(%x): %x, mem_img(%x): %x\n",
125: i, *(rom_image + i), i, *(mem_img + i));
126: break;
127: }
128: clr_ci();
129: *(mem_img + i) = c;
130: }
131: #endif
132: copy_count++;
133: set_ci();
134: cmp_result = memcmp(mem_img, rom_image, bios_device.img_size);
135: clr_ci();
136: }
137: while ((copy_count < 5) && (cmp_result != 0));
138: if (cmp_result != 0) {
139: printf
140: ("\nCopying Expansion ROM Image to Memory failed after %d retries! (%x)\n",
141: copy_count, cmp_result);
142: dump(rom_image, 0x20);
143: dump(mem_img, 0x20);
144: return 0;
145: }
146: // setup default Interrupt Vectors
147: // some expansion ROMs seem to check for these addresses..
148: // each handler is only an IRET (0xCF) instruction
149: // ROM BIOS Int 10 Handler F000:F065
150: my_wrl(0x10 * 4, 0xf000f065);
151: my_wrb(0x000ff065, 0xcf);
152: // ROM BIOS Int 11 Handler F000:F84D
153: my_wrl(0x11 * 4, 0xf000f84d);
154: my_wrb(0x000ff84d, 0xcf);
155: // ROM BIOS Int 12 Handler F000:F841
156: my_wrl(0x12 * 4, 0xf000f841);
157: my_wrb(0x000ff841, 0xcf);
158: // ROM BIOS Int 13 Handler F000:EC59
159: my_wrl(0x13 * 4, 0xf000ec59);
160: my_wrb(0x000fec59, 0xcf);
161: // ROM BIOS Int 14 Handler F000:E739
162: my_wrl(0x14 * 4, 0xf000e739);
163: my_wrb(0x000fe739, 0xcf);
164: // ROM BIOS Int 15 Handler F000:F859
165: my_wrl(0x15 * 4, 0xf000f859);
166: my_wrb(0x000ff859, 0xcf);
167: // ROM BIOS Int 16 Handler F000:E82E
168: my_wrl(0x16 * 4, 0xf000e82e);
169: my_wrb(0x000fe82e, 0xcf);
170: // ROM BIOS Int 17 Handler F000:EFD2
171: my_wrl(0x17 * 4, 0xf000efd2);
172: my_wrb(0x000fefd2, 0xcf);
173: // ROM BIOS Int 1A Handler F000:FE6E
174: my_wrl(0x1a * 4, 0xf000fe6e);
175: my_wrb(0x000ffe6e, 0xcf);
176:
177: // setup BIOS Data Area (0000:04xx, or 0040:00xx)
178: // we currently 0 this area, meaning "we dont have
179: // any hardware" :-) no serial/parallel ports, floppys, ...
180: memset(biosmem + 0x400, 0x0, 0x100);
181:
182: // at offset 13h in BDA is the memory size in kbytes
183: my_wrw(0x413, biosmem_size / 1024);
184: // at offset 0eh in BDA is the segment of the Extended BIOS Data Area
185: // see setup further down
186: my_wrw(0x40e, INITIAL_EBDA_SEGMENT);
187: // TODO: setup BDA Video Data ( offset 49h-66h)
188: // e.g. to store video mode, cursor position, ...
189: // in int10 (done) handler and VBE Functions
190:
191: // TODO: setup BDA Fixed Disk Data
192: // 74h: Fixed Disk Last Operation Status
193: // 75h: Fixed Disk Number of Disk Drives
194:
195: // TODO: check BDA for further needed data...
196:
197: //setup Extended BIOS Data Area
198: //we currently 0 this area
199: memset(biosmem + (INITIAL_EBDA_SEGMENT << 4), 0, INITIAL_EBDA_SIZE);
200: // at offset 0h in EBDA is the size of the EBDA in KB
201: my_wrw((INITIAL_EBDA_SEGMENT << 4) + 0x0, INITIAL_EBDA_SIZE / 1024);
202: //TODO: check for further needed EBDA data...
203:
204: // setup original ROM BIOS Area (F000:xxxx)
205: char *date = "06/11/99";
206: for (i = 0; date[i]; i++)
207: my_wrb(0xffff5 + i, date[i]);
208: // set up eisa ident string
209: char *ident = "PCI_ISA";
210: for (i = 0; ident[i]; i++)
211: my_wrb(0xfffd9 + i, ident[i]);
212:
213: // write system model id for IBM-AT
214: // according to "Ralf Browns Interrupt List" Int15 AH=C0 Table 515,
215: // model FC is the original AT and also used in all DOSEMU Versions.
216: my_wrb(0xFFFFE, 0xfc);
217:
218: //setup interrupt handler
219: X86EMU_intrFuncs intrFuncs[256];
220: for (i = 0; i < 256; i++)
221: intrFuncs[i] = handleInterrupt;
222: X86EMU_setupIntrFuncs(intrFuncs);
223: X86EMU_setupPioFuncs(&my_pio_funcs);
224: X86EMU_setupMemFuncs(&my_mem_funcs);
225:
226: // setup the CPU
227: M.x86.R_AH = bios_device.bus;
228: M.x86.R_AL = bios_device.devfn;
229: M.x86.R_DX = 0x80;
230: M.x86.R_EIP = 3;
231: M.x86.R_CS = OPTION_ROM_CODE_SEGMENT;
232:
233: // Initialize stack and data segment
234: M.x86.R_SS = STACK_SEGMENT;
235: M.x86.R_SP = STACK_START_OFFSET;
236: M.x86.R_DS = DATA_SEGMENT;
237:
238: // push a HLT instruction and a pointer to it onto the stack
239: // any return will pop the pointer and jump to the HLT, thus
240: // exiting (more or less) cleanly
241: push_word(0xf4f4); //F4=HLT
242: push_word(M.x86.R_SS);
243: push_word(M.x86.R_SP + 2);
244:
245: CHECK_DBG(DEBUG_TRACE_X86EMU) {
246: X86EMU_trace_on();
247: } else {
248: #ifdef DEBUG
249: M.x86.debug |= DEBUG_SAVE_IP_CS_F;
250: M.x86.debug |= DEBUG_DECODE_F;
251: M.x86.debug |= DEBUG_DECODE_NOPRINT_F;
252: #endif
253: }
254: CHECK_DBG(DEBUG_JMP) {
255: M.x86.debug |= DEBUG_TRACEJMP_F;
256: M.x86.debug |= DEBUG_TRACEJMP_REGS_F;
257: M.x86.debug |= DEBUG_TRACECALL_F;
258: M.x86.debug |= DEBUG_TRACECALL_REGS_F;
259: }
260:
261: DEBUG_PRINTF("Executing Initialization Vector...\n");
262: X86EMU_exec();
263: DEBUG_PRINTF("done\n");
264:
265: // according to PNP BIOS Spec, Option ROMs should upon exit, return some boot device status in
266: // AX (see PNP BIOS Spec Section 3.3
267: DEBUG_PRINTF_CS_IP("Option ROM Exit Status: %04x\n", M.x86.R_AX);
268: #ifdef DEBUG
269: DEBUG_PRINTF("Exit Status Decode:\n");
270: if (M.x86.R_AX & 0x100) { // bit 8
271: DEBUG_PRINTF
272: (" IPL Device supporting INT 13h Block Device Format:\n");
273: switch (((M.x86.R_AX >> 4) & 0x3)) { // bits 5:4
274: case 0:
275: DEBUG_PRINTF(" No IPL Device attached\n");
276: break;
277: case 1:
278: DEBUG_PRINTF(" IPL Device status unknown\n");
279: break;
280: case 2:
281: DEBUG_PRINTF(" IPL Device attached\n");
282: break;
283: case 3:
284: DEBUG_PRINTF(" IPL Device status RESERVED!!\n");
285: break;
286: }
287: }
288: if (M.x86.R_AX & 0x80) { // bit 7
289: DEBUG_PRINTF
290: (" Output Device supporting INT 10h Character Output:\n");
291: switch (((M.x86.R_AX >> 4) & 0x3)) { // bits 5:4
292: case 0:
293: DEBUG_PRINTF(" No Display Device attached\n");
294: break;
295: case 1:
296: DEBUG_PRINTF(" Display Device status unknown\n");
297: break;
298: case 2:
299: DEBUG_PRINTF(" Display Device attached\n");
300: break;
301: case 3:
302: DEBUG_PRINTF(" Display Device status RESERVED!!\n");
303: break;
304: }
305: }
306: if (M.x86.R_AX & 0x40) { // bit 6
307: DEBUG_PRINTF
308: (" Input Device supporting INT 9h Character Input:\n");
309: switch (((M.x86.R_AX >> 4) & 0x3)) { // bits 5:4
310: case 0:
311: DEBUG_PRINTF(" No Input Device attached\n");
312: break;
313: case 1:
314: DEBUG_PRINTF(" Input Device status unknown\n");
315: break;
316: case 2:
317: DEBUG_PRINTF(" Input Device attached\n");
318: break;
319: case 3:
320: DEBUG_PRINTF(" Input Device status RESERVED!!\n");
321: break;
322: }
323: }
324: #endif
325: // check wether the stack is "clean" i.e. containing the HLT instruction
326: // we pushed before executing, and pointing to the original stack address...
327: // indicating that the initialization probably was successful
328: if ((pop_word() == 0xf4f4) && (M.x86.R_SS == STACK_SEGMENT)
329: && (M.x86.R_SP == STACK_START_OFFSET)) {
330: DEBUG_PRINTF("Stack is clean, initialization successfull!\n");
331: } else {
332: DEBUG_PRINTF
333: ("Stack unclean, initialization probably NOT COMPLETE!!!\n");
334: DEBUG_PRINTF("SS:SP = %04x:%04x, expected: %04x:%04x\n",
335: M.x86.R_SS, M.x86.R_SP, STACK_SEGMENT,
336: STACK_START_OFFSET);
337: }
338:
339:
340: // TODO: according to the BIOS Boot Spec initializations may be ended using INT18h and setting
341: // the status.
342: // We need to implement INT18 accordingly, pseudo code is in specsbbs101.pdf page 30
343: // (also for Int19)
344: return 0;
345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.