OpenCores
URL https://opencores.org/ocsvn/ao486/ao486/trunk

Subversion Repositories ao486

[/] [ao486/] [trunk/] [bochsDevs/] [main.cpp] - Blame information for rev 4

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 alfik
 
2
#include <cstdio>
3
#include <cstdlib>
4
 
5
#include <dlfcn.h>
6
 
7
#include <sys/mman.h>
8
#include <sys/types.h>
9
#include <sys/stat.h>
10
#include <fcntl.h>
11
#include <unistd.h>
12
 
13
#include "shared_mem.h"
14
 
15
#include "bochs.h"
16
#include "plugin.h"
17
#include "extplugin.h"
18
#include "iodev/iodev.h"
19
#include "iodev/virt_timer.h"
20
 
21
//------------------------------------------------------------------------------
22
//------------------------------------------------------------------------------
23
//------------------------------------------------------------------------------
24
 
25
volatile shared_mem_t *shared_ptr = NULL;
26
 
27
//------------------------------------------------------------------------------
28
//------------------------------------------------------------------------------
29
//------------------------------------------------------------------------------
30
 
31
ioWriteHandler_t io_write_handlers[65537];
32
void *           io_write_this    [65537];
33
uint8            io_write_mask    [65537];
34
ioReadHandler_t  io_read_handlers [65537];
35
void *           io_read_this     [65537];
36
uint8            io_read_mask     [65537];
37
 
38
void  (*pluginRegisterIRQ)(unsigned irq, const char* name) = 0;
39
 
40
int (*pluginRegisterIOReadHandler)(void *thisPtr, ioReadHandler_t callback,
41
                            unsigned base, const char *name, Bit8u mask) = 0;
42
int (*pluginRegisterIOWriteHandler)(void *thisPtr, ioWriteHandler_t callback,
43
                             unsigned base, const char *name, Bit8u mask) = 0;
44
int (*pluginRegisterDefaultIOReadHandler)(void *thisPtr, ioReadHandler_t callback,
45
                            const char *name, Bit8u mask) = 0;
46
int (*pluginRegisterDefaultIOWriteHandler)(void *thisPtr, ioWriteHandler_t callback,
47
                             const char *name, Bit8u mask) = 0;
48
 
49
static void
50
builtinRegisterIRQ(unsigned irq, const char* name)
51
{
52
//bx_devices.register_irq(irq, name);
53
printf("builtinRegisterIRQ(%d, %s)\n", irq, name);
54
}
55
 
56
static int
57
builtinRegisterIOReadHandler(void *thisPtr, ioReadHandler_t callback,
58
                            unsigned base, const char *name, Bit8u mask)
59
{
60
//  int ret;
61
//  BX_ASSERT(mask<8);
62
//  ret = bx_devices.register_io_read_handler (thisPtr, callback, base, name, mask);
63
//  pluginlog->ldebug("plugin %s registered I/O read  address at %04x", name, base);
64
//  return ret;
65
 
66
printf("builtinRegisterIOReadHandler: %s %04x %d\n", name, base, mask);
67
    io_read_handlers[base] = callback;
68
    io_read_mask[base]     = mask;
69
    io_read_this[base]     = thisPtr;
70
 
71
    return 1;
72
}
73
 
74
static int
75
builtinRegisterIOWriteHandler(void *thisPtr, ioWriteHandler_t callback,
76
                             unsigned base, const char *name, Bit8u mask)
77
{
78
//  int ret;
79
//  BX_ASSERT(mask<8);
80
//  ret = bx_devices.register_io_write_handler (thisPtr, callback, base, name, mask);
81
//  pluginlog->ldebug("plugin %s registered I/O write address at %04x", name, base);
82
//  return ret;
83
 
84
printf("builtinRegisterIOWriteHandler: %s %04x %d\n", name, base, mask);
85
    io_write_handlers[base] = callback;
86
    io_write_mask[base]     = mask;
87
    io_write_this[base]     = thisPtr;
88
 
89
    return 1;
90
}
91
 
92
static int
93
builtinRegisterDefaultIOReadHandler(void *thisPtr, ioReadHandler_t callback,
94
                            const char *name, Bit8u mask)
95
{
96
//  BX_ASSERT(mask<8);
97
//  bx_devices.register_default_io_read_handler (thisPtr, callback, name, mask);
98
//  pluginlog->ldebug("plugin %s registered default I/O read ", name);
99
printf("builtinRegisterDefaultIOReadHandler: %s %x\n", name, mask);
100
    io_read_handlers[65536] = callback;
101
    io_read_mask[65536]     = mask;
102
    io_read_this[65536]     = thisPtr;
103
 
104
    return 1;
105
}
106
 
107
static int
108
builtinRegisterDefaultIOWriteHandler(void *thisPtr, ioWriteHandler_t callback,
109
                             const char *name, Bit8u mask)
110
{
111
//  BX_ASSERT(mask<8);
112
//  bx_devices.register_default_io_write_handler (thisPtr, callback, name, mask);
113
//  pluginlog->ldebug("plugin %s registered default I/O write ", name);
114
printf("builtinRegisterDefaultIOWriteHandler: %s %x\n", name, mask);
115
    io_write_handlers[65536] = callback;
116
    io_write_mask[65536]     = mask;
117
    io_write_this[65536]     = thisPtr;
118
 
119
    return 1;
120
}
121
 
122
void pluginRegisterDeviceDevmodel(plugin_t *plugin, plugintype_t type, bx_devmodel_c *devmodel, const char *name) {
123
printf("pluginRegisterDeviceDevmodel() for %s\n", name);
124
 
125
devmodel->init();
126
}
127
 
128
//------------------------------------------------------------------------------
129
//------------------------------------------------------------------------------
130
//------------------------------------------------------------------------------ SIM
131
 
132
const char *enum_choices[] = { "0_choice", "1_choice", NULL };
133
 
134
#define BOCHS_DEVS_IPS 480000
135
 
136
BxEvent *callback(void *theclass, BxEvent *event) {
137
printf("bochsDevs::callback()\n");
138
    return event;
139
}
140
 
141
bxevent_handler bxevent_callback      = callback;
142
void *          bxevent_callback_data = NULL;
143
 
