![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mem.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 mem.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: #include <stdio.h>
14: #include <stdint.h>
15: #include <cpu.h>
16: #include "debug.h"
17: #include "device.h"
18: #include "x86emu/x86emu.h"
19: #include "biosemu.h"
20: #include <time.h>
21:
22: // define a check for access to certain (virtual) memory regions (interrupt handlers, BIOS Data Area, ...)
23: #ifdef DEBUG
24: static uint8_t in_check = 0; // to avoid recursion...
25: uint16_t ebda_segment;
26: uint32_t ebda_size;
27:
28: //TODO: these macros have grown so large, that they should be changed to an inline function,
29: //just for the sake of readability...
30:
31: //declare prototypes of the functions to follow, for use in DEBUG_CHECK_VMEM_ACCESS
32: uint8_t my_rdb(uint32_t);
33: uint16_t my_rdw(uint32_t);
34: uint32_t my_rdl(uint32_t);
35:
36: #define DEBUG_CHECK_VMEM_READ(_addr, _rval) \
37: if ((debug_flags & DEBUG_CHECK_VMEM_ACCESS) && (in_check == 0)) { \
38: in_check = 1; \
39: /* determine ebda_segment and size \
40: * since we are using my_rdx calls, make sure, this is after setting in_check! */ \
41: /* offset 03 in BDA is EBDA segment */ \
42: ebda_segment = my_rdw(0x40e); \
43: /* first value in ebda is size in KB */ \
44: ebda_size = my_rdb(ebda_segment << 4) * 1024; \
45: /* check Interrupt Vector Access (0000:0000h - 0000:0400h) */ \
46: if (_addr < 0x400) { \
47: DEBUG_PRINTF_CS_IP("%s: read from Interrupt Vector %x --> %x\n", \
48: __FUNCTION__, _addr / 4, _rval); \
49: } \
50: /* access to BIOS Data Area (0000:0400h - 0000:0500h)*/ \
51: else if ((_addr >= 0x400) && (addr < 0x500)) { \
52: DEBUG_PRINTF_CS_IP("%s: read from BIOS Data Area: addr: %x --> %x\n", \
53: __FUNCTION__, _addr, _rval); \
54: /* dump registers */ \
55: /* x86emu_dump_xregs(); */ \
56: } \
57: /* access to first 64k of memory... */ \
58: else if (_addr < 0x10000) { \
59: DEBUG_PRINTF_CS_IP("%s: read from segment 0000h: addr: %x --> %x\n", \
60: __FUNCTION__, _addr, _rval); \
61: /* dump registers */ \
62: /* x86emu_dump_xregs(); */ \
63: } \
64: /* read from PMM_CONV_SEGMENT */ \
65: else if ((_addr <= ((PMM_CONV_SEGMENT << 4) | 0xffff)) && (_addr >= (PMM_CONV_SEGMENT << 4))) { \
66: DEBUG_PRINTF_CS_IP("%s: read from PMM Segment %04xh: addr: %x --> %x\n", \
67: __FUNCTION__, PMM_CONV_SEGMENT, _addr, _rval); \
68: /* HALT_SYS(); */ \
69: /* dump registers */ \
70: /* x86emu_dump_xregs(); */ \
71: } \
72: /* read from PNP_DATA_SEGMENT */ \
73: else if ((_addr <= ((PNP_DATA_SEGMENT << 4) | 0xffff)) && (_addr >= (PNP_DATA_SEGMENT << 4))) { \
74: DEBUG_PRINTF_CS_IP("%s: read from PnP Data Segment %04xh: addr: %x --> %x\n", \
75: __FUNCTION__, PNP_DATA_SEGMENT, _addr, _rval); \
76: /* HALT_SYS(); */ \
77: /* dump registers */ \
78: /* x86emu_dump_xregs(); */ \
79: } \
80: /* read from EBDA Segment */ \
81: else if ((_addr <= ((ebda_segment << 4) | (ebda_size - 1))) && (_addr >= (ebda_segment << 4))) { \
82: DEBUG_PRINTF_CS_IP("%s: read from Extended BIOS Data Area %04xh, size: %04x: addr: %x --> %x\n", \
83: __FUNCTION__, ebda_segment, ebda_size, _addr, _rval); \
84: } \
85: /* read from BIOS_DATA_SEGMENT */ \
86: else if ((_addr <= ((BIOS_DATA_SEGMENT << 4) | 0xffff)) && (_addr >= (BIOS_DATA_SEGMENT << 4))) { \
87: DEBUG_PRINTF_CS_IP("%s: read from BIOS Data Segment %04xh: addr: %x --> %x\n", \
88: __FUNCTION__, BIOS_DATA_SEGMENT, _addr, _rval); \
89: /* for PMM debugging */ \
90: /*if (_addr == BIOS_DATA_SEGMENT << 4) { \
91: X86EMU_trace_on(); \
92: M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; \
93: }*/ \
94: /* dump registers */ \
95: /* x86emu_dump_xregs(); */ \
96: } \
97: in_check = 0; \
98: }
99: #define DEBUG_CHECK_VMEM_WRITE(_addr, _val) \
100: if ((debug_flags & DEBUG_CHECK_VMEM_ACCESS) && (in_check == 0)) { \
101: in_check = 1; \
102: /* determine ebda_segment and size \
103: * since we are using my_rdx calls, make sure, this is after setting in_check! */ \
104: /* offset 03 in BDA is EBDA segment */ \
105: ebda_segment = my_rdw(0x40e); \
106: /* first value in ebda is size in KB */ \
107: ebda_size = my_rdb(ebda_segment << 4) * 1024; \
108: /* check Interrupt Vector Access (0000:0000h - 0000:0400h) */ \
109: if (_addr < 0x400) { \
110: DEBUG_PRINTF_CS_IP("%s: write to Interrupt Vector %x <-- %x\n", \
111: __FUNCTION__, _addr / 4, _val); \
112: } \
113: /* access to BIOS Data Area (0000:0400h - 0000:0500h)*/ \
114: else if ((_addr >= 0x400) && (addr < 0x500)) { \
115: DEBUG_PRINTF_CS_IP("%s: write to BIOS Data Area: addr: %x <-- %x\n", \
116: __FUNCTION__, _addr, _val); \
117: /* dump registers */ \
118: /* x86emu_dump_xregs(); */ \
119: } \
120: /* access to first 64k of memory...*/ \
121: else if (_addr < 0x10000) { \
122: DEBUG_PRINTF_CS_IP("%s: write to segment 0000h: addr: %x <-- %x\n", \
123: __FUNCTION__, _addr, _val); \
124: /* dump registers */ \
125: /* x86emu_dump_xregs(); */ \
126: } \
127: /* write to PMM_CONV_SEGMENT... */ \
128: else if ((_addr <= ((PMM_CONV_SEGMENT << 4) | 0xffff)) && (_addr >= (PMM_CONV_SEGMENT << 4))) { \
129: DEBUG_PRINTF_CS_IP("%s: write to PMM Segment %04xh: addr: %x <-- %x\n", \
130: __FUNCTION__, PMM_CONV_SEGMENT, _addr, _val); \
131: /* dump registers */ \
132: /* x86emu_dump_xregs(); */ \
133: } \
134: /* write to PNP_DATA_SEGMENT... */ \
135: else if ((_addr <= ((PNP_DATA_SEGMENT << 4) | 0xffff)) && (_addr >= (PNP_DATA_SEGMENT << 4))) { \
136: DEBUG_PRINTF_CS_IP("%s: write to PnP Data Segment %04xh: addr: %x <-- %x\n", \
137: __FUNCTION__, PNP_DATA_SEGMENT, _addr, _val); \
138: /* dump registers */ \
139: /* x86emu_dump_xregs(); */ \
140: } \
141: /* write to EBDA Segment... */ \
142: else if ((_addr <= ((ebda_segment << 4) | (ebda_size - 1))) && (_addr >= (ebda_segment << 4))) { \
143: DEBUG_PRINTF_CS_IP("%s: write to Extended BIOS Data Area %04xh, size: %04x: addr: %x <-- %x\n", \
144: __FUNCTION__, ebda_segment, ebda_size, _addr, _val); \
145: } \
146: /* write to BIOS_DATA_SEGMENT... */ \
147: else if ((_addr <= ((BIOS_DATA_SEGMENT << 4) | 0xffff)) && (_addr >= (BIOS_DATA_SEGMENT << 4))) { \
148: DEBUG_PRINTF_CS_IP("%s: write to BIOS Data Segment %04xh: addr: %x <-- %x\n", \
149: __FUNCTION__, BIOS_DATA_SEGMENT, _addr, _val); \
150: /* dump registers */ \
151: /* x86emu_dump_xregs(); */ \
152: } \
153: /* write to current CS segment... */ \
154: else if ((_addr < ((M.x86.R_CS << 4) | 0xffff)) && (_addr > (M.x86.R_CS << 4))) { \
155: DEBUG_PRINTF_CS_IP("%s: write to CS segment %04xh: addr: %x <-- %x\n", \
156: __FUNCTION__, M.x86.R_CS, _addr, _val); \
157: /* dump registers */ \
158: /* x86emu_dump_xregs(); */ \
159: } \
160: in_check = 0; \
161: }
162: #else
163: #define DEBUG_CHECK_VMEM_READ(_addr, _rval)
164: #define DEBUG_CHECK_VMEM_WRITE(_addr, _val)
165: #endif
166:
167: //defined in net-snk/kernel/timer.c
168: extern uint64_t get_time(void);
169:
170: void update_time(uint32_t);
171:
172: // read byte from memory
173: uint8_t
174: my_rdb(uint32_t addr)
175: {
176: uint64_t translated_addr = addr;
177: uint8_t translated = dev_translate_address(&translated_addr);
178: uint8_t rval;
179: if (translated != 0) {
180: //translation successfull, access VGA Memory (BAR or Legacy...)
181: DEBUG_PRINTF_MEM("%s(%08x): access to VGA Memory\n",
182: __FUNCTION__, addr);
183: //DEBUG_PRINTF_MEM("%s(%08x): translated_addr: %llx\n", __FUNCTION__, addr, translated_addr);
184: set_ci();
185: rval = *((uint8_t *) translated_addr);
186: clr_ci();
187: DEBUG_PRINTF_MEM("%s(%08x) VGA --> %02x\n", __FUNCTION__, addr,
188: rval);
189: return rval;
190: } else if (addr > M.mem_size) {
191: DEBUG_PRINTF("%s(%08x): Memory Access out of range!\n",
192: __FUNCTION__, addr);
193: //disassemble_forward(M.x86.saved_cs, M.x86.saved_ip, 1);
194: HALT_SYS();
195: } else {
196: /* read from virtual memory */
197: rval = *((uint8_t *) (M.mem_base + addr));
198: DEBUG_CHECK_VMEM_READ(addr, rval);
199: return rval;
200: }
201: return -1;
202: }
203:
204: //read word from memory
205: uint16_t
206: my_rdw(uint32_t addr)
207: {
208: uint64_t translated_addr = addr;
209: uint8_t translated = dev_translate_address(&translated_addr);
210: uint16_t rval;
211: if (translated != 0) {
212: //translation successfull, access VGA Memory (BAR or Legacy...)
213: DEBUG_PRINTF_MEM("%s(%08x): access to VGA Memory\n",
214: __FUNCTION__, addr);
215: //DEBUG_PRINTF_MEM("%s(%08x): translated_addr: %llx\n", __FUNCTION__, addr, translated_addr);
216: // check for legacy memory, because of the remapping to BARs, the reads must
217: // be byte reads...
218: if ((addr >= 0xa0000) && (addr < 0xc0000)) {
219: //read bytes a using my_rdb, because of the remapping to BARs
220: //words may not be contiguous in memory, so we need to translate
221: //every address...
222: rval = ((uint8_t) my_rdb(addr)) |
223: (((uint8_t) my_rdb(addr + 1)) << 8);
224: } else {
225: if ((translated_addr & (uint64_t) 0x1) == 0) {
226: // 16 bit aligned access...
227: set_ci();
228: rval = in16le((void *) translated_addr);
229: clr_ci();
230: } else {
231: // unaligned access, read single bytes
232: set_ci();
233: rval = (*((uint8_t *) translated_addr)) |
234: (*((uint8_t *) translated_addr + 1) << 8);
235: clr_ci();
236: }
237: }
238: DEBUG_PRINTF_MEM("%s(%08x) VGA --> %04x\n", __FUNCTION__, addr,
239: rval);
240: return rval;
241: } else if (addr > M.mem_size) {
242: DEBUG_PRINTF("%s(%08x): Memory Access out of range!\n",
243: __FUNCTION__, addr);
244: //disassemble_forward(M.x86.saved_cs, M.x86.saved_ip, 1);
245: HALT_SYS();
246: } else {
247: /* read from virtual memory */
248: rval = in16le((void *) (M.mem_base + addr));
249: DEBUG_CHECK_VMEM_READ(addr, rval);
250: return rval;
251: }
252: return -1;
253: }
254:
255: //read long from memory
256: uint32_t
257: my_rdl(uint32_t addr)
258: {
259: uint64_t translated_addr = addr;
260: uint8_t translated = dev_translate_address(&translated_addr);
261: uint32_t rval;
262: if (translated != 0) {
263: //translation successfull, access VGA Memory (BAR or Legacy...)
264: DEBUG_PRINTF_MEM("%s(%x): access to VGA Memory\n",
265: __FUNCTION__, addr);
266: //DEBUG_PRINTF_MEM("%s(%08x): translated_addr: %llx\n", __FUNCTION__, addr, translated_addr);
267: // check for legacy memory, because of the remapping to BARs, the reads must
268: // be byte reads...
269: if ((addr >= 0xa0000) && (addr < 0xc0000)) {
270: //read bytes a using my_rdb, because of the remapping to BARs
271: //dwords may not be contiguous in memory, so we need to translate
272: //every address...
273: rval = ((uint8_t) my_rdb(addr)) |
274: (((uint8_t) my_rdb(addr + 1)) << 8) |
275: (((uint8_t) my_rdb(addr + 2)) << 16) |
276: (((uint8_t) my_rdb(addr + 3)) << 24);
277: } else {
278: if ((translated_addr & (uint64_t) 0x3) == 0) {
279: // 32 bit aligned access...
280: set_ci();
281: rval = in32le((void *) translated_addr);
282: clr_ci();
283: } else {
284: // unaligned access, read single bytes
285: set_ci();
286: rval = (*((uint8_t *) translated_addr)) |
287: (*((uint8_t *) translated_addr + 1) << 8) |
288: (*((uint8_t *) translated_addr + 2) << 16) |
289: (*((uint8_t *) translated_addr + 3) << 24);
290: clr_ci();
291: }
292: }
293: DEBUG_PRINTF_MEM("%s(%08x) VGA --> %08x\n", __FUNCTION__, addr,
294: rval);
295: //HALT_SYS();
296: return rval;
297: } else if (addr > M.mem_size) {
298: DEBUG_PRINTF("%s(%08x): Memory Access out of range!\n",
299: __FUNCTION__, addr);
300: //disassemble_forward(M.x86.saved_cs, M.x86.saved_ip, 1);
301: HALT_SYS();
302: } else {
303: /* read from virtual memory */
304: rval = in32le((void *) (M.mem_base + addr));
305: switch (addr) {
306: case 0x46c:
307: //BDA Time Data, update it, before reading
308: update_time(rval);
309: rval = in32le((void *) (M.mem_base + addr));
310: break;
311: }
312: DEBUG_CHECK_VMEM_READ(addr, rval);
313: return rval;
314: }
315: return -1;
316: }
317:
318: //write byte to memory
319: void
320: my_wrb(uint32_t addr, uint8_t val)
321: {
322: uint64_t translated_addr = addr;
323: uint8_t translated = dev_translate_address(&translated_addr);
324: if (translated != 0) {
325: //translation successfull, access VGA Memory (BAR or Legacy...)
326: DEBUG_PRINTF_MEM("%s(%x, %x): access to VGA Memory\n",
327: __FUNCTION__, addr, val);
328: //DEBUG_PRINTF_MEM("%s(%08x): translated_addr: %llx\n", __FUNCTION__, addr, translated_addr);
329: set_ci();
330: *((uint8_t *) translated_addr) = val;
331: clr_ci();
332: } else if (addr > M.mem_size) {
333: DEBUG_PRINTF("%s(%08x): Memory Access out of range!\n",
334: __FUNCTION__, addr);
335: //disassemble_forward(M.x86.saved_cs, M.x86.saved_ip, 1);
336: HALT_SYS();
337: } else {
338: /* write to virtual memory */
339: DEBUG_CHECK_VMEM_WRITE(addr, val);
340: *((uint8_t *) (M.mem_base + addr)) = val;
341: }
342: }
343:
344: void
345: my_wrw(uint32_t addr, uint16_t val)
346: {
347: uint64_t translated_addr = addr;
348: uint8_t translated = dev_translate_address(&translated_addr);
349: if (translated != 0) {
350: //translation successfull, access VGA Memory (BAR or Legacy...)
351: DEBUG_PRINTF_MEM("%s(%x, %x): access to VGA Memory\n",
352: __FUNCTION__, addr, val);
353: //DEBUG_PRINTF_MEM("%s(%08x): translated_addr: %llx\n", __FUNCTION__, addr, translated_addr);
354: // check for legacy memory, because of the remapping to BARs, the reads must
355: // be byte reads...
356: if ((addr >= 0xa0000) && (addr < 0xc0000)) {
357: //read bytes a using my_rdb, because of the remapping to BARs
358: //words may not be contiguous in memory, so we need to translate
359: //every address...
360: my_wrb(addr, (uint8_t) (val & 0x00FF));
361: my_wrb(addr + 1, (uint8_t) ((val & 0xFF00) >> 8));
362: } else {
363: if ((translated_addr & (uint64_t) 0x1) == 0) {
364: // 16 bit aligned access...
365: set_ci();
366: out16le((void *) translated_addr, val);
367: clr_ci();
368: } else {
369: // unaligned access, write single bytes
370: set_ci();
371: *((uint8_t *) translated_addr) =
372: (uint8_t) (val & 0x00FF);
373: *((uint8_t *) translated_addr + 1) =
374: (uint8_t) ((val & 0xFF00) >> 8);
375: clr_ci();
376: }
377: }
378: } else if (addr > M.mem_size) {
379: DEBUG_PRINTF("%s(%08x): Memory Access out of range!\n",
380: __FUNCTION__, addr);
381: //disassemble_forward(M.x86.saved_cs, M.x86.saved_ip, 1);
382: HALT_SYS();
383: } else {
384: /* write to virtual memory */
385: DEBUG_CHECK_VMEM_WRITE(addr, val);
386: out16le((void *) (M.mem_base + addr), val);
387: }
388: }
389: void
390: my_wrl(uint32_t addr, uint32_t val)
391: {
392: uint64_t translated_addr = addr;
393: uint8_t translated = dev_translate_address(&translated_addr);
394: if (translated != 0) {
395: //translation successfull, access VGA Memory (BAR or Legacy...)
396: DEBUG_PRINTF_MEM("%s(%x, %x): access to VGA Memory\n",
397: __FUNCTION__, addr, val);
398: //DEBUG_PRINTF_MEM("%s(%08x): translated_addr: %llx\n", __FUNCTION__, addr, translated_addr);
399: // check for legacy memory, because of the remapping to BARs, the reads must
400: // be byte reads...
401: if ((addr >= 0xa0000) && (addr < 0xc0000)) {
402: //read bytes a using my_rdb, because of the remapping to BARs
403: //words may not be contiguous in memory, so we need to translate
404: //every address...
405: my_wrb(addr, (uint8_t) (val & 0x000000FF));
406: my_wrb(addr + 1, (uint8_t) ((val & 0x0000FF00) >> 8));
407: my_wrb(addr + 2, (uint8_t) ((val & 0x00FF0000) >> 16));
408: my_wrb(addr + 3, (uint8_t) ((val & 0xFF000000) >> 24));
409: } else {
410: if ((translated_addr & (uint64_t) 0x3) == 0) {
411: // 32 bit aligned access...
412: set_ci();
413: out32le((void *) translated_addr, val);
414: clr_ci();
415: } else {
416: // unaligned access, write single bytes
417: set_ci();
418: *((uint8_t *) translated_addr) =
419: (uint8_t) (val & 0x000000FF);
420: *((uint8_t *) translated_addr + 1) =
421: (uint8_t) ((val & 0x0000FF00) >> 8);
422: *((uint8_t *) translated_addr + 2) =
423: (uint8_t) ((val & 0x00FF0000) >> 16);
424: *((uint8_t *) translated_addr + 3) =
425: (uint8_t) ((val & 0xFF000000) >> 24);
426: clr_ci();
427: }
428: }
429: } else if (addr > M.mem_size) {
430: DEBUG_PRINTF("%s(%08x): Memory Access out of range!\n",
431: __FUNCTION__, addr);
432: //disassemble_forward(M.x86.saved_cs, M.x86.saved_ip, 1);
433: HALT_SYS();
434: } else {
435: /* write to virtual memory */
436: DEBUG_CHECK_VMEM_WRITE(addr, val);
437: out32le((void *) (M.mem_base + addr), val);
438: }
439: }
440:
441: //update time in BIOS Data Area
442: //DWord at offset 0x6c is the timer ticks since midnight, timer is running at 18Hz
443: //byte at 0x70 is timer overflow (set if midnight passed since last call to interrupt 1a function 00
444: //cur_val is the current value, of offset 6c...
445: void
446: update_time(uint32_t cur_val)
447: {
448: //for convenience, we let the start of timebase be at midnight, we currently dont support
449: //real daytime anyway...
450: uint64_t ticks_per_day = tb_freq * 60 * 24;
451: // at 18Hz a period is ~55ms, converted to ticks (tb_freq is ticks/second)
452: uint32_t period_ticks = (55 * tb_freq) / 1000;
453: uint64_t curr_time = get_time();
454: uint64_t ticks_since_midnight = curr_time % ticks_per_day;
455: uint32_t periods_since_midnight = ticks_since_midnight / period_ticks;
456: // if periods since midnight is smaller than last value, set overflow
457: // at BDA Offset 0x70
458: if (periods_since_midnight < cur_val) {
459: my_wrb(0x470, 1);
460: }
461: // store periods since midnight at BDA offset 0x6c
462: my_wrl(0x46c, periods_since_midnight);
463: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.