144
class bochsDevs_sim : public bx_simulator_interface_c {
145
 
146
    bx_param_bool_c *get_param_bool(const char *pname, bx_param_c *base) {
147
printf("bochsDevs_sim::get_param_bool(%s, base=%s)\n", pname, (base==NULL)? "(nil)" : (base->get_name() == NULL)? "(nill name)" : base->get_name());
148
 
149
        if(base != NULL) {
150
            bx_param_c *param = ((bx_list_c *)base)->get_by_name(pname);
151
            return (bx_param_bool_c *)param;
152
        }
153
 
154
        if(strcmp(pname, BXPN_PORT_E9_HACK) == 0)           return new bx_param_bool_c(NULL, "port_e9_hack", "", "", 0);
155
        if(strcmp(pname, BXPN_CMOSIMAGE_ENABLED) == 0)      return new bx_param_bool_c(NULL, "enabled",      "", "", 0);
156
 
157
        if(strcmp(pname, BXPN_FLOPPYSIGCHECK) == 0)         return new bx_param_bool_c(NULL, "floppy_sig_check", "", "", 0);
158
        if(strcmp(pname, BXPN_PCI_ENABLED) == 0)            return new bx_param_bool_c(NULL, "enabled",          "", "", 0);
159
 
160
        if(strcmp(pname, BXPN_PRIVATE_COLORMAP) == 0)       return new bx_param_bool_c(NULL, "private_colormap", "", "", 0);
161
 
162
        if(strcmp(pname, BXPN_KBD_USEMAPPING) == 0)         return new bx_param_bool_c(NULL, "use_mapping", "", "", 0);
163
 
164
        if(strcmp(pname, BXPN_MOUSE_ENABLED) == 0)          return new bx_param_bool_c(NULL, "enabled", "", "", 0);
165
 
166
        return NULL;
167
    }
168
    bx_param_string_c *get_param_string(const char *pname, bx_param_c *base) {
169
printf("bochsDevs_sim::get_param_string(%s, base=%s)\n", pname, (base==NULL)? "(nil)" : (base->get_name() == NULL)? "(nill name)" : base->get_name());
170
 
171
        if(base != NULL) {
172
            bx_param_c *param = ((bx_list_c *)base)->get_by_name(pname);
173
            return (bx_param_string_c *)param;
174
        }
175
 
176
        if(strcmp(pname, BXPN_VGA_EXTENSION) == 0)          return new bx_param_string_c(NULL, "vga_extension",      "", "", "none");
177
        if(strcmp(pname, BXPN_DISPLAYLIB_OPTIONS) == 0)     return new bx_param_string_c(NULL, "displaylib_options", "", "", "");
178
 
179
        if(strcmp(pname, BXPN_VGA_ROM_PATH) == 0)     return new bx_param_string_c(NULL, "path", "", "", "");
180
 
181
        return NULL;
182
    }
183
    bx_param_enum_c *get_param_enum(const char *pname, bx_param_c *base) {
184
printf("bochsDevs_sim::get_param_enum(%s, base=%s)\n", pname, (base==NULL)? "(nil)" : (base->get_name() == NULL)? "(nill name)" : base->get_name());
185
 
186
        if(base != NULL) {
187
            bx_param_c *param = ((bx_list_c *)base)->get_by_name(pname);
188
            return (bx_param_enum_c *)param;
189
        }
190
 
191
        if(strcmp(pname, BXPN_CLOCK_SYNC) == 0)       return new bx_param_enum_c(NULL, "clock_sync", "", "", enum_choices, 0);
192
 
193
        if(strcmp(pname, BXPN_FLOPPYA_DEVTYPE) == 0)  return new bx_param_enum_c(NULL, "devtype", "", "", enum_choices, 0);
194
        if(strcmp(pname, BXPN_FLOPPYA_TYPE) == 0)     return new bx_param_enum_c(NULL, "type",    "", "", enum_choices, 0);
195
        if(strcmp(pname, BXPN_FLOPPYA_STATUS) == 0)   return new bx_param_enum_c(NULL, "status",  "", "", enum_choices, 0);
196
 
197
        if(strcmp(pname, BXPN_FLOPPYB_DEVTYPE) == 0)  return new bx_param_enum_c(NULL, "devtype", "", "", enum_choices, 0);
198
        if(strcmp(pname, BXPN_FLOPPYB_TYPE) == 0)     return new bx_param_enum_c(NULL, "type",    "", "", enum_choices, 0);
199
        if(strcmp(pname, BXPN_FLOPPYB_STATUS) == 0)   return new bx_param_enum_c(NULL, "status",  "", "", enum_choices, 0);
200
 
201
        if(strcmp(pname, BXPN_BOOTDRIVE1) == 0)       return new bx_param_enum_c(NULL, "boot_drive1", "", "", enum_choices, BX_BOOT_FLOPPYA);
202
        if(strcmp(pname, BXPN_BOOTDRIVE2) == 0)       return new bx_param_enum_c(NULL, "boot_drive2", "", "", enum_choices, BX_BOOT_FLOPPYA);
203
        if(strcmp(pname, BXPN_BOOTDRIVE3) == 0)       return new bx_param_enum_c(NULL, "boot_drive3", "", "", enum_choices, BX_BOOT_FLOPPYA);
204
 
205
        if(strcmp(pname, BXPN_MOUSE_TYPE) == 0)       return new bx_param_enum_c(NULL, "type", "", "", enum_choices, BX_MOUSE_TYPE_PS2);
206
 
207
        if(strcmp(pname, BXPN_MOUSE_TOGGLE) == 0)      return new bx_param_enum_c(NULL, "toggle", "", "", enum_choices, BX_MOUSE_TOGGLE_CTRL_F10);
208
 
209
        if(strcmp(pname, BXPN_KBD_TYPE) == 0)         return new bx_param_enum_c(NULL, "type", "", "", enum_choices, BX_KBD_AT_TYPE);
210
 
211
        return NULL;
212
    }
213
    bx_param_num_c *get_param_num(const char *pname, bx_param_c *base) {
214
printf("bochsDevs_sim::get_param_num(%s, base=%s)\n", pname, (base==NULL)? "(nil)" : (base->get_name() == NULL)? "(nill name)" : base->get_name());
215
 
216
        if(base != NULL) {
217
            bx_param_c *param = ((bx_list_c *)base)->get_by_name(pname);
218
            return (bx_param_num_c *)param;
219
        }
220
 
221
        if(strcmp(pname, BXPN_CLOCK_TIME0) == 0)  return new bx_param_num_c(NULL, "time0",   "", "", 100,100,100);
222
 
223
        if(strcmp(pname, BXPN_KBD_SERIAL_DELAY) == 0) return new bx_param_num_c(NULL, "serial_delay",   "", "", 100,100,100);
224
        if(strcmp(pname, BXPN_KBD_PASTE_DELAY) == 0)  return new bx_param_num_c(NULL, "paste_delay",   "", "", 100,100,100);
225
        if(strcmp(pname, BXPN_MOUSE_ENABLED) == 0)    return new bx_param_num_c(NULL, "enabled",   "", "", 1,1,1);
226
 
227
        if(strcmp(pname, BXPN_VGA_UPDATE_FREQUENCY) == 0)   return new bx_param_num_c(NULL, "vga_update_frequency",   "", "", 500000,500000,500000);
228
 
229
        if(strcmp(pname, BXPN_IPS) == 0)   return new bx_param_num_c(NULL, "ips",   "", "", BOCHS_DEVS_IPS, BOCHS_DEVS_IPS, BOCHS_DEVS_IPS);
230
        return NULL;
231
    }
232
    bx_param_c *get_param(const char *pname, bx_param_c *base=NULL) {
233
        if(strcmp(pname, BXPN_ATA0_RES) == 0) {
234
            bx_list_c *list = new bx_list_c(NULL);
235
            list->add(new bx_param_bool_c(NULL, "enabled", "", "", 1));
236
            list->add(new bx_param_num_c(NULL,  "ioaddr1", "", "", 0x1f0,0x1f0,0x1f0));
237
            list->add(new bx_param_num_c(NULL,  "ioaddr2", "", "", 0x3f0,0x3f0,0x3f0));
238
            list->add(new bx_param_num_c(NULL,  "irq",     "", "", 14,14,14));
239
            return list;
240
        }
241
        if(strcmp(pname, BXPN_ATA1_RES) == 0 || strcmp(pname, BXPN_ATA2_RES) == 0 || strcmp(pname, BXPN_ATA3_RES) == 0) {
242
            bx_list_c *list = new bx_list_c(NULL);
243
            list->add(new bx_param_bool_c(NULL, "enabled", "", "", 0));
244
            return list;
245
        }
246
        if(strcmp(pname, BXPN_FLOPPYA) == 0 || strcmp(pname, BXPN_FLOPPYB) == 0) {
247
            bx_list_c *list = new bx_list_c(NULL);
248
            list->add(new bx_param_enum_c(NULL,   "status",   "", "", enum_choices, 0));
249
            list->add(new bx_param_bool_c(NULL,   "readonly", "", "", 1));
250
            list->add(new bx_param_string_c(NULL, "path",     "", "", "none"));
251
            return list;
252
        }
253
        if(strcmp(pname, BXPN_ATA0_MASTER) == 0) {
254
            bx_list_c *list = new bx_list_c(NULL);
255
            list->add(new bx_param_enum_c(NULL,   "type",        "", "", enum_choices, BX_ATA_DEVICE_DISK));
256
            list->add(new bx_param_string_c(NULL, "model",       "", "", "HDmodel"));
257
            list->add(new bx_param_num_c(NULL,    "cylinders",   "", "", 1024,1024,1024));
258
            list->add(new bx_param_num_c(NULL,    "heads",       "", "", 16,16,16));
259
            list->add(new bx_param_num_c(NULL,    "spt",         "", "", 63,63,63));
260
            list->add(new bx_param_enum_c(NULL,   "mode",        "", "", enum_choices, BX_HDIMAGE_MODE_FLAT));
261
            list->add(new bx_param_string_c(NULL, "path",        "", "", "/home/alek/temp/bochs-run/hd.img"));
262
            list->add(new bx_param_string_c(NULL, "journal",     "", "", ""));
263
            list->add(new bx_param_enum_c(NULL,   "translation", "", "", enum_choices, BX_ATA_TRANSLATION_NONE));
264
            return list;
265
        }
266
        if(strcmp(pname, BXPN_ATA1_MASTER) == 0 || strcmp(pname, BXPN_ATA2_MASTER) == 0 || strcmp(pname, BXPN_ATA3_MASTER) == 0 ||
267
           strcmp(pname, BXPN_ATA0_SLAVE) == 0  || strcmp(pname, BXPN_ATA1_SLAVE) == 0  || strcmp(pname, BXPN_ATA2_SLAVE) == 0  || strcmp(pname, BXPN_ATA3_SLAVE) == 0)
268
        {
269
            bx_list_c *list = new bx_list_c(NULL);
270
            list->add(new bx_param_enum_c(NULL, "type", "", "", enum_choices, BX_ATA_DEVICE_NONE));
271
            return list;
272
        }
273
        return NULL;
274
    }
275
    void set_notify_callback(bxevent_handler func, void *arg) {
276
        bxevent_callback = func;
277
        bxevent_callback_data = arg;
278
    }
279
 
280
    void get_notify_callback(bxevent_handler *func, void **arg) {
281
        *func = bxevent_callback;
282
        *arg = bxevent_callback_data;
283
    }
284
};
285
 
286
bx_simulator_interface_c *SIM;
287
 
288
//------------------------------------------------------------------------------
289
//------------------------------------------------------------------------------
290
//------------------------------------------------------------------------------ logfunctions
291
 
292
void logfunctions::panic(const char *fmt, ...) {
293
    printf("#bochsDevs::logfunctions::panic(): ");
294
 
295
    va_list ap;
296
    va_start(ap, fmt);
297
    vprintf(fmt, ap);
298
    va_end(ap);
299
 
300
    printf("\n");
301
    fflush(stdout);
302
 
303
    if(strstr(fmt, "exception with no resolution") != NULL) {
304
        printf("start_shutdown: 0\n");
305
        printf("\n");
306
        fflush(stdout);
307
        exit(0);
308
    }
309
    else {
310
        exit(-1);
311
    }
312
}
313
void logfunctions::error(const char *fmt, ...) {
314
    printf("#bochsDevs::logfunctions::error(): ");
315
 
316
    va_list ap;
317
    va_start(ap, fmt);
318
    vprintf(fmt, ap);
319
    va_end(ap);
320
 
321
    printf("\n");
322
    fflush(stdout);
323
}
324
void logfunctions::ldebug(const char *fmt, ...) {
325
    printf("#bochsDevs::logfunctions::debug(): ");
326
 
327
    va_list ap;
328
    va_start(ap, fmt);
329
    vprintf(fmt, ap);
330
    va_end(ap);
331
 
332
    printf("\n");
333
    fflush(stdout);
334
}
335
void logfunctions::info(const char *fmt, ...) {
336
    printf("#bochsDevs::logfunctions::info(): ");
337
 
338
    va_list ap;
339
    va_start(ap, fmt);
340
    vprintf(fmt, ap);
341
    va_end(ap);
342
 
343
    printf("\n");
344
    fflush(stdout);
345
}
346
void logfunctions::put(const char *n, const char *p) {
347
}
348
void logfunctions::put(const char *p) {
349
}
350
logfunctions::logfunctions() {
351
}
352
logfunctions::~logfunctions() {
353
}
354
 
355
static logfunctions theLog;
356
logfunctions *pluginlog         = &theLog;
357
logfunctions *siminterface_log  = &theLog;
358
logfunctions *genlog            = &theLog;
359
 
360
//------------------------------------------------------------------------------
361
//------------------------------------------------------------------------------
362
//------------------------------------------------------------------------------ menu
363
 
364
void bx_param_string_c::text_print(FILE *fp) {
365
printf("#bochsDevs::bx_param_string_c::text_print()\n");
366
}
367
void bx_param_enum_c::text_print(FILE *fp) {
368
printf("bochsDevs::bx_param_enum_c::text_print()\n");
369
}
370
void bx_param_bool_c::text_print(FILE *fp) {
371
printf("bochsDevs::bx_param_bool_c::text_print()\n");
372
}
373
void bx_param_num_c::text_print(FILE *fp) {
374
printf("bochsDevs::bx_param_num_c::text_print()\n");
375
}
376
void bx_list_c::text_print(FILE *fp) {
377
printf("bochsDevs::bx_list_c::text_print()\n");
378
}
379
int bx_param_enum_c::text_ask(FILE *fpin, FILE *fpout) {
380
printf("bochsDevs::bx_param_enum_c::text_ask()\n");
381
    return 0;
382
}
383
int bx_param_bool_c::text_ask(FILE *fpin, FILE *fpout) {
384
printf("bochsDevs::bx_param_bool_c::text_ask()\n");
385
    return 0;
386
}
387
int bx_param_num_c::text_ask(FILE *fpin, FILE *fpout) {
388
printf("bochsDevs::bx_param_num_c::text_ask()\n");
389
    return 0;
390
}
391
int bx_param_string_c::text_ask(FILE *fpin, FILE *fpout) {
392
printf("bochsDevs::bx_param_string_c::text_ask()\n");
393
    return 0;
394
}
395
int bx_list_c::text_ask(FILE *fpin, FILE *fpout) {
396
printf("bochsDevs::bx_list_c::text_ask()\n");
397
    return 0;
398
}
399
 
400
bx_list_c *root_param = NULL;
401
 
402
//------------------------------------------------------------------------------
403
//------------------------------------------------------------------------------
404
//------------------------------------------------------------------------------ memory
405
 
406
memory_handler_t vga_read_memory  = NULL;
407
memory_handler_t vga_write_memory = NULL;
408
void *           vga_param        = NULL;
409
 
410
BX_MEM_C::BX_MEM_C() {
411
}
412
BX_MEM_C::~BX_MEM_C() {
413
}
414
 
415
void BX_MEM_C::dmaReadPhysicalPage(bx_phy_address addr, unsigned len, Bit8u *data)  {
416
printf("bochsDevs::BX_MEM_C::dmaReadPhysicalPage()\n");
417
 
418
    memcpy(data, (void *)(shared_ptr->mem.bytes + addr), len);
419
}
420
 
421
void BX_MEM_C::dmaWritePhysicalPage(bx_phy_address addr, unsigned len, Bit8u *data) {
422
printf("bochsDevs::BX_MEM_C::dmaWritePhysicalPage()\n");
423
 
424
    memcpy((void *)(shared_ptr->mem.bytes + addr), data, len);
425
}
426
 
427
bx_bool
428
BX_MEM_C::registerMemoryHandlers(void *param, memory_handler_t read_handler,
429
                memory_handler_t write_handler, memory_direct_access_handler_t da_handler,
430
                bx_phy_address begin_addr, bx_phy_address end_addr)
431
{
432
printf("bochsDevs::BX_MEM_C::registerMemoryHandlers(): %llx %llx\n", begin_addr, end_addr);
433
    if(da_handler != NULL) {
434
        printf("bochsDevs::da_handler != NULL\n");
435
        exit(-1);
436
    }
437
    if(begin_addr != 0xA0000 || end_addr != 0xBFFFF) {
438
        printf("bochsDevs::invalid address\n");
439
        exit(-1);
440
    }
441
 
442
    vga_read_memory = read_handler;
443
    vga_write_memory= write_handler;
444
    vga_param       = param;
445
 
446
return 1;
447
}
448
 
449
void BX_MEM_C::load_ROM(const char *path, bx_phy_address romaddress, Bit8u type) {
450
printf("bochsDevs::BX_MEM_C::load_ROM()\n");
451
}
452
 
453
BX_MEM_C bx_mem;
454
 
455
 
456
//------------------------------------------------------------------------------
457
//------------------------------------------------------------------------------
458
//------------------------------------------------------------------------------
459
 
460
bx_bool bx_dbg_register_debug_info(const char *devname, void *dev) {
461
printf("bochsDevs::bx_dbg_register_debug_info() %s\n", devname);
462
return true;
463
}
464
 
465
void dbg_printf(const char *fmt, ...) {
466
printf("bochsDevs::dbg_printf(%s)\n", fmt);
467
}
468
 
469
void bx_dbg_dma_report(bx_phy_address addr, unsigned len, unsigned what, Bit32u val) {
470
printf("bochsDevs::bx_dbg_dma_report()\n");
471
}
472
 
473
void bx_dbg_iac_report(unsigned vector, unsigned irq) {
474
printf("bochsDevs::bx_dbg_iac_report()\n");
475
}
476
 
477
void bx_debug_break() {
478
printf("bochsDevs::bx_debug_break()\n");
479
}
480
 
481
bx_guard_t bx_guard;
482
 
483
//------------------------------------------------------------------------------
484
//------------------------------------------------------------------------------
485
//------------------------------------------------------------------------------
486
 
487
#define MinAllowableTimerPeriod 1
488
 
489
const Bit64u bx_pc_system_c::NullTimerInterval = 0xffffffff;
490
 
491
bx_pc_system_c::bx_pc_system_c() {
492
  this->put("pc_system", "SYS");
493
 
494
  BX_ASSERT(numTimers == 0);
495
 
496
  // Timer[0] is the null timer.  It is initialized as a special
497
  // case here.  It should never be turned off or modified, and its
498
  // duration should always remain the same.
499
  ticksTotal = 0; // Reset ticks since emulator started.
500
  timer[0].inUse      = 1;
501
  timer[0].period     = NullTimerInterval;
502
  timer[0].active     = 1;
503
  timer[0].continuous = 1;
504
  timer[0].funct      = nullTimer;
505
  timer[0].this_ptr   = this;
506
  numTimers = 1; // So far, only the nullTimer.
507
 
508
  //initialize()
509
  ticksTotal = 0;
510
  timer[0].timeToFire = NullTimerInterval;
511
  currCountdown       = NullTimerInterval;
512
  currCountdownPeriod = NullTimerInterval;
513
  lastTimeUsec = 0;
514
  usecSinceLast = 0;
515
  triggeredTimer = 0;
516
  HRQ = 0;
517
  kill_bochs_request = 0;
518
 
519
  // parameter 'ips' is the processor speed in Instructions-Per-Second
520
  m_ips = BOCHS_DEVS_IPS / 1000000.0L;
521
}
522
 
523
void bx_pc_system_c::nullTimer(void* this_ptr) {
524
}
525
 
526
int bx_pc_system_c::register_timer_ticks(void* this_ptr, bx_timer_handler_t funct,
527
    Bit64u ticks, bx_bool continuous, bx_bool active, const char *id)
528
{
529
  unsigned i;
530
 
531
  // If the timer frequency is rediculously low, make it more sane.
532
  // This happens when 'ips' is too low.
533
  if (ticks < MinAllowableTimerPeriod) {
534
    //BX_INFO(("register_timer_ticks: adjusting ticks of %llu to min of %u",
535
    //          ticks, MinAllowableTimerPeriod));
536
    ticks = MinAllowableTimerPeriod;
537
  }
538
 
539
  // search for new timer for i=1, i=0 is reserved for NullTimer
540
  for (i=1; i < numTimers; i++) {
541
    if (timer[i].inUse == 0)
542
      break;
543
  }
544
 
545
  timer[i].inUse      = 1;
546
  timer[i].period     = ticks;
547
  timer[i].timeToFire = (ticksTotal + Bit64u(currCountdownPeriod-currCountdown)) + ticks;
548
  timer[i].active     = active;
549
  timer[i].continuous = continuous;
550
  timer[i].funct      = funct;
551
  timer[i].this_ptr   = this_ptr;
552
  strncpy(timer[i].id, id, BxMaxTimerIDLen);
553
  timer[i].id[BxMaxTimerIDLen-1] = 0; // Null terminate if not already.
554
 
555
  if (active) {
556
    if (ticks < Bit64u(currCountdown)) {
557
      // This new timer needs to fire before the current countdown.
558
      // Skew the current countdown and countdown period to be smaller
559
      // by the delta.
560
      currCountdownPeriod -= (currCountdown - Bit32u(ticks));
561
      currCountdown = Bit32u(ticks);
562
    }
563
  }
564
 
565
printf("bochsDevs::timer id %d registered for '%s'", i, id);
566
  // If we didn't find a free slot, increment the bound, numTimers.
567
  if (i==numTimers)
568
    numTimers++; // One new timer installed.
569
 
570
  // Return timer id.
571
  return(i);
572
}
573
 
574
int bx_pc_system_c::register_timer(void *this_ptr, void (*funct)(void *),
575
  Bit32u useconds, bx_bool continuous, bx_bool active, const char *id)
576
{
577
printf("bochsDevs::bx_pc_system_c::register_timer()\n");
578
 
579
    // Convert useconds to number of ticks.
580
  Bit64u ticks = (Bit64u) (double(useconds) * m_ips);
581
 
582
  return register_timer_ticks(this_ptr, funct, ticks, continuous, active, id);
583
}
584
 
585
void bx_pc_system_c::activate_timer_ticks(unsigned i, Bit64u ticks, bx_bool continuous)
586
{
587
  // If the timer frequency is rediculously low, make it more sane.
588
  // This happens when 'ips' is too low.
589
  if (ticks < MinAllowableTimerPeriod) {
590
    //BX_INFO(("activate_timer_ticks: adjusting ticks of %llu to min of %u",
591
    //          ticks, MinAllowableTimerPeriod));
592
    ticks = MinAllowableTimerPeriod;
593
  }
594
 
595
  timer[i].period = ticks;
596
  timer[i].timeToFire = (ticksTotal + Bit64u(currCountdownPeriod-currCountdown)) + ticks;
597
  timer[i].active     = 1;
598
  timer[i].continuous = continuous;
599
 
600
  if (ticks < Bit64u(currCountdown)) {
601
    // This new timer needs to fire before the current countdown.
602
    // Skew the current countdown and countdown period to be smaller
603
    // by the delta.
604
    currCountdownPeriod -= (currCountdown - Bit32u(ticks));
605
    currCountdown = Bit32u(ticks);
606
  }
607
}
608
 
609
void bx_pc_system_c::activate_timer(unsigned i, Bit32u useconds, bx_bool continuous)
610
{
611
//printf("bochsDevs::bx_pc_system_c::activate_timer(%d, %d, %d)\n", i, useconds, continuous);
612
 
613
  Bit64u ticks;
614
 
615
  // if useconds = 0, use default stored in period field
616
  // else set new period from useconds
617
  if (useconds==0) {
618
    ticks = timer[i].period;
619
  }
620
  else {
621
    // convert useconds to number of ticks
622
    ticks = (Bit64u) (double(useconds) * m_ips);
623
 
624
    // If the timer frequency is rediculously low, make it more sane.
625
    // This happens when 'ips' is too low.
626
    if (ticks < MinAllowableTimerPeriod) {
627
      //BX_INFO(("activate_timer: adjusting ticks of %llu to min of %u",
628
      //          ticks, MinAllowableTimerPeriod));
629
      ticks = MinAllowableTimerPeriod;
630
    }
631
 
632
    timer[i].period = ticks;
633
  }
634
 
635
  activate_timer_ticks(i, ticks, continuous);
636
}
637
 
638
void bx_pc_system_c::deactivate_timer(unsigned i) {
639
//printf("bochsDevs::bx_pc_system_c::deactivate_timer(%d)\n", i);
640
 
641
    timer[i].active = 0;
642
}
643
 
644
Bit64u bx_pc_system_c::time_usec() {
645
  return (Bit64u) (((double)(Bit64s)time_ticks()) / m_ips);
646
}
647
 
648
void bx_pc_system_c::countdownEvent(void) {
649
  unsigned i;
650
  Bit64u   minTimeToFire;
651
  bx_bool  triggered[BX_MAX_TIMERS];
652
 
653
  // Increment global ticks counter by number of ticks which have
654
  // elapsed since the last update.
655
  ticksTotal += Bit64u(currCountdownPeriod);
656
  minTimeToFire = (Bit64u) -1;
657
 
658
  for (i=0; i < numTimers; i++) {
659
    triggered[i] = 0; // Reset triggered flag.
660
    if (timer[i].active) {
661
      if (ticksTotal == timer[i].timeToFire) {
662
        // This timer is ready to fire.
663
        triggered[i] = 1;
664
 
665
        if (timer[i].continuous==0) {
666
          // If triggered timer is one-shot, deactive.
667
          timer[i].active = 0;
668
        }
669
        else {
670
          // Continuous timer, increment time-to-fire by period.
671
          timer[i].timeToFire += timer[i].period;
672
          if (timer[i].timeToFire < minTimeToFire)
673
            minTimeToFire = timer[i].timeToFire;
674
        }
675
      }
676
      else {
677
        // This timer is not ready to fire yet.
678
        if (timer[i].timeToFire < minTimeToFire)
679
          minTimeToFire = timer[i].timeToFire;
680
      }
681
    }
682
  }
683
 
684
  // Calculate next countdown period.  We need to do this before calling
685
  // any of the callbacks, as they may call timer features, which need
686
  // to be advanced to the next countdown cycle.
687
  currCountdown = currCountdownPeriod =
688
      Bit32u(minTimeToFire - ticksTotal);
689
 
690
  for (i=0; i < numTimers; i++) {
691
    // Call requested timer function.  It may request a different
692
    // timer period or deactivate etc.
693
    if (triggered[i]) {
694
      triggeredTimer = i;
695
      timer[i].funct(timer[i].this_ptr);
696
      triggeredTimer = 0;
697
    }
698
  }
699
}
700
 
701
//------------------------------------------------------------------------------
702
 
703
bool a20_state = true;
704
 
705
void bx_pc_system_c::set_HRQ(bx_bool val) {
706
printf("bochsDevs::bx_pc_system_c::set_HRQ() %d\n", val);
707
 
708
    if(val) {
709
        bx_devices.pluginDmaDevice->raise_HLDA();
710
    }
711
}
712
 
713
int bx_pc_system_c::Reset(unsigned type) {
714
printf("bochsDevs::bx_pc_system_c::Reset() %d\n", type);
715
std::exit(-1);
716
    return 0;
717
}
718
 
719
bx_bool bx_pc_system_c::get_enable_a20(void) {
720
printf("bochsDevs::bx_pc_system_c::get_enable_a20() %d\n", a20_state);
721
  return a20_state;
722
}
723
 
724
void bx_pc_system_c::set_enable_a20(bx_bool value) {
725
printf("bochsDevs::bx_pc_system_c::set_enable_a20(%d) %d\n", value, a20_state);
726
    a20_state = value;
727
}
728
 
729
void bx_pc_system_c::clear_INTR(void) {
730
printf("bochsDevs::bx_pc_system_c::clear_INTR()\n");
731
    shared_ptr->interrupt_at_counter = 0;
732
}
733
 
734
void bx_pc_system_c::raise_INTR(void) {
735
printf("bochsDevs::bx_pc_system_c::raise_INTR()\n");
736
 
737
    uint32 last = shared_ptr->interrupt_at_counter;
738
 
739
    shared_ptr->interrupt_vector = bx_devices.pluginPicDevice->IAC();
740
 
741
    uint32 v1 = shared_ptr->bochs486_pc.instr_counter + 5;
742
    uint32 v2 = shared_ptr->ao486.instr_counter + 5;
743
 
744
    shared_ptr->interrupt_at_counter = (v1 > v2)? v1 : v2;
745
 
746
printf("interrupt: %02x\n", shared_ptr->interrupt_vector);
747
 
748
    FILE *interrupt_fp = fopen("interrupt.txt", "a");
749
    fprintf(interrupt_fp, "irq %02x at %d (%d %d) %d\n", shared_ptr->interrupt_vector, shared_ptr->interrupt_at_counter, v1, v2, shared_ptr->interrupt_at_counter - last);
750
    fclose(interrupt_fp);
751
}
752
 
753
class capture_pic_stub_c : public bx_pic_stub_c {
754
public:
755
    capture_pic_stub_c(bx_pic_stub_c *orig) {
756
        this->orig = orig;
757
    }
758
 
759
    virtual void raise_irq(unsigned irq_no) {
760
        FILE *fp = fopen("track.txt", "a");
761
        fprintf(fp, "raise_irq %d\n", irq_no);
762
        fclose(fp);
763
 
764
        orig->raise_irq(irq_no);
765
    }
766
 
767
    virtual void lower_irq(unsigned irq_no) {
768
        FILE *fp = fopen("track.txt", "a");
769
        fprintf(fp, "lower_irq %d\n", irq_no);
770
        fclose(fp);
771
 
772
        orig->lower_irq(irq_no);
773
    }
774
 
775
    virtual void set_mode(bx_bool ma_sl, Bit8u mode) {
776
        FILE *fp = fopen("track.txt", "a");
777
        fprintf(fp, "set_mode %d %d\n", ma_sl, mode);
778
        fclose(fp);
779
 
780
        orig->set_mode(ma_sl, mode);
781
    }
782
 
783
    virtual Bit8u IAC(void) {
784
        Bit8u ret = orig->IAC();
785
 
786
        FILE *fp = fopen("track.txt", "a");
787
        fprintf(fp, "IAC %d\n", ret);
788
        fclose(fp);
789
 
790
        return ret;
791
    }
792
 
793
private:
794
    bx_pic_stub_c *orig;
795
};
796
 
797
bx_pc_system_c bx_pc_system;
798
 
799
//------------------------------------------------------------------------------
800
//------------------------------------------------------------------------------
801
//------------------------------------------------------------------------------
802
 
803
Bit64u bx_get_realtime64_usec(void)
804
{
805
  timeval thetime;
806
  gettimeofday(&thetime,0);
807
  Bit64u mytime;
808
  mytime=(Bit64u)thetime.tv_sec*(Bit64u)1000000+(Bit64u)thetime.tv_usec;
809
  return mytime;
810
}
811
 
812
//------------------------------------------------------------------------------
813
//------------------------------------------------------------------------------
814
//------------------------------------------------------------------------------
815
 
816
bx_devices_c::bx_devices_c() {
817
}
818
bx_devices_c::~bx_devices_c() {
819
}
820
 
821
void bx_devices_c::mouse_motion(int delta_x, int delta_y, int delta_z, unsigned button_state, bx_bool absxy) {
822
printf("bochsDevs::bx_devices_c::mouse_motion()\n");
823
  // If mouse events are disabled on the GUI headerbar, don't
824
  // generate any mouse data
825
  if (!mouse_captured)
826
    return;
827
 
828
  // if a removable mouse is connected, redirect mouse data to the device
829
  if (bx_mouse[1].dev != NULL) {
830
    bx_mouse[1].enq_event(bx_mouse[1].dev, delta_x, delta_y, delta_z, button_state, absxy);
831
    return;
832
  }
833
 
834
  // if a mouse is connected, direct mouse data to the device
835
  if (bx_mouse[0].dev != NULL) {
836
    bx_mouse[0].enq_event(bx_mouse[0].dev, delta_x, delta_y, delta_z, button_state, absxy);
837
  }
838
}
839
 
840
bx_bool bx_devices_c::optional_key_enq(Bit8u *scan_code) {
841
printf("bochsDevs::bx_devices_c::optional_key_enq()\n");
842
  if (bx_keyboard.dev != NULL) {
843
    return bx_keyboard.enq_event(bx_keyboard.dev, scan_code);
844
  }
845
  return 0;
846
}
847
 
848
void bx_devices_c::mouse_enabled_changed(bx_bool enabled) {
849
printf("bochsDevs::bx_devices_c::mouse_enabled_changed()\n");
850
  mouse_captured = enabled;
851
 
852
  if ((bx_mouse[1].dev != NULL) && (bx_mouse[1].enabled_changed != NULL)) {
853
    bx_mouse[1].enabled_changed(bx_mouse[1].dev, enabled);
854
    return;
855
  }
856
 
857
  if ((bx_mouse[0].dev != NULL) && (bx_mouse[0].enabled_changed != NULL)) {
858
    bx_mouse[0].enabled_changed(bx_mouse[0].dev, enabled);
859
  }
860
}
861
 
862
void bx_devices_c::register_default_mouse(void *dev, bx_mouse_enq_t mouse_enq,
863
                                          bx_mouse_enabled_changed_t mouse_enabled_changed)
864
{
865
printf("bochsDevs::bx_devices_c::register_default_mouse()\n");
866
  if (bx_mouse[0].dev == NULL) {
867
    bx_mouse[0].dev = dev;
868
    bx_mouse[0].enq_event = mouse_enq;
869
    bx_mouse[0].enabled_changed = mouse_enabled_changed;
870
  }
871
}
872
 
873
bx_devices_c bx_devices;
874
 
875
//------------------------------------------------------------------------------
876
//------------------------------------------------------------------------------
877
//------------------------------------------------------------------------------
878
 
879
const char *hdimage_mode_names[] = {
880
  "flat",
881
  "concat",
882
  "external",
883
  "dll",
884
  "sparse",
885
  "vmware3",
886
  "vmware4",
887
  "undoable",
888
  "growing",
889
  "volatile",
890
  "vvfat",
891
  "vpc",
892
  NULL
893
};
894
 
895
void bx_stop_simulation() {
896
printf("bochsDevs::bx_stop_simulation()\n");
897
}
898
 
899
class BX_CPU_C : public logfunctions {
900
};
901
 
902
BX_CPU_C bx_cpu;
903
 
904
bx_bool bx_user_quit;
905
 
906
//------------------------------------------------------------------------------
907
//------------------------------------------------------------------------------
908
//------------------------------------------------------------------------------
909
 
910
void register_plugin(const char *libname, const char *initname) {
911
 
912
    void *handle;
913
 
914
    handle = dlopen(libname, RTLD_NOW | RTLD_GLOBAL);
915
 
916
    if(handle == NULL) {
917
        char *error = dlerror();
918
 
919
        printf("dlopen() error: %s\n", error);
920
        exit(-1);
921
    }
922
 
923
 
924
    plugin_init_t plugin_init = (plugin_init_t)dlsym(handle, initname);
925
    if(plugin_init == NULL) {
926
        char *error = dlerror();
927
 
928
        printf("dlsym() error: %s\n", error);
929
 
930
        dlclose(handle);
931
        exit(-2);
932
    }
933
 
934
    plugin_init(NULL, PLUGTYPE_CORE, 0,NULL);
935
 
936
    //dlclose(handle);
937
}
938
 
939
int main(int argc, char **argv) {
940
 
941
    //map shared memory
942
    int fd = open("./../sim/sim_pc/shared_mem.dat", O_RDWR, S_IRUSR | S_IWUSR);
943
 
944
    if(fd == -1) {
945
        perror("open() failed for shared_mem.dat");
946
        return -1;
947
    }
948
 
949
    shared_ptr = (shared_mem_t *)mmap(NULL, sizeof(shared_mem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
950
 
951
    if(shared_ptr == MAP_FAILED) {
952
        perror("mmap() failed");
953
        close(fd);
954
        return -2;
955
    }
956
 
957
    //wait for ack
958
 
959
    shared_ptr->bochsDevs_starting = STEP_REQ;
960
    printf("Waiting for startup ack...");
961
    fflush(stdout);
962
    while(shared_ptr->bochsDevs_starting != STEP_ACK) {
963
        usleep(100000);
964
    }
965
    printf("done.\n");
966
 
967
    //--------------------------------------------------------------------------
968
 
969
    printf("bochsDevs\n");
970
 
971
    FILE *debug_fp = fopen("output.txt", "w");
972
 
973
    pluginRegisterIRQ = builtinRegisterIRQ;
974
 
975
    pluginRegisterIOReadHandler = builtinRegisterIOReadHandler;
976
    pluginRegisterIOWriteHandler = builtinRegisterIOWriteHandler;
977
 
978
    pluginRegisterDefaultIOReadHandler = builtinRegisterDefaultIOReadHandler;
979
    pluginRegisterDefaultIOWriteHandler = builtinRegisterDefaultIOWriteHandler;
980
 
981
 
982
    SIM = new bochsDevs_sim();
983
 
984
    bx_virt_timer.init();
985
 
986
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_unmapped.so.0.0.0",   "libunmapped_LTX_plugin_init");
987
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_biosdev.so.0.0.0",    "libbiosdev_LTX_plugin_init");
988
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_cmos.so.0.0.0",       "libcmos_LTX_plugin_init");
989
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_dma.so.0.0.0",        "libdma_LTX_plugin_init");
990
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_x.so.0.0.0",          "libx_LTX_plugin_init");
991
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_floppy.so.0.0.0",     "libfloppy_LTX_plugin_init");
992
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_hdimage.so.0.0.0",    "libhdimage_LTX_plugin_init");
993
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_harddrv.so.0.0.0",    "libharddrv_LTX_plugin_init");
994
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_iodebug.so.0.0.0",    "libiodebug_LTX_plugin_init");
995
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_keyboard.so.0.0.0",   "libkeyboard_LTX_plugin_init");
996
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_pic.so.0.0.0",        "libpic_LTX_plugin_init");
997
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_pit.so.0.0.0",        "libpit_LTX_plugin_init");
998
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_speaker.so.0.0.0",    "libspeaker_LTX_plugin_init");
999
    register_plugin("/opt/bochs-2.6.2/lib/bochs/plugins/libbx_vga.so.0.0.0",        "libvga_LTX_plugin_init");
1000
 
1001
    // misc. CMOS
1002
    Bit64u memory_in_bytes = sizeof(shared_ptr->mem.bytes);
1003
    Bit64u BASE_MEMORY_IN_K = 640;
1004
 
1005
    Bit64u memory_in_k = memory_in_bytes / 1024;
1006
    Bit64u extended_memory_in_k = memory_in_k > 1024 ? (memory_in_k - 1024) : 0;
1007
    if (extended_memory_in_k > 0xfc00) extended_memory_in_k = 0xfc00;
1008
 
1009
    DEV_cmos_set_reg(0x15, (Bit8u) BASE_MEMORY_IN_K);
1010
    DEV_cmos_set_reg(0x16, (Bit8u) (BASE_MEMORY_IN_K >> 8));
1011
    DEV_cmos_set_reg(0x17, (Bit8u) (extended_memory_in_k & 0xff));
1012
    DEV_cmos_set_reg(0x18, (Bit8u) ((extended_memory_in_k >> 8) & 0xff));
1013
    DEV_cmos_set_reg(0x30, (Bit8u) (extended_memory_in_k & 0xff));
1014
    DEV_cmos_set_reg(0x31, (Bit8u) ((extended_memory_in_k >> 8) & 0xff));
1015
 
1016
    Bit64u extended_memory_in_64k = memory_in_k > 16384 ? (memory_in_k - 16384) / 64 : 0;
1017
    // Limit to 3 GB - 16 MB. PCI Memory Address Space starts at 3 GB.
1018
    if (extended_memory_in_64k > 0xbf00) extended_memory_in_64k = 0xbf00;
1019
 
1020
    DEV_cmos_set_reg(0x34, (Bit8u) (extended_memory_in_64k & 0xff));
1021
    DEV_cmos_set_reg(0x35, (Bit8u) ((extended_memory_in_64k >> 8) & 0xff));
1022
 
1023
    Bit64u memory_above_4gb = (memory_in_bytes > BX_CONST64(0x100000000)) ?
1024
                                (memory_in_bytes - BX_CONST64(0x100000000)) : 0;
1025
    if (memory_above_4gb) {
1026
        DEV_cmos_set_reg(0x5b, (Bit8u)(memory_above_4gb >> 16));
1027
        DEV_cmos_set_reg(0x5c, (Bit8u)(memory_above_4gb >> 24));
1028
        DEV_cmos_set_reg(0x5d, memory_above_4gb >> 32);
1029
    }
1030
 
1031
    /* now perform checksum of CMOS memory */
1032
    DEV_cmos_checksum();
1033
 
1034
    //replace pic with capture
1035
    capture_pic_stub_c *capture = new capture_pic_stub_c(bx_devices.pluginPicDevice);
1036
    bx_devices.pluginPicDevice = capture;
1037
 
1038
    uint32 last_instr_counter = 0;
1039
    while(true) {
1040
 
1041
        //---------------------------------------------------------------------- stop
1042
 
1043
        if(shared_ptr->bochsDevs_stop == STEP_REQ) {
1044
            shared_ptr->bochsDevs_stop = STEP_ACK;
1045
            while(shared_ptr->bochsDevs_stop != STEP_IDLE) {
1046
                usleep(500);
1047
            }
1048
        }
1049
 
1050
        //---------------------------------------------------------------------- irq
1051
 
1052
        static step_t last_pit_irq_step = STEP_IDLE;
1053
 
1054
        if(last_pit_irq_step == STEP_IDLE && shared_ptr->pit_irq_step == STEP_REQ) {
1055
            bx_devices.pluginPicDevice->raise_irq(0);
1056
            last_pit_irq_step = STEP_REQ;
1057
        }
1058
        else if(last_pit_irq_step == STEP_REQ && shared_ptr->pit_irq_step == STEP_IDLE) {
1059
            bx_devices.pluginPicDevice->lower_irq(0);
1060
            last_pit_irq_step = STEP_IDLE;
1061
        }
1062
 
1063
        static step_t last_rtc_irq_step = STEP_IDLE;
1064
 
1065
        if(last_rtc_irq_step == STEP_IDLE && shared_ptr->rtc_irq_step == STEP_REQ) {
1066
            bx_devices.pluginPicDevice->raise_irq(8);
1067
            last_rtc_irq_step = STEP_REQ;
1068
        }
1069
        else if(last_rtc_irq_step == STEP_REQ && shared_ptr->rtc_irq_step == STEP_IDLE) {
1070
            bx_devices.pluginPicDevice->lower_irq(8);
1071
            last_rtc_irq_step = STEP_IDLE;
1072
        }
1073
 
1074
        static step_t last_floppy_irq_step = STEP_IDLE;
1075
 
1076
        if(last_floppy_irq_step == STEP_IDLE && shared_ptr->floppy_irq_step == STEP_REQ) {
1077
            bx_devices.pluginPicDevice->raise_irq(6);
1078
            last_floppy_irq_step = STEP_REQ;
1079
        }
1080
        else if(last_floppy_irq_step == STEP_REQ && shared_ptr->floppy_irq_step == STEP_IDLE) {
1081
            bx_devices.pluginPicDevice->lower_irq(6);
1082
            last_floppy_irq_step = STEP_IDLE;
1083
        }
1084
 
1085
        static step_t last_keyboard_irq_step = STEP_IDLE;
1086
 
1087
        if(last_keyboard_irq_step == STEP_IDLE && shared_ptr->keyboard_irq_step == STEP_REQ) {
1088
            bx_devices.pluginPicDevice->raise_irq(1);
1089
            last_keyboard_irq_step = STEP_REQ;
1090
        }
1091
        else if(last_keyboard_irq_step == STEP_REQ && shared_ptr->keyboard_irq_step == STEP_IDLE) {
1092
            bx_devices.pluginPicDevice->lower_irq(1);
1093
            last_keyboard_irq_step = STEP_IDLE;
1094
        }
1095
 
1096
        static step_t last_mouse_irq_step = STEP_IDLE;
1097
 
1098
        if(last_mouse_irq_step == STEP_IDLE && shared_ptr->mouse_irq_step == STEP_REQ) {
1099
            bx_devices.pluginPicDevice->raise_irq(12);
1100
            last_mouse_irq_step = STEP_REQ;
1101
        }
1102
        else if(last_mouse_irq_step == STEP_REQ && shared_ptr->mouse_irq_step == STEP_IDLE) {
1103
            bx_devices.pluginPicDevice->lower_irq(12);
1104
            last_mouse_irq_step = STEP_IDLE;
1105
        }
1106
 
1107
        //---------------------------------------------------------------------- service io
1108
 
1109
        if(shared_ptr->combined.io_step == STEP_REQ) {
1110
 
1111
            uint32 address = shared_ptr->combined.io_address & 0xFFFF;
1112
            uint32 byteena = shared_ptr->combined.io_byteenable;
1113
            uint32 value   = shared_ptr->combined.io_data;
1114
            uint32 shifted = 0;
1115
 
1116
            if(address == 0x01F0 || address == 0x01F4 || (address == 0x03F4 && byteena == 0x4) || address == 0x0040 || (address == 0x0060 && byteena == 0x2) ||
1117
               (address == 0x0070 && (byteena == 0x1 || byteena == 0x02)) || (address == 0x03F4 && ((byteena >> 2) & 1) == 0) || address == 0x03F0 ||
1118
               address == 0x0000 || address == 0x0004 || address == 0x0008 || address == 0x000C ||
1119
               address == 0x0080 || address == 0x0084 || address == 0x0088 || address == 0x008C ||
1120
               address == 0x00C0 || address == 0x00C4 || address == 0x00C8 || address == 0x00CC ||
1121
               address == 0x00D0 || address == 0x00D4 || address == 0x00D8 || address == 0x00DC ||
1122
               address == 0x03B0 || address == 0x03B4 || address == 0x03B8 || address == 0x03BC ||
1123
               address == 0x03C0 || address == 0x03C4 || address == 0x03C8 || address == 0x03CC ||
1124
               address == 0x03D0 || address == 0x03D4 || address == 0x03D8 || address == 0x03DC ||
1125
               (address == 0x0060 && ((byteena >> 1) & 1) == 0) || address == 0x0064 ||
1126
               address == 0x0090 || address == 0x0094 || address == 0x0098 || address == 0x009C ||
1127
               (address == 0x0020 && ((byteena >> 2) & 3) == 0) || (address == 0x00A0 && ((byteena >> 2) & 3) == 0) ||
1128
               address == 0x8888 || address == 0x888C)
1129
            {
1130
                //
1131
            }
1132
            else {
1133
                if(shared_ptr->combined.io_is_write) {
1134
                    FILE *fp = fopen("track.txt", "a");
1135
                    fprintf(fp, "io wr %04x %x %08x\n", address, byteena, value);
1136
                    fclose(fp);
1137
                }
1138
 
1139
                for(uint32 i=0; i<4; i++) {
1140
                    if(byteena & 1) break;
1141
 
1142
                    shifted++;
1143
                    address++;
1144
                    byteena >>= 1;
1145
                    value >>= 8;
1146
                }
1147
                uint32 length = 0;
1148
                for(uint32 i=0; i<4; i++) {
1149
                    if(byteena & 1) length++;
1150
 
1151
                    byteena >>= 1;
1152
                }
1153
 
1154
                if(shared_ptr->combined.io_is_write) {
1155
                    ioWriteHandler_t handler = io_write_handlers[address];
1156
                    uint8 mask = io_write_mask[address];
1157
                    void *this_ptr = io_write_this[address];
1158
 
1159
                    if(handler == NULL) {
1160
                        handler = io_write_handlers[65536];
1161
                        mask = io_write_mask[65536];
1162
                    }
1163
 
1164
                    if(mask & length) {
1165
                        ((bx_write_handler_t)handler)(this_ptr, address, value, length);
1166
                    }
1167
                    else {
1168
                        printf("bochsDevs::io write mismatch: mask=%d, length=%d, address=%04x\n", mask, length, address);
1169
                    }
1170
 
1171
                    if(address == 0x92) {
1172
                        a20_state = (value & 2)? 1 : 0;
1173
                    }
1174
 
1175
                    /*
1176
                    if(address == 0x8888) {
1177
                        fprintf(debug_fp, "%c", value & 0xFF);
1178
                        fflush(debug_fp);
1179
                    }
1180
                    */
1181
                }
1182
                else {
1183
                    ioReadHandler_t handler = io_read_handlers[address];
1184
                    uint8 mask = io_read_mask[address];
1185
                    void *this_ptr = io_read_this[address];
1186
 
1187
                    if(handler == NULL) {
1188
                        handler = io_read_handlers[65536];
1189
                        mask = io_read_mask[65536];
1190
                    }
1191
 
1192
                    uint32 ret = 0xFFFFFF;
1193
 
1194
                    if(mask & length) {
1195
                        ret = ((bx_read_handler_t)handler)(this_ptr, address, length);
1196
                    }
1197
                    else {
1198
                        printf("bochsDevs::io read mismatch: mask=%d, length=%d, address=%04x\n", mask, length, address);
1199
                        ret = (length == 1)? 0xFF : (length == 2)? 0xFFFF : 0xFFFFFFFF;
1200
                    }
1201
 
1202
                    if(address == 0x92) {
1203
                        ret = (a20_state)? 0x02 : 0x00;
1204
                    }
1205
 
1206
                    ret &= (length == 1)? 0xFF : (length == 2)? 0xFFFF : (length == 3)? 0xFFFFFF : 0xFFFFFFFF;
1207
                    shared_ptr->combined.io_data = ret << (8*shifted);
1208
 
1209
                    FILE *fp = fopen("track.txt", "a");
1210
                    fprintf(fp, "io rd %04x %x %08x\n", shared_ptr->combined.io_address & 0xFFFF, shared_ptr->combined.io_byteenable, shared_ptr->combined.io_data);
1211
                    fclose(fp);
1212
                }
1213
                shared_ptr->combined.io_step = STEP_ACK;
1214
            }
1215
        }
1216
 
1217
        //---------------------------------------------------------------------- service vga memory
1218
 
1219
        /*
1220
        if(shared_ptr->combined.mem_step == STEP_REQ) {
1221
            uint32 address = shared_ptr->combined.mem_address;
1222
            uint32 byteena = shared_ptr->combined.mem_byteenable;
1223
            uint32 value   = shared_ptr->combined.mem_data;
1224
            uint32 shifted = 0;
1225
 
1226
            for(uint32 i=0; i<4; i++) {
1227
                if(byteena & 1) break;
1228
 
1229
                shifted++;
1230
                address++;
1231
                byteena >>= 1;
1232
                value >>= 8;
1233
            }
1234
            uint32 length = 0;
1235
            for(uint32 i=0; i<4; i++) {
1236
                if(byteena & 1) length++;
1237
 
1238
                byteena >>= 1;
1239
            }
1240
 
1241
            if(address >= 0xA0000 && address < 0xC0000) {
1242
                if(shared_ptr->combined.mem_is_write) {
1243
                    (vga_write_memory)(address, length, &value, vga_param);
1244
 
1245
                    FILE *fp = fopen("track.txt", "a");
1246
                    fprintf(fp, "vga wr %08x %x %08x\n", address, byteena, value);
1247
                    fclose(fp);
1248
                }
1249
                else {
1250
                    uint32 ret = 0xFFFFFF;
1251
                    (vga_read_memory)(address, length, &ret, vga_param);
1252
 
1253
                    ret &= (length == 1)? 0xFF : (length == 2)? 0xFFFF : (length == 3)? 0xFFFFFF : 0xFFFFFFFF;
1254
                    shared_ptr->combined.mem_data = ret << (8*shifted);
1255
 
1256
                    FILE *fp = fopen("track.txt", "a");
1257
                    fprintf(fp, "vga rd %08x %x %08x\n", shared_ptr->combined.mem_address, shared_ptr->combined.mem_byteenable, shared_ptr->combined.mem_data);
1258
                    fclose(fp);
1259
                }
1260
                shared_ptr->combined.mem_step = STEP_ACK;
1261
            }
1262
        }
1263
        */
1264
 
1265
        //----------------------------------------------------------------------
1266
 
1267
        bx_gui->handle_events();
1268
 
1269
        //bx_pc_system.tickn(1);
1270
        //usleep(100);
1271
        uint32 snapshot = shared_ptr->bochs486_pc.instr_counter;
1272
        if(snapshot > last_instr_counter) {
1273
            bx_pc_system.tickn(snapshot - last_instr_counter); //500 -- hang (too fast interrupt), 100 -- ok
1274
            last_instr_counter = snapshot;
1275
        }
1276
        usleep(10);
1277
    }
1278
 
1279
    return 0;
1280
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.