diff --git a/bochs/PARAM_TREE.txt b/bochs/PARAM_TREE.txt index 5c3ac22be..23f69eaf5 100644 --- a/bochs/PARAM_TREE.txt +++ b/bochs/PARAM_TREE.txt @@ -1,4 +1,4 @@ -$Id: PARAM_TREE.txt,v 1.7 2006-02-22 19:18:28 vruppert Exp $ +$Id: PARAM_TREE.txt,v 1.8 2006-02-26 19:11:20 vruppert Exp $ I'm trying to organize the parameters into a tree structure instead of a huge flat list. Once the parameter code is improved, I hope to use @@ -167,12 +167,12 @@ floppy status BXP_FLOPPYB_STATUS, ata - 0 - menu (for some reason, I had a separate object for menu) - present BXP_ATA0_PRESENT, - ioaddr1 BXP_ATA0_IOADDR1, - ioaddr2 BXP_ATA0_IOADDR2, - irq BXP_ATA0_IRQ, + 0 BXP_ATA0_MENU + resources BXP_ATA0 + enabled BXP_ATA0_PRESENT, + ioaddr1 BXP_ATA0_IOADDR1, + ioaddr2 BXP_ATA0_IOADDR2, + irq BXP_ATA0_IRQ, master BXP_ATA0_MASTER present BXP_ATA0_MASTER_PRESENT type BXP_ATA0_MASTER_TYPE diff --git a/bochs/bochs.h b/bochs/bochs.h index 95dcf7c79..9725edeea 100644 --- a/bochs/bochs.h +++ b/bochs/bochs.h @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: bochs.h,v 1.181 2006-02-24 22:35:45 vruppert Exp $ +// $Id: bochs.h,v 1.182 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -464,13 +464,6 @@ extern bx_bool bx_gui_sighandler; #define BX_PATHNAME_LEN 512 -typedef struct { - bx_param_bool_c *Opresent; - bx_param_num_c *Oioaddr1; - bx_param_num_c *Oioaddr2; - bx_param_num_c *Oirq; -} bx_ata_options; - typedef struct { bx_param_bool_c *Oenabled; bx_param_string_c *Ooutfile; @@ -522,8 +515,6 @@ typedef struct { #define BX_N_PCI_SLOTS 5 typedef struct BOCHSAPI { - bx_ata_options ata[BX_MAX_ATA_CHANNEL]; - bx_atadevice_options atadevice[BX_MAX_ATA_CHANNEL][2]; bx_serial_options com[BX_N_SERIAL_PORTS]; bx_parport_options par[BX_N_PARALLEL_PORTS]; bx_usb_options usb[BX_N_USB_HUBS]; diff --git a/bochs/config.cc b/bochs/config.cc index b0e789981..af9937dd7 100755 --- a/bochs/config.cc +++ b/bochs/config.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: config.cc,v 1.84 2006-02-24 22:35:45 vruppert Exp $ +// $Id: config.cc,v 1.85 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -54,288 +54,254 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] static int parse_bochsrc(char *rcfile); static int get_floppy_type_from_image(const char *filename); -static Bit64s bx_param_handler (bx_param_c *param, int set, Bit64s val) +static Bit64s bx_param_handler(bx_param_c *param, int set, Bit64s val) { - bx_id id = param->get_id (); char pname[BX_PATHNAME_LEN]; + Bit8u channel, device; - switch (id) { - case BXP_ATA0_MASTER_STATUS: - case BXP_ATA0_SLAVE_STATUS: - case BXP_ATA1_MASTER_STATUS: - case BXP_ATA1_SLAVE_STATUS: - case BXP_ATA2_MASTER_STATUS: - case BXP_ATA2_SLAVE_STATUS: - case BXP_ATA3_MASTER_STATUS: - case BXP_ATA3_SLAVE_STATUS: + bx_list_c *base = (bx_list_c*) param->get_parent(); + base->get_param_path(pname, BX_PATHNAME_LEN); + if (!strncmp(pname, "ata.", 4)) { + channel = pname[4] - '0'; + if (!strcmp(base->get_name(), "master")) { + device = 0; + } else { + device = 1; + } + if (!strcmp(param->get_name(), "status")) { if ((set) && (SIM->get_init_done ())) { - Bit8u device = id - BXP_ATA0_MASTER_STATUS; - Bit32u handle = DEV_hd_get_device_handle (device/2, device%2); + Bit32u handle = DEV_hd_get_device_handle(channel, device); DEV_hd_set_cd_media_status(handle, val == BX_INSERTED); - bx_gui->update_drive_status_buttons (); + bx_gui->update_drive_status_buttons(); } - break; - - case BXP_ATA0_MASTER_MODE: - case BXP_ATA0_SLAVE_MODE: - case BXP_ATA1_MASTER_MODE: - case BXP_ATA1_SLAVE_MODE: - case BXP_ATA2_MASTER_MODE: - case BXP_ATA2_SLAVE_MODE: - case BXP_ATA3_MASTER_MODE: - case BXP_ATA3_SLAVE_MODE: + } else if (!strcmp(param->get_name(), "mode")) { if (set) { - int device = id - BXP_ATA0_MASTER_MODE; switch (val) { case BX_ATA_MODE_UNDOABLE: case BX_ATA_MODE_VOLATILE: // case BX_ATA_MODE_Z_UNDOABLE: // case BX_ATA_MODE_Z_VOLATILE: - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_JOURNAL + device))->set_enabled (1); + SIM->get_param("journal", base)->set_enabled(1); break; default: - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_JOURNAL + device))->set_enabled (0); + SIM->get_param("journal", base)->set_enabled(0); } } - break; - - case BXP_ATA0_MASTER_TYPE: - case BXP_ATA0_SLAVE_TYPE: - case BXP_ATA1_MASTER_TYPE: - case BXP_ATA1_SLAVE_TYPE: - case BXP_ATA2_MASTER_TYPE: - case BXP_ATA2_SLAVE_TYPE: - case BXP_ATA3_MASTER_TYPE: - case BXP_ATA3_SLAVE_TYPE: + } else if (!strcmp(param->get_name(), "type")) { if (set) { - int device = id - BXP_ATA0_MASTER_TYPE; switch (val) { case BX_ATA_DEVICE_DISK: - SIM->get_param_num ((bx_id)(BXP_ATA0_MASTER_PRESENT + device))->set (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_MODE + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_PATH + device))->set_enabled (1); - //SIM->get_param ((bx_id)(BXP_ATA0_MASTER_JOURNAL + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_CYLINDERS + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_HEADS + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_SPT + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_STATUS + device))->set_enabled (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_MODEL + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_BIOSDETECT + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_TRANSLATION + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_PATH + device))->set_runtime_param (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_STATUS + device))->set_runtime_param (0); + SIM->get_param_num("present", base)->set(1); + SIM->get_param("mode", base)->set_enabled(1); + SIM->get_param("path", base)->set_enabled(1); + //SIM->get_param("journal", base)->set_enabled(1); + SIM->get_param("cylinders", base)->set_enabled(1); + SIM->get_param("heads", base)->set_enabled(1); + SIM->get_param("spt", base)->set_enabled(1); + SIM->get_param("status", base)->set_enabled(0); + SIM->get_param("model", base)->set_enabled(1); + SIM->get_param("biosdetect", base)->set_enabled(1); + SIM->get_param("translation", base)->set_enabled(1); + SIM->get_param("path", base)->set_runtime_param(0); + SIM->get_param("status", base)->set_runtime_param(0); break; case BX_ATA_DEVICE_CDROM: - SIM->get_param_num ((bx_id)(BXP_ATA0_MASTER_PRESENT + device))->set (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_MODE + device))->set_enabled (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_PATH + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_JOURNAL + device))->set_enabled (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_CYLINDERS + device))->set_enabled (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_HEADS + device))->set_enabled (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_SPT + device))->set_enabled (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_STATUS + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_MODEL + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_BIOSDETECT + device))->set_enabled (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_TRANSLATION + device))->set_enabled (0); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_PATH + device))->set_runtime_param (1); - SIM->get_param ((bx_id)(BXP_ATA0_MASTER_STATUS + device))->set_runtime_param (1); + SIM->get_param_num("present", base)->set(1); + SIM->get_param("mode", base)->set_enabled(0); + SIM->get_param("path", base)->set_enabled(1); + SIM->get_param("journal", base)->set_enabled(0); + SIM->get_param("cylinders", base)->set_enabled(0); + SIM->get_param("heads", base)->set_enabled(0); + SIM->get_param("spt", base)->set_enabled(0); + SIM->get_param("status", base)->set_enabled(1); + SIM->get_param("model", base)->set_enabled(1); + SIM->get_param("biosdetect", base)->set_enabled(1); + SIM->get_param("translation", base)->set_enabled(0); + SIM->get_param("path", base)->set_runtime_param(1); + SIM->get_param("status", base)->set_runtime_param(1); break; - } } - break; - default: - param->get_param_path(pname, BX_PATHNAME_LEN); - if (!strcmp(pname, BXPN_LOAD32BITOS_WHICH)) { - if (set) { - int enable = (val != Load32bitOSNone); - SIM->get_param(BXPN_LOAD32BITOS_PATH)->set_enabled(enable); - SIM->get_param(BXPN_LOAD32BITOS_IOLOG)->set_enabled(enable); - SIM->get_param(BXPN_LOAD32BITOS_INITRD)->set_enabled(enable); - } - } else if (!strcmp(pname, BXPN_FLOPPYA_TYPE)) { - if (set) { - if (val == BX_FLOPPY_AUTO) { - val = get_floppy_type_from_image(SIM->get_param_string(BXPN_FLOPPYA_PATH)->getptr()); - SIM->get_param_enum(BXPN_FLOPPYA_TYPE)->set(val); - } else if (!SIM->get_init_done ()) { - SIM->get_param_enum(BXPN_FLOPPYA_DEVTYPE)->set(val); - } - } - } else if (!strcmp(pname, BXPN_FLOPPYB_TYPE)) { - if (set) { - if (val == BX_FLOPPY_AUTO) { - val = get_floppy_type_from_image(SIM->get_param_string(BXPN_FLOPPYB_PATH)->getptr()); - SIM->get_param_enum(BXPN_FLOPPYB_TYPE)->set(val); - } else if (!SIM->get_init_done ()) { - SIM->get_param_enum(BXPN_FLOPPYB_DEVTYPE)->set(val); - } - } - } else if (!strcmp(pname, BXPN_FLOPPYA_STATUS)) { - if ((set) && (SIM->get_init_done())) { - DEV_floppy_set_media_status(0, val == BX_INSERTED); - bx_gui->update_drive_status_buttons(); - } - } else if (!strcmp(pname, BXPN_FLOPPYB_STATUS)) { - if ((set) && (SIM->get_init_done())) { - DEV_floppy_set_media_status(1, val == BX_INSERTED); - bx_gui->update_drive_status_buttons(); - } - } else { - BX_PANIC (("bx_param_handler called with unknown id %d", id)); - return -1; } + } + } else { + param->get_param_path(pname, BX_PATHNAME_LEN); + if (!strcmp(pname, BXPN_LOAD32BITOS_WHICH)) { + if (set) { + int enable = (val != Load32bitOSNone); + SIM->get_param(BXPN_LOAD32BITOS_PATH)->set_enabled(enable); + SIM->get_param(BXPN_LOAD32BITOS_IOLOG)->set_enabled(enable); + SIM->get_param(BXPN_LOAD32BITOS_INITRD)->set_enabled(enable); + } + } else if (!strcmp(pname, BXPN_FLOPPYA_TYPE)) { + if (set) { + if (val == BX_FLOPPY_AUTO) { + val = get_floppy_type_from_image(SIM->get_param_string(BXPN_FLOPPYA_PATH)->getptr()); + SIM->get_param_enum(BXPN_FLOPPYA_TYPE)->set(val); + } else if (!SIM->get_init_done ()) { + SIM->get_param_enum(BXPN_FLOPPYA_DEVTYPE)->set(val); + } + } + } else if (!strcmp(pname, BXPN_FLOPPYB_TYPE)) { + if (set) { + if (val == BX_FLOPPY_AUTO) { + val = get_floppy_type_from_image(SIM->get_param_string(BXPN_FLOPPYB_PATH)->getptr()); + SIM->get_param_enum(BXPN_FLOPPYB_TYPE)->set(val); + } else if (!SIM->get_init_done ()) { + SIM->get_param_enum(BXPN_FLOPPYB_DEVTYPE)->set(val); + } + } + } else if (!strcmp(pname, BXPN_FLOPPYA_STATUS)) { + if ((set) && (SIM->get_init_done())) { + DEV_floppy_set_media_status(0, val == BX_INSERTED); + bx_gui->update_drive_status_buttons(); + } + } else if (!strcmp(pname, BXPN_FLOPPYB_STATUS)) { + if ((set) && (SIM->get_init_done())) { + DEV_floppy_set_media_status(1, val == BX_INSERTED); + bx_gui->update_drive_status_buttons(); + } + } else { + BX_PANIC(("bx_param_handler called with unknown parameter '%s'", pname)); + return -1; + } } return val; } -char *bx_param_string_handler (bx_param_string_c *param, int set, char *val, int maxlen) +char *bx_param_string_handler(bx_param_string_c *param, int set, char *val, int maxlen) { - bx_id id = param->get_id(); char pname[BX_PATHNAME_LEN]; + Bit8u channel, device; int empty = 0; if ((strlen(val) < 1) || !strcmp ("none", val)) { empty = 1; val = "none"; } - switch (id) { - case BXP_ATA0_MASTER_PATH: - case BXP_ATA0_SLAVE_PATH: - case BXP_ATA1_MASTER_PATH: - case BXP_ATA1_SLAVE_PATH: - case BXP_ATA2_MASTER_PATH: - case BXP_ATA2_SLAVE_PATH: - case BXP_ATA3_MASTER_PATH: - case BXP_ATA3_SLAVE_PATH: + bx_list_c *base = (bx_list_c*) param->get_parent(); + base->get_param_path(pname, BX_PATHNAME_LEN); + if (!strncmp(pname, "ata.", 4)) { + channel = pname[4] - '0'; + if (!strcmp(base->get_name(), "master")) { + device = 0; + } else { + device = 1; + } + if (!strcmp(param->get_name(), "path")) { if (set==1) { if (SIM->get_init_done ()) { - - Bit8u device = id - BXP_ATA0_MASTER_PATH; - Bit32u handle = DEV_hd_get_device_handle(device/2, device%2); - + Bit32u handle = DEV_hd_get_device_handle(channel, device); if (empty) { DEV_hd_set_cd_media_status(handle, 0); - bx_gui->update_drive_status_buttons (); + bx_gui->update_drive_status_buttons(); } else { - if (!SIM->get_param_num((bx_id)(BXP_ATA0_MASTER_PRESENT + device))->get ()) { + if (!SIM->get_param_num("present", base)->get()) { BX_ERROR(("Cannot add a cdrom drive at runtime")); - bx_options.atadevice[device/2][device%2].Opresent->set (0); + SIM->get_param_num("present", base)->set(0); } - if (SIM->get_param_num((bx_id)(BXP_ATA0_MASTER_TYPE + device))->get () != BX_ATA_DEVICE_CDROM) { + if (SIM->get_param_num("type", base)->get() != BX_ATA_DEVICE_CDROM) { BX_ERROR(("Device is not a cdrom drive")); - bx_options.atadevice[device/2][device%2].Opresent->set (0); + SIM->get_param_num("present", base)->set(0); } } if (DEV_hd_present() && - (SIM->get_param_num((bx_id)(BXP_ATA0_MASTER_STATUS + device))->get () == BX_INSERTED) && - (SIM->get_param_num((bx_id)(BXP_ATA0_MASTER_TYPE + device))->get () == BX_ATA_DEVICE_CDROM)) { + (SIM->get_param_num("status", base)->get () == BX_INSERTED) && + (SIM->get_param_num("type", base)->get() == BX_ATA_DEVICE_CDROM)) { // tell the device model that we removed, then inserted the cd DEV_hd_set_cd_media_status(handle, 0); DEV_hd_set_cd_media_status(handle, 1); } } } - break; - - default: - param->get_param_path(pname, BX_PATHNAME_LEN); - if (!strcmp(pname, BXPN_SCREENMODE)) { - if (set==1) { - BX_INFO (("Screen mode changed to %s", val)); - } - } else if (!strcmp(pname, BXPN_FLOPPYA_PATH)) { - if (set==1) { - if (SIM->get_init_done()) { - if (empty) { - DEV_floppy_set_media_status(0, 0); - bx_gui->update_drive_status_buttons(); - } else { - if (!SIM->get_param_num(BXPN_FLOPPYA_TYPE)->get_enabled()) { - BX_ERROR(("Cannot add a floppy drive at runtime")); - SIM->get_param_string(BXPN_FLOPPYA_PATH)->set("none"); - } - } - if ((DEV_floppy_present()) && - (SIM->get_param_enum(BXPN_FLOPPYA_STATUS)->get() == BX_INSERTED)) { - // tell the device model that we removed, then inserted the disk - DEV_floppy_set_media_status(0, 0); - DEV_floppy_set_media_status(0, 1); - } - } else { - SIM->get_param_enum(BXPN_FLOPPYA_DEVTYPE)->set_enabled(!empty); - SIM->get_param_enum(BXPN_FLOPPYA_TYPE)->set_enabled(!empty); - SIM->get_param_enum(BXPN_FLOPPYA_STATUS)->set_enabled(!empty); - } - } - } else if (!strcmp(pname, BXPN_FLOPPYB_PATH)) { - if (set==1) { - if (SIM->get_init_done()) { - if (empty) { - DEV_floppy_set_media_status(1, 0); - bx_gui->update_drive_status_buttons(); - } else { - if (!SIM->get_param_num(BXPN_FLOPPYB_TYPE)->get_enabled()) { - BX_ERROR(("Cannot add a floppy drive at runtime")); - SIM->get_param_string(BXPN_FLOPPYB_PATH)->set("none"); - } - } - if ((DEV_floppy_present()) && - (SIM->get_param_enum(BXPN_FLOPPYB_STATUS)->get() == BX_INSERTED)) { - // tell the device model that we removed, then inserted the disk - DEV_floppy_set_media_status(1, 0); - DEV_floppy_set_media_status(1, 1); - } - } else { - SIM->get_param_enum(BXPN_FLOPPYB_DEVTYPE)->set_enabled(!empty); - SIM->get_param_enum(BXPN_FLOPPYB_TYPE)->set_enabled(!empty); - SIM->get_param_enum(BXPN_FLOPPYB_STATUS)->set_enabled(!empty); - } - } - } else { - BX_PANIC (("bx_string_handler called with unexpected parameter %d", param->get_id())); + } + } else { + param->get_param_path(pname, BX_PATHNAME_LEN); + if (!strcmp(pname, BXPN_SCREENMODE)) { + if (set==1) { + BX_INFO(("Screen mode changed to %s", val)); } + } else if (!strcmp(pname, BXPN_FLOPPYA_PATH)) { + if (set==1) { + if (SIM->get_init_done()) { + if (empty) { + DEV_floppy_set_media_status(0, 0); + bx_gui->update_drive_status_buttons(); + } else { + if (!SIM->get_param_num(BXPN_FLOPPYA_TYPE)->get_enabled()) { + BX_ERROR(("Cannot add a floppy drive at runtime")); + SIM->get_param_string(BXPN_FLOPPYA_PATH)->set("none"); + } + } + if ((DEV_floppy_present()) && + (SIM->get_param_enum(BXPN_FLOPPYA_STATUS)->get() == BX_INSERTED)) { + // tell the device model that we removed, then inserted the disk + DEV_floppy_set_media_status(0, 0); + DEV_floppy_set_media_status(0, 1); + } + } else { + SIM->get_param_enum(BXPN_FLOPPYA_DEVTYPE)->set_enabled(!empty); + SIM->get_param_enum(BXPN_FLOPPYA_TYPE)->set_enabled(!empty); + SIM->get_param_enum(BXPN_FLOPPYA_STATUS)->set_enabled(!empty); + } + } + } else if (!strcmp(pname, BXPN_FLOPPYB_PATH)) { + if (set==1) { + if (SIM->get_init_done()) { + if (empty) { + DEV_floppy_set_media_status(1, 0); + bx_gui->update_drive_status_buttons(); + } else { + if (!SIM->get_param_num(BXPN_FLOPPYB_TYPE)->get_enabled()) { + BX_ERROR(("Cannot add a floppy drive at runtime")); + SIM->get_param_string(BXPN_FLOPPYB_PATH)->set("none"); + } + } + if ((DEV_floppy_present()) && + (SIM->get_param_enum(BXPN_FLOPPYB_STATUS)->get() == BX_INSERTED)) { + // tell the device model that we removed, then inserted the disk + DEV_floppy_set_media_status(1, 0); + DEV_floppy_set_media_status(1, 1); + } + } else { + SIM->get_param_enum(BXPN_FLOPPYB_DEVTYPE)->set_enabled(!empty); + SIM->get_param_enum(BXPN_FLOPPYB_TYPE)->set_enabled(!empty); + SIM->get_param_enum(BXPN_FLOPPYB_STATUS)->set_enabled(!empty); + } + } + } else { + BX_PANIC(("bx_param_string_handler called with unknown parameter '%s'", pname)); + } } return val; } static int bx_param_enable_handler (bx_param_c *param, int val) { - bx_id id = param->get_id (); - switch (id) { - case BXP_ATA0_MASTER_STATUS: - case BXP_ATA0_SLAVE_STATUS: - case BXP_ATA1_MASTER_STATUS: - case BXP_ATA1_SLAVE_STATUS: - case BXP_ATA2_MASTER_STATUS: - case BXP_ATA2_SLAVE_STATUS: - case BXP_ATA3_MASTER_STATUS: - case BXP_ATA3_SLAVE_STATUS: + char pname[BX_PATHNAME_LEN]; + Bit8u channel, device; + + bx_list_c *base = (bx_list_c*) param->get_parent(); + base->get_param_path(pname, BX_PATHNAME_LEN); + if (!strncmp(pname, "ata.", 4)) { + channel = pname[4] - '0'; + if (!strcmp(base->get_name(), "master")) { + device = 0; + } else { + device = 1; + } + if (!strcmp(param->get_name(), "status")) { if (val != 0) { - Bit8u device = id - BXP_ATA0_MASTER_STATUS; - - switch (SIM->get_param_enum ((bx_id)(BXP_ATA0_MASTER_TYPE + device))->get()) { + switch (SIM->get_param_enum("type", base)->get()) { case BX_ATA_DEVICE_CDROM: return (1); break; - } } - return (0); - break; - - case BXP_ATA0_MASTER_JOURNAL: - case BXP_ATA0_SLAVE_JOURNAL: - case BXP_ATA1_MASTER_JOURNAL: - case BXP_ATA1_SLAVE_JOURNAL: - case BXP_ATA2_MASTER_JOURNAL: - case BXP_ATA2_SLAVE_JOURNAL: - case BXP_ATA3_MASTER_JOURNAL: - case BXP_ATA3_SLAVE_JOURNAL: + } + } else if (!strcmp(param->get_name(), "journal")) { if (val != 0) { - Bit8u device = id - BXP_ATA0_MASTER_JOURNAL; - - switch (SIM->get_param_enum ((bx_id)(BXP_ATA0_MASTER_TYPE + device))->get()) { + switch (SIM->get_param_enum("type", base)->get()) { case BX_ATA_DEVICE_DISK: - switch (SIM->get_param_enum ((bx_id)(BXP_ATA0_MASTER_MODE + device))->get()) { + switch (SIM->get_param_enum("mode", base)->get()) { case BX_ATA_MODE_UNDOABLE: case BX_ATA_MODE_VOLATILE: // case BX_ATA_MODE_Z_UNDOABLE: @@ -343,13 +309,14 @@ static int bx_param_enable_handler (bx_param_c *param, int val) return (1); break; } - } } + } return (0); - break; - - default: - BX_PANIC (("bx_param_handler called with unknown id %d", id)); + } else { + BX_PANIC(("bx_param_enable_handler called with unknown parameter '%s'", pname)); + } + } else { + BX_PANIC(("bx_param_enable_handler called with unknown parameter '%s'", pname)); } return val; } @@ -359,6 +326,8 @@ void bx_init_options() int i; bx_list_c *menu; bx_list_c *deplist; + bx_param_num_c *ioaddr, *ioaddr2, *irq; + bx_param_bool_c *enabled; bx_param_filename_c *path; char name[1024], descr[1024], group[16], label[1024]; @@ -374,282 +343,6 @@ void bx_init_options() BX_RUN_START, BX_QUICK_START); - // disk options - - // FIXME use descr and name - char *s_atachannel[] = { - "ATA channel 0", - "ATA channel 1", - "ATA channel 2", - "ATA channel 3", - }; - char *s_atadevice[4][2] = { - { "First HD/CD on channel 0", - "Second HD/CD on channel 0" }, - { "First HD/CD on channel 1", - "Second HD/CD on channel 1" }, - { "First HD/CD on channel 2", - "Second HD/CD on channel 2" }, - { "First HD/CD on channel 3", - "Second HD/CD on channel 3" } - }; - Bit16u ata_default_ioaddr1[BX_MAX_ATA_CHANNEL] = { - 0x1f0, 0x170, 0x1e8, 0x168 - }; - Bit16u ata_default_ioaddr2[BX_MAX_ATA_CHANNEL] = { - 0x3f0, 0x370, 0x3e0, 0x360 - }; - Bit8u ata_default_irq[BX_MAX_ATA_CHANNEL] = { - 14, 15, 11, 9 - }; - - bx_list_c *ata[BX_MAX_ATA_CHANNEL]; - bx_list_c *ata_menu[BX_MAX_ATA_CHANNEL]; - - Bit8u channel; - for (channel=0; channelget_options ()->set (bx_list_c::SERIES_ASK); - - ata[channel]->add (bx_options.ata[channel].Opresent = new bx_param_bool_c ((bx_id)(BXP_ATAx_PRESENT(channel)), - "ata:present", - "Controls whether ata channel is installed or not", - 0)); - - ata[channel]->add (bx_options.ata[channel].Oioaddr1 = new bx_param_num_c ((bx_id)(BXP_ATAx_IOADDR1(channel)), - "ata:ioaddr1", - "IO adress of ata command block", - 0, 0xffff, - ata_default_ioaddr1[channel])); - - ata[channel]->add (bx_options.ata[channel].Oioaddr2 = new bx_param_num_c ((bx_id)(BXP_ATAx_IOADDR2(channel)), - "ata:ioaddr2", - "IO adress of ata control block", - 0, 0xffff, - ata_default_ioaddr2[channel])); - - ata[channel]->add (bx_options.ata[channel].Oirq = new bx_param_num_c ((bx_id)(BXP_ATAx_IRQ(channel)), - "ata:irq", - "IRQ used by this ata channel", - 0, 15, - ata_default_irq[channel])); - - // all items in the ata[channel] menu depend on the present flag. - // The menu list is complete, but a few dependent_list items will - // be added later. Use clone() to make a copy of the dependent_list - // so that it can be changed without affecting the menu. - bx_options.ata[channel].Opresent->set_dependent_list ( - ata[channel]->clone()); - - for (Bit8u slave=0; slave<2; slave++) { - - menu = bx_options.atadevice[channel][slave].Omenu = new bx_list_c ((bx_id)(BXP_ATAx_DEVICE(channel,slave)), - s_atadevice[channel][slave], - s_atadevice[channel][slave], - BXP_PARAMS_PER_ATA_DEVICE + 1 ); - menu->get_options ()->set (menu->SERIES_ASK); - - menu->add (bx_options.atadevice[channel][slave].Opresent = new bx_param_bool_c ((bx_id)(BXP_ATAx_DEVICE_PRESENT(channel,slave)), - "ata-device:present", - "Controls whether ata device is installed or not", - 0)); - - menu->add (bx_options.atadevice[channel][slave].Otype = new bx_param_enum_c ((bx_id)(BXP_ATAx_DEVICE_TYPE(channel,slave)), - "ata-device:type", - "Type of ATA device (disk or cdrom)", - atadevice_type_names, - BX_ATA_DEVICE_DISK, - BX_ATA_DEVICE_DISK)); - - menu->add (bx_options.atadevice[channel][slave].Opath = new bx_param_filename_c ((bx_id)(BXP_ATAx_DEVICE_PATH(channel,slave)), - "ata-device:path", - "Pathname of the image or physical device (cdrom only)", - "", BX_PATHNAME_LEN)); - - menu->add (bx_options.atadevice[channel][slave].Omode = new bx_param_enum_c ((bx_id)(BXP_ATAx_DEVICE_MODE(channel,slave)), - "ata-device:mode", - "Mode of the ATA harddisk", - atadevice_mode_names, - BX_ATA_MODE_FLAT, - BX_ATA_MODE_FLAT)); - - menu->add (bx_options.atadevice[channel][slave].Ostatus = new bx_param_enum_c ((bx_id)(BXP_ATAx_DEVICE_STATUS(channel,slave)), - "ata-device:status", - "CD-ROM media status (inserted / ejected)", - atadevice_status_names, - BX_INSERTED, - BX_EJECTED)); - - menu->add (bx_options.atadevice[channel][slave].Ojournal = new bx_param_filename_c ((bx_id)(BXP_ATAx_DEVICE_JOURNAL(channel,slave)), - "ata-device:journal", - "Pathname of the journal file", - "", BX_PATHNAME_LEN)); - - menu->add (bx_options.atadevice[channel][slave].Ocylinders = new bx_param_num_c ((bx_id)(BXP_ATAx_DEVICE_CYLINDERS(channel,slave)), - "ata-device:cylinders", - "Number of cylinders", - 0, 262143, - 0)); - menu->add (bx_options.atadevice[channel][slave].Oheads = new bx_param_num_c ((bx_id)(BXP_ATAx_DEVICE_HEADS(channel,slave)), - "ata-device:heads", - "Number of heads", - 0, 255, - 0)); - menu->add (bx_options.atadevice[channel][slave].Ospt = new bx_param_num_c ((bx_id)(BXP_ATAx_DEVICE_SPT(channel,slave)), - "ata-device:spt", - "Number of sectors per track", - 0, 255, - 0)); - - menu->add (bx_options.atadevice[channel][slave].Omodel = new bx_param_string_c ((bx_id)(BXP_ATAx_DEVICE_MODEL(channel,slave)), - "ata-device:model", - "String returned by the 'identify device' command", - "Generic 1234", 40)); - - menu->add (bx_options.atadevice[channel][slave].Obiosdetect = new bx_param_enum_c ((bx_id)(BXP_ATAx_DEVICE_BIOSDETECT(channel,slave)), - "ata-device:biosdetect", - "Type of bios detection", - atadevice_biosdetect_names, - BX_ATA_BIOSDETECT_AUTO, - BX_ATA_BIOSDETECT_NONE)); - - menu->add (bx_options.atadevice[channel][slave].Otranslation = new bx_param_enum_c ((bx_id)(BXP_ATAx_DEVICE_TRANSLATION(channel,slave)), - "How the ata-disk translation is done by the bios", - "Type of translation", - atadevice_translation_names, - BX_ATA_TRANSLATION_AUTO, - BX_ATA_TRANSLATION_NONE)); - - // the menu and all items on it depend on the Opresent flag - bx_options.atadevice[channel][slave].Opresent->set_dependent_list ( - menu->clone ()); - // the present flag depends on the ATA channel's present flag - bx_options.ata[channel].Opresent->get_dependent_list()->add ( - bx_options.atadevice[channel][slave].Opresent); - // the menu depends on the ATA channel's present flag - bx_options.ata[channel].Opresent->get_dependent_list()->add(menu); - } - - // set up top level menu for ATA[i] controller configuration. This list - // controls what will appear on the ATA configure dialog. It now - // requests the USE_TAB_WINDOW display, which is implemented in wx. - char buffer[32]; - sprintf (buffer, "Configure ATA%d", channel); - ata_menu[channel] = new bx_list_c ((bx_id)(BXP_ATAx_MENU(channel)), strdup(buffer), "", 4); - ata_menu[channel]->add (ata[channel]); - ata_menu[channel]->add (bx_options.atadevice[channel][0].Omenu); - ata_menu[channel]->add (bx_options.atadevice[channel][1].Omenu); - ata_menu[channel]->get_options()->set (bx_list_c::USE_TAB_WINDOW); - } - - // Enable two ATA interfaces by default, disable the others. - // Now that the dependence relationships are established, call set() on - // the ata device present params to set all enables correctly. - for (i=0; iset_initial_val(i<2); - bx_options.ata[i].Opresent->set(i<2); - } - - for (channel=0; channelset_ask_format ("Channel is enabled: [%s] "); - bx_options.ata[channel].Oioaddr1->set_ask_format ("Enter new ioaddr1: [0x%x] "); - bx_options.ata[channel].Oioaddr2->set_ask_format ("Enter new ioaddr2: [0x%x] "); - bx_options.ata[channel].Oirq->set_ask_format ("Enter new IRQ: [%d] "); -#if BX_WITH_WX - bx_options.ata[channel].Opresent->set_label ("Enable this channel?"); - bx_options.ata[channel].Oioaddr1->set_label ("I/O Address 1:"); - bx_options.ata[channel].Oioaddr2->set_label ("I/O Address 2:"); - bx_options.ata[channel].Oirq->set_label ("IRQ:"); - bx_options.ata[channel].Oirq->set_options (bx_param_num_c::USE_SPIN_CONTROL); -#else - bx_options.ata[channel].Opresent->set_format ("enabled: %s"); - bx_options.ata[channel].Oioaddr1->set_format ("ioaddr1: 0x%x"); - bx_options.ata[channel].Oioaddr2->set_format ("ioaddr2: 0x%x"); - bx_options.ata[channel].Oirq->set_format ("irq: %d"); -#endif - bx_options.ata[channel].Oioaddr1->set_base (16); - bx_options.ata[channel].Oioaddr2->set_base (16); - - for (Bit8u slave=0; slave<2; slave++) { - - bx_options.atadevice[channel][slave].Opresent->set_ask_format ( - "Device is enabled: [%s] "); - bx_options.atadevice[channel][slave].Otype->set_ask_format ( - "Enter type of ATA device, disk or cdrom: [%s] "); - bx_options.atadevice[channel][slave].Omode->set_ask_format ( - "Enter mode of ATA device, (flat, concat, etc.): [%s] "); - bx_options.atadevice[channel][slave].Opath->set_ask_format ( - "Enter new filename: [%s] "); - bx_options.atadevice[channel][slave].Ocylinders->set_ask_format ( - "Enter number of cylinders: [%d] "); - bx_options.atadevice[channel][slave].Oheads->set_ask_format ( - "Enter number of heads: [%d] "); - bx_options.atadevice[channel][slave].Ospt->set_ask_format ( - "Enter number of sectors per track: [%d] "); - bx_options.atadevice[channel][slave].Ostatus->set_ask_format ( - "Is the device inserted or ejected? [%s] "); - bx_options.atadevice[channel][slave].Omodel->set_ask_format ( - "Enter new model name: [%s]"); - bx_options.atadevice[channel][slave].Otranslation->set_ask_format ( - "Enter translation type: [%s]"); - bx_options.atadevice[channel][slave].Obiosdetect->set_ask_format ( - "Enter bios detection type: [%s]"); - bx_options.atadevice[channel][slave].Ojournal->set_ask_format ( - "Enter path of journal file: [%s]"); - -#if BX_WITH_WX - bx_options.atadevice[channel][slave].Opresent->set_label ( - "Enable this device?"); - bx_options.atadevice[channel][slave].Otype->set_label ( - "Type of ATA device:"); - bx_options.atadevice[channel][slave].Omode->set_label ( - "Type of disk image:"); - bx_options.atadevice[channel][slave].Opath->set_label ( - "Path or physical device name:"); - bx_options.atadevice[channel][slave].Ocylinders->set_label ( - "Cylinders:"); - bx_options.atadevice[channel][slave].Oheads->set_label ( - "Heads:"); - bx_options.atadevice[channel][slave].Ospt->set_label ( - "Sectors per track:"); - bx_options.atadevice[channel][slave].Ostatus->set_label ( - "Inserted?"); - bx_options.atadevice[channel][slave].Omodel->set_label ( - "Model name:"); - bx_options.atadevice[channel][slave].Otranslation->set_label ( - "Translation type:"); - bx_options.atadevice[channel][slave].Obiosdetect->set_label ( - "BIOS Detection:"); - bx_options.atadevice[channel][slave].Ojournal->set_label ( - "Path of journal file:"); -#else - bx_options.atadevice[channel][slave].Opresent->set_format ("enabled: %s"); - bx_options.atadevice[channel][slave].Otype->set_format ("type %s"); - bx_options.atadevice[channel][slave].Omode->set_format ("mode %s"); - bx_options.atadevice[channel][slave].Opath->set_format ("path '%s'"); - bx_options.atadevice[channel][slave].Ocylinders->set_format ("%d cylinders"); - bx_options.atadevice[channel][slave].Oheads->set_format ("%d heads"); - bx_options.atadevice[channel][slave].Ospt->set_format ("%d sectors/track"); - bx_options.atadevice[channel][slave].Ostatus->set_format ("%s"); - bx_options.atadevice[channel][slave].Omodel->set_format ("model '%s'"); - bx_options.atadevice[channel][slave].Otranslation->set_format ("translation '%s'"); - bx_options.atadevice[channel][slave].Obiosdetect->set_format ("biosdetect '%s'"); - bx_options.atadevice[channel][slave].Ojournal->set_format ("journal is '%s'"); -#endif - - bx_options.atadevice[channel][slave].Otype->set_handler (bx_param_handler); - bx_options.atadevice[channel][slave].Omode->set_handler (bx_param_handler); - bx_options.atadevice[channel][slave].Ostatus->set_handler (bx_param_handler); - bx_options.atadevice[channel][slave].Opath->set_handler (bx_param_string_handler); - - // Set the enable_hanlders - bx_options.atadevice[channel][slave].Ojournal->set_enable_handler (bx_param_enable_handler); - bx_options.atadevice[channel][slave].Ostatus->set_enable_handler (bx_param_enable_handler); - } - } - #if BX_SUPPORT_SMP #define BX_CPU_PROCESSORS_LIMIT 8 #define BX_CPU_CORES_LIMIT 4 @@ -1265,27 +958,240 @@ void bx_init_options() floppyb->get_options()->set(bx_list_c::SERIES_ASK); floppy->get_options()->set(bx_list_c::SHOW_PARENT); + // ATA/ATAPI subtree + bx_list_c *ata = new bx_list_c(root_param, "ata", "ATA/ATAPI Options"); + + // disk options + char *s_atachannel[] = { + "ATA channel 0", + "ATA channel 1", + "ATA channel 2", + "ATA channel 3", + }; + char *s_atadevname[2] = { + "master", + "slave", + }; + char *s_atadevice[4][2] = { + { "First HD/CD on channel 0", + "Second HD/CD on channel 0" }, + { "First HD/CD on channel 1", + "Second HD/CD on channel 1" }, + { "First HD/CD on channel 2", + "Second HD/CD on channel 2" }, + { "First HD/CD on channel 3", + "Second HD/CD on channel 3" } + }; + Bit16u ata_default_ioaddr1[BX_MAX_ATA_CHANNEL] = { + 0x1f0, 0x170, 0x1e8, 0x168 + }; + Bit16u ata_default_ioaddr2[BX_MAX_ATA_CHANNEL] = { + 0x3f0, 0x370, 0x3e0, 0x360 + }; + Bit8u ata_default_irq[BX_MAX_ATA_CHANNEL] = { + 14, 15, 11, 9 + }; + + bx_list_c *ata_menu[BX_MAX_ATA_CHANNEL]; + bx_list_c *ata_res[BX_MAX_ATA_CHANNEL]; + + Bit8u channel; + for (channel=0; channelget_options()->set(bx_list_c::USE_TAB_WINDOW); + ata_res[channel] = new bx_list_c(ata_menu[channel], "resources", s_atachannel[channel], 8); + ata_res[channel]->get_options()->set(bx_list_c::SERIES_ASK); + + enabled = new bx_param_bool_c(ata_res[channel], + "enabled", + "Enable ATA channel", + "Controls whether ata channel is installed or not", + 0); + enabled->set_ask_format("Channel is enabled: [%s] "); + + ioaddr = new bx_param_num_c(ata_res[channel], + "ioaddr1", + "I/O Address 1", + "IO adress of ata command block", + 0, 0xffff, + ata_default_ioaddr1[channel]); + ioaddr->set_base(16); + ioaddr->set_ask_format("Enter new ioaddr1: [0x%x] "); + + ioaddr2 = new bx_param_num_c(ata_res[channel], + "ioaddr2", + "I/O Address 2", + "IO adress of ata control block", + 0, 0xffff, + ata_default_ioaddr2[channel]); + ioaddr2->set_base(16); + ioaddr2->set_ask_format("Enter new ioaddr2: [0x%x] "); + + irq = new bx_param_num_c(ata_res[channel], + "irq", + "IRQ", + "IRQ used by this ata channel", + 0, 15, + ata_default_irq[channel]); + irq->set_ask_format("Enter new IRQ: [%d] "); + irq->set_options(bx_param_num_c::USE_SPIN_CONTROL); + + // all items in the ata[channel] menu depend on the enabled flag. + // The menu list is complete, but a few dependent_list items will + // be added later. Use clone() to make a copy of the dependent_list + // so that it can be changed without affecting the menu. + enabled->set_dependent_list(ata_res[channel]->clone()); + + for (Bit8u slave=0; slave<2; slave++) { + + menu = new bx_list_c(ata_menu[channel], + s_atadevname[slave], + s_atadevice[channel][slave], + BXP_PARAMS_PER_ATA_DEVICE + 1); + menu->get_options()->set(bx_list_c::SERIES_ASK); + + bx_param_bool_c *present = new bx_param_bool_c(menu, + "present", + "Enable this device", + "Controls whether ata device is installed or not", + 0); + present->set_ask_format("Device is enabled: [%s] "); + + bx_param_enum_c *type = new bx_param_enum_c(menu, + "type", + "Type of ATA device", + "Type of ATA device (disk or cdrom)", + atadevice_type_names, + BX_ATA_DEVICE_DISK, + BX_ATA_DEVICE_DISK); + type->set_ask_format("Enter type of ATA device, disk or cdrom: [%s] "); + + path = new bx_param_filename_c(menu, + "path", + "Path or physical device name", + "Pathname of the image or physical device (cdrom only)", + "", BX_PATHNAME_LEN); + path->set_ask_format("Enter new filename: [%s] "); + + bx_param_enum_c *mode = new bx_param_enum_c(menu, + "mode", + "Type of disk image", + "Mode of the ATA harddisk", + atadevice_mode_names, + BX_ATA_MODE_FLAT, + BX_ATA_MODE_FLAT); + mode->set_ask_format("Enter mode of ATA device, (flat, concat, etc.): [%s] "); + + bx_param_enum_c *status = new bx_param_enum_c(menu, + "status", + "Inserted", + "CD-ROM media status (inserted / ejected)", + atadevice_status_names, + BX_INSERTED, + BX_EJECTED); + status->set_ask_format("Is the device inserted or ejected? [%s] "); + + bx_param_filename_c *journal = new bx_param_filename_c(menu, + "journal", + "Path of journal file", + "Pathname of the journal file", + "", BX_PATHNAME_LEN); + journal->set_ask_format("Enter path of journal file: [%s]"); + + bx_param_num_c *cylinders = new bx_param_num_c(menu, + "cylinders", + "Cylinders", + "Number of cylinders", + 0, 262143, + 0); + cylinders->set_ask_format("Enter number of cylinders: [%d] "); + bx_param_num_c *heads = new bx_param_num_c(menu, + "heads", + "Heads", + "Number of heads", + 0, 255, + 0); + heads->set_ask_format("Enter number of heads: [%d] "); + bx_param_num_c *spt = new bx_param_num_c(menu, + "spt", + "Sectors per track", + "Number of sectors per track", + 0, 255, + 0); + spt->set_ask_format("Enter number of sectors per track: [%d] "); + + bx_param_string_c *model = new bx_param_string_c(menu, + "model", + "Model name", + "String returned by the 'identify device' command", + "Generic 1234", 40); + model->set_ask_format("Enter new model name: [%s]"); + + bx_param_enum_c *biosdetect = new bx_param_enum_c(menu, + "biosdetect", + "BIOS Detection", + "Type of bios detection", + atadevice_biosdetect_names, + BX_ATA_BIOSDETECT_AUTO, + BX_ATA_BIOSDETECT_NONE); + biosdetect->set_ask_format("Enter bios detection type: [%s]"); + + bx_param_enum_c *translation = new bx_param_enum_c(menu, + "translation", + "Translation type", + "How the ata-disk translation is done by the bios", + atadevice_translation_names, + BX_ATA_TRANSLATION_AUTO, + BX_ATA_TRANSLATION_NONE); + translation->set_ask_format("Enter translation type: [%s]"); + + // the menu and all items on it depend on the present flag + present->set_dependent_list(menu->clone()); + // the present flag depends on the ATA channel's enabled flag + enabled->get_dependent_list()->add(present); + // the master/slave menu depends on the ATA channel's enabled flag + enabled->get_dependent_list()->add(menu); + + type->set_handler(bx_param_handler); + mode->set_handler(bx_param_handler); + status->set_handler(bx_param_handler); + path->set_handler(bx_param_string_handler); + + // Set the enable_hanlders + journal->set_enable_handler(bx_param_enable_handler); + status->set_enable_handler(bx_param_enable_handler); + } + + // Enable two ATA interfaces by default, disable the others. + // Now that the dependence relationships are established, call set() on + // the ata device present params to set all enables correctly. + enabled->set_initial_val(i<2); + enabled->set(i<2); + } + // disk menu bx_param_c *disk_menu_init_list[] = { SIM->get_param(BXPN_FLOPPYA), SIM->get_param(BXPN_FLOPPYB), - SIM->get_param(BXP_ATA0), - SIM->get_param(BXP_ATA0_MASTER), - SIM->get_param(BXP_ATA0_SLAVE), + SIM->get_param(BXPN_ATA0_RES), + SIM->get_param(BXPN_ATA0_MASTER), + SIM->get_param(BXPN_ATA0_SLAVE), #if BX_MAX_ATA_CHANNEL>1 - SIM->get_param(BXP_ATA1), - SIM->get_param(BXP_ATA1_MASTER), - SIM->get_param(BXP_ATA1_SLAVE), + SIM->get_param(BXPN_ATA1_RES), + SIM->get_param(BXPN_ATA1_MASTER), + SIM->get_param(BXPN_ATA1_SLAVE), #endif #if BX_MAX_ATA_CHANNEL>2 - SIM->get_param(BXP_ATA2), - SIM->get_param(BXP_ATA2_MASTER), - SIM->get_param(BXP_ATA2_SLAVE), + SIM->get_param(BXPN_ATA2_RES), + SIM->get_param(BXPN_ATA2_MASTER), + SIM->get_param(BXPN_ATA2_SLAVE), #endif #if BX_MAX_ATA_CHANNEL>3 - SIM->get_param(BXP_ATA3), - SIM->get_param(BXP_ATA3_MASTER), - SIM->get_param(BXP_ATA3_SLAVE), + SIM->get_param(BXPN_ATA3_RES), + SIM->get_param(BXPN_ATA3_MASTER), + SIM->get_param(BXPN_ATA3_SLAVE), #endif SIM->get_param("boot_params"), NULL @@ -1683,36 +1589,14 @@ void bx_init_options() menu->get_options ()->set (menu->SHOW_PARENT | menu->SHOW_GROUP_NAME); // param-tree test output -//printf ("parameter tree:\n"); -//print_tree (root_param, 0); +//printf("parameter tree:\n"); +//print_tree(root_param, 0); } void bx_reset_options () { Bit8u i; - // ata/atapi drives - for (unsigned channel=0; channelreset(); - bx_options.ata[channel].Oioaddr1->reset(); - bx_options.ata[channel].Oioaddr2->reset(); - bx_options.ata[channel].Oirq->reset(); - - for (unsigned slave=0; slave<2; slave++) { - bx_options.atadevice[channel][slave].Opresent->reset(); - bx_options.atadevice[channel][slave].Otype->reset(); - bx_options.atadevice[channel][slave].Omode->reset(); - bx_options.atadevice[channel][slave].Opath->reset(); - bx_options.atadevice[channel][slave].Ocylinders->reset(); - bx_options.atadevice[channel][slave].Oheads->reset(); - bx_options.atadevice[channel][slave].Ospt->reset(); - bx_options.atadevice[channel][slave].Ostatus->reset(); - bx_options.atadevice[channel][slave].Omodel->reset(); - bx_options.atadevice[channel][slave].Obiosdetect->reset(); - bx_options.atadevice[channel][slave].Otranslation->reset(); - } - } - // cpu SIM->get_param("cpu")->reset(); @@ -1737,6 +1621,9 @@ void bx_reset_options () // floppy drives SIM->get_param("floppy")->reset(); + // ata/atapi drives + SIM->get_param("ata")->reset(); + // standard ports for (i=0; ireset(); @@ -2124,6 +2011,7 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] { int i, slot, t; Bit8u idx; + bx_list_c *base; if (num_params < 1) return 0; if (num_params < 2) { @@ -2251,6 +2139,7 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] } else if ((!strncmp(params[0], "ata", 3)) && (strlen(params[0]) == 4)) { + char tmpname[80]; Bit8u channel = params[0][3]; if ((channel < '0') || (channel > '9')) { @@ -2264,12 +2153,12 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] if ((num_params < 2) || (num_params > 5)) { PARSE_ERR(("%s: ataX directive malformed.", context)); } - + sprintf(tmpname, "ata.%d.resources", channel); + base = (bx_list_c*) SIM->get_param(tmpname); if (strncmp(params[1], "enabled=", 8)) { PARSE_ERR(("%s: ataX directive malformed.", context)); - } - else { - bx_options.ata[channel].Opresent->set (atol(¶ms[1][8])); + } else { + SIM->get_param_bool("enabled", base)->set(atol(¶ms[1][8])); } if (num_params > 2) { @@ -2278,9 +2167,9 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] } else { if ( (params[2][8] == '0') && (params[2][9] == 'x') ) - bx_options.ata[channel].Oioaddr1->set (strtoul (¶ms[2][8], NULL, 16)); + SIM->get_param_num("ioaddr1", base)->set(strtoul (¶ms[2][8], NULL, 16)); else - bx_options.ata[channel].Oioaddr1->set (strtoul (¶ms[2][8], NULL, 10)); + SIM->get_param_num("ioaddr1", base)->set(strtoul (¶ms[2][8], NULL, 10)); } } @@ -2290,9 +2179,9 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] } else { if ( (params[3][8] == '0') && (params[3][9] == 'x') ) - bx_options.ata[channel].Oioaddr2->set (strtoul (¶ms[3][8], NULL, 16)); + SIM->get_param_num("ioaddr2", base)->set(strtoul (¶ms[3][8], NULL, 16)); else - bx_options.ata[channel].Oioaddr2->set (strtoul (¶ms[3][8], NULL, 10)); + SIM->get_param_num("ioaddr2", base)->set(strtoul (¶ms[3][8], NULL, 10)); } } @@ -2301,15 +2190,16 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] PARSE_ERR(("%s: ataX directive malformed.", context)); } else { - bx_options.ata[channel].Oirq->set (atol(¶ms[4][4])); + SIM->get_param_num("irq", base)->set(atol(¶ms[4][4])); } } } // ataX-master, ataX-slave else if ((!strncmp(params[0], "ata", 3)) && (strlen(params[0]) > 4)) { - Bit8u channel = params[0][3], slave = 0, type = 0, mode = BX_ATA_MODE_FLAT; + Bit8u channel = params[0][3], type = 0, mode = BX_ATA_MODE_FLAT; Bit32u cylinders = 0, heads = 0, sectors = 0; + char tmpname[80]; if ((channel < '0') || (channel > '9')) { PARSE_ERR(("%s: ataX-master/slave directive malformed.", context)); @@ -2324,10 +2214,8 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] PARSE_ERR(("%s: ataX-master/slave directive malformed.", context)); } - if (!strcmp(¶ms[0][4], "-slave")) { - slave = 1; - } - + sprintf(tmpname, "ata.%d.%s", channel, ¶ms[0][5]); + base = (bx_list_c*) SIM->get_param(tmpname); for (i=1; iset(¶ms[i][5]); } else if (!strncmp(params[i], "cylinders=", 10)) { cylinders = atol(¶ms[i][10]); } else if (!strncmp(params[i], "heads=", 6)) { @@ -2364,58 +2252,58 @@ static Bit32s parse_line_formatted(char *context, int num_params, char *params[] } else if (!strncmp(params[i], "spt=", 4)) { sectors = atol(¶ms[i][4]); } else if (!strncmp(params[i], "model=", 6)) { - bx_options.atadevice[channel][slave].Omodel->set(¶ms[i][6]); + SIM->get_param_string("model", base)->set(¶ms[i][6]); } else if (!strcmp(params[i], "biosdetect=none")) { - bx_options.atadevice[channel][slave].Obiosdetect->set(BX_ATA_BIOSDETECT_NONE); + SIM->get_param_enum("biosdetect", base)->set(BX_ATA_BIOSDETECT_NONE); } else if (!strcmp(params[i], "biosdetect=cmos")) { - bx_options.atadevice[channel][slave].Obiosdetect->set(BX_ATA_BIOSDETECT_CMOS); + SIM->get_param_enum("biosdetect", base)->set(BX_ATA_BIOSDETECT_CMOS); } else if (!strcmp(params[i], "biosdetect=auto")) { - bx_options.atadevice[channel][slave].Obiosdetect->set(BX_ATA_BIOSDETECT_AUTO); + SIM->get_param_enum("biosdetect", base)->set(BX_ATA_BIOSDETECT_AUTO); } else if (!strcmp(params[i], "translation=none")) { - bx_options.atadevice[channel][slave].Otranslation->set(BX_ATA_TRANSLATION_NONE); + SIM->get_param_enum("translation", base)->set(BX_ATA_TRANSLATION_NONE); } else if (!strcmp(params[i], "translation=lba")) { - bx_options.atadevice[channel][slave].Otranslation->set(BX_ATA_TRANSLATION_LBA); + SIM->get_param_enum("translation", base)->set(BX_ATA_TRANSLATION_LBA); } else if (!strcmp(params[i], "translation=large")) { - bx_options.atadevice[channel][slave].Otranslation->set(BX_ATA_TRANSLATION_LARGE); + SIM->get_param_enum("translation", base)->set(BX_ATA_TRANSLATION_LARGE); } else if (!strcmp(params[i], "translation=echs")) { // synonym of large - bx_options.atadevice[channel][slave].Otranslation->set(BX_ATA_TRANSLATION_LARGE); + SIM->get_param_enum("translation", base)->set(BX_ATA_TRANSLATION_LARGE); } else if (!strcmp(params[i], "translation=rechs")) { - bx_options.atadevice[channel][slave].Otranslation->set(BX_ATA_TRANSLATION_RECHS); + SIM->get_param_enum("translation", base)->set(BX_ATA_TRANSLATION_RECHS); } else if (!strcmp(params[i], "translation=auto")) { - bx_options.atadevice[channel][slave].Otranslation->set(BX_ATA_TRANSLATION_AUTO); + SIM->get_param_enum("translation", base)->set(BX_ATA_TRANSLATION_AUTO); } else if (!strcmp(params[i], "status=ejected")) { - bx_options.atadevice[channel][slave].Ostatus->set(BX_EJECTED); + SIM->get_param_enum("status", base)->set(BX_EJECTED); } else if (!strcmp(params[i], "status=inserted")) { - bx_options.atadevice[channel][slave].Ostatus->set(BX_INSERTED); + SIM->get_param_enum("status", base)->set(BX_INSERTED); } else if (!strncmp(params[i], "journal=", 8)) { - bx_options.atadevice[channel][slave].Ojournal->set(¶ms[i][8]); + SIM->get_param_string("journal", base)->set(¶ms[i][8]); } else { PARSE_ERR(("%s: ataX-master/slave directive malformed.", context)); } } // Enables the ata device - if (strlen(bx_options.atadevice[channel][slave].Opath->getptr()) > 0) { - bx_options.atadevice[channel][slave].Opresent->set(1); - bx_options.atadevice[channel][slave].Otype->set (type); - bx_options.atadevice[channel][slave].Omode->set (mode); - bx_options.atadevice[channel][slave].Ocylinders->set (cylinders); - bx_options.atadevice[channel][slave].Oheads->set (heads); - bx_options.atadevice[channel][slave].Ospt->set (sectors); + if (strlen(SIM->get_param_string("path", base)->getptr()) > 0) { + SIM->get_param_bool("present", base)->set(1); + SIM->get_param_enum("type", base)->set(type); + SIM->get_param_enum("mode", base)->set(mode); + SIM->get_param_num("cylinders", base)->set(cylinders); + SIM->get_param_num("heads", base)->set(heads); + SIM->get_param_num("spt", base)->set(sectors); } // if enabled, check if device ok - if (bx_options.atadevice[channel][slave].Opresent->get() == 1) { - if (bx_options.atadevice[channel][slave].Otype->get() == BX_ATA_DEVICE_DISK) { - if ((bx_options.atadevice[channel][slave].Ocylinders->get() == 0) && - (bx_options.atadevice[channel][slave].Oheads->get() ==0 ) && - (bx_options.atadevice[channel][slave].Ospt->get() == 0)) { + if (SIM->get_param_bool("present", base)->get() == 1) { + if (SIM->get_param_enum("type", base)->get() == BX_ATA_DEVICE_DISK) { + if ((SIM->get_param_num("cylinders", base)->get() == 0) && + (SIM->get_param_num("heads", base)->get() ==0 ) && + (SIM->get_param_num("spt", base)->get() == 0)) { PARSE_WARN(("%s: ataX-master/slave CHS set to 0/0/0 - autodetection enabled", context)); // using heads = 16 and spt = 63 for autodetection (bximage defaults) - bx_options.atadevice[channel][slave].Oheads->set (16); - bx_options.atadevice[channel][slave].Ospt->set (63); + SIM->get_param_num("heads", base)->set(16); + SIM->get_param_num("spt", base)->set(63); } - } else if (bx_options.atadevice[channel][slave].Otype->get() != BX_ATA_DEVICE_CDROM) { + } else if (SIM->get_param_enum("type", base)->get() != BX_ATA_DEVICE_CDROM) { PARSE_WARN(("%s: ataX-master/slave: type should be specified", context)); } } @@ -3198,64 +3086,64 @@ int bx_write_floppy_options (FILE *fp, int drive) return 0; } -int bx_write_ata_options (FILE *fp, Bit8u channel, bx_ata_options *opt) +int bx_write_ata_options (FILE *fp, Bit8u channel, bx_list_c *base) { - fprintf (fp, "ata%d: enabled=%d", channel, opt->Opresent->get()); + fprintf(fp, "ata%d: enabled=%d", channel, SIM->get_param_bool("enabled", base)->get()); - if (opt->Opresent->get()) { - fprintf (fp, ", ioaddr1=0x%x, ioaddr2=0x%x, irq=%d", opt->Oioaddr1->get(), - opt->Oioaddr2->get(), opt->Oirq->get()); + if (SIM->get_param_bool("enabled", base)->get()) { + fprintf(fp, ", ioaddr1=0x%x, ioaddr2=0x%x, irq=%d", SIM->get_param_num("ioaddr1", base)->get(), + SIM->get_param_num("ioaddr2", base)->get(), SIM->get_param_num("irq", base)->get()); } - fprintf (fp, "\n"); + fprintf(fp, "\n"); return 0; } -int bx_write_atadevice_options (FILE *fp, Bit8u channel, Bit8u drive, bx_atadevice_options *opt) +int bx_write_atadevice_options (FILE *fp, Bit8u channel, Bit8u drive, bx_list_c *base) { - if (opt->Opresent->get()) { - fprintf (fp, "ata%d-%s: ", channel, drive==0?"master":"slave"); + if (SIM->get_param_bool("present", base)->get()) { + fprintf(fp, "ata%d-%s: ", channel, drive==0?"master":"slave"); - if (opt->Otype->get() == BX_ATA_DEVICE_DISK) { - fprintf (fp, "type=disk"); + if (SIM->get_param_enum("type", base)->get() == BX_ATA_DEVICE_DISK) { + fprintf(fp, "type=disk"); - switch(opt->Omode->get()) { + switch (SIM->get_param_enum("mode", base)->get()) { case BX_ATA_MODE_FLAT: - fprintf (fp, ", mode=flat"); + fprintf(fp, ", mode=flat"); break; case BX_ATA_MODE_CONCAT: - fprintf (fp, ", mode=concat"); + fprintf(fp, ", mode=concat"); break; case BX_ATA_MODE_EXTDISKSIM: - fprintf (fp, ", mode=external"); + fprintf(fp, ", mode=external"); break; case BX_ATA_MODE_DLL_HD: - fprintf (fp, ", mode=dll"); + fprintf(fp, ", mode=dll"); break; case BX_ATA_MODE_SPARSE: - fprintf (fp, ", mode=sparse"); + fprintf(fp, ", mode=sparse"); break; case BX_ATA_MODE_VMWARE3: - fprintf (fp, ", mode=vmware3"); + fprintf(fp, ", mode=vmware3"); break; case BX_ATA_MODE_UNDOABLE: - fprintf (fp, ", mode=undoable"); + fprintf(fp, ", mode=undoable"); break; case BX_ATA_MODE_GROWING: - fprintf (fp, ", mode=growing"); + fprintf(fp, ", mode=growing"); break; case BX_ATA_MODE_VOLATILE: - fprintf (fp, ", mode=volatile"); + fprintf(fp, ", mode=volatile"); break; // case BX_ATA_MODE_Z_UNDOABLE: -// fprintf (fp, ", mode=z-undoable"); +// fprintf(fp, ", mode=z-undoable"); // break; // case BX_ATA_MODE_Z_VOLATILE: -// fprintf (fp, ", mode=z-volatile"); +// fprintf(fp, ", mode=z-volatile"); // break; } - switch(opt->Otranslation->get()) { + switch(SIM->get_param_enum("translation", base)->get()) { case BX_ATA_TRANSLATION_NONE: fprintf (fp, ", translation=none"); break; @@ -3274,21 +3162,22 @@ int bx_write_atadevice_options (FILE *fp, Bit8u channel, Bit8u drive, bx_atadevi } fprintf (fp, ", path=\"%s\", cylinders=%d, heads=%d, spt=%d", - opt->Opath->getptr(), - opt->Ocylinders->get(), opt->Oheads->get(), opt->Ospt->get()); + SIM->get_param_string("path", base)->getptr(), + SIM->get_param_num("cylinders", base)->get(), + SIM->get_param_num("heads", base)->get(), + SIM->get_param_num("spt", base)->get()); - if (opt->Ojournal->getptr() != NULL) - if ( strcmp(opt->Ojournal->getptr(), "") != 0) - fprintf (fp, ", journal=\"%s\"", opt->Ojournal->getptr()); + if (SIM->get_param_string("journal", base)->getptr() != NULL) + if (strcmp(SIM->get_param_string("journal", base)->getptr(), "") != 0) + fprintf (fp, ", journal=\"%s\"", SIM->get_param_string("journal", base)->getptr()); - } - else if (opt->Otype->get() == BX_ATA_DEVICE_CDROM) { + } else if (SIM->get_param_enum("type", base)->get() == BX_ATA_DEVICE_CDROM) { fprintf (fp, "type=cdrom, path=\"%s\", status=%s", - opt->Opath->getptr(), - opt->Ostatus->get ()==BX_EJECTED ? "ejected" : "inserted"); - } + SIM->get_param_string("path", base)->getptr(), + SIM->get_param_enum("status", base)->get()==BX_EJECTED ? "ejected" : "inserted"); + } - switch(opt->Obiosdetect->get()) { + switch(SIM->get_param_enum("biosdetect", base)->get()) { case BX_ATA_BIOSDETECT_NONE: fprintf (fp, ", biosdetect=none"); break; @@ -3299,8 +3188,8 @@ int bx_write_atadevice_options (FILE *fp, Bit8u channel, Bit8u drive, bx_atadevi fprintf (fp, ", biosdetect=auto"); break; } - if (strlen(opt->Omodel->getptr())>0) { - fprintf (fp, ", model=\"%s\"", opt->Omodel->getptr()); + if (SIM->get_param_string("model", base)->getptr()>0) { + fprintf (fp, ", model=\"%s\"", SIM->get_param_string("model", base)->getptr()); } fprintf (fp, "\n"); @@ -3493,10 +3382,11 @@ int bx_write_keyboard_options(FILE *fp) // 0: written ok // -1: failed // -2: already exists, and overwrite was off -int bx_write_configuration (char *rc, int overwrite) +int bx_write_configuration(char *rc, int overwrite) { int i; char *strptr, tmppath[80], tmpaddr[80], tmpdev[80]; + bx_list_c *base; BX_INFO(("write configuration to %s\n", rc)); // check if it exists. If so, only proceed if overwrite is set. @@ -3515,8 +3405,8 @@ int bx_write_configuration (char *rc, int overwrite) if (strlen(strptr) > 0) fprintf(fp, ", options=\"%s\"\n", strptr); else - fprintf (fp, "\n"); - fprintf (fp, "megs: %d\n", SIM->get_param_num(BXPN_MEM_SIZE)->get()); + fprintf(fp, "\n"); + fprintf(fp, "megs: %d\n", SIM->get_param_num(BXPN_MEM_SIZE)->get()); strptr = SIM->get_param_string(BXPN_ROM_PATH)->getptr(); if (strlen(strptr) > 0) fprintf(fp, "romimage: file=\"%s\", address=0x%05x\n", strptr, (unsigned int)SIM->get_param_num(BXPN_ROM_ADDRESS)->get()); @@ -3541,9 +3431,11 @@ int bx_write_configuration (char *rc, int overwrite) bx_write_floppy_options(fp, 0); bx_write_floppy_options(fp, 1); for (Bit8u channel=0; channelget_param(tmppath); + bx_write_ata_options(fp, channel, (bx_list_c*) SIM->get_param("resources", base)); + bx_write_atadevice_options(fp, channel, 0, (bx_list_c*) SIM->get_param("master", base)); + bx_write_atadevice_options(fp, channel, 1, (bx_list_c*) SIM->get_param("slave", base)); } for (i=0; iget_param_string(tmpdev)->getptr(); if (strlen(strptr) > 0) { - fprintf (fp, ", slot%d=%s", i+1, strptr); + fprintf(fp, ", slot%d=%s", i+1, strptr); } } } - fprintf (fp, "\n"); + fprintf(fp, "\n"); if (SIM->get_param_num(BXPN_PCIDEV_VENDOR)->get() != 0xffff) { fprintf(fp, "pcidev: vendor=0x%04x, device=0x%04x\n", SIM->get_param_num(BXPN_PCIDEV_VENDOR)->get(), SIM->get_param_num(BXPN_PCIDEV_DEVICE)->get()); } - bx_write_usb_options (fp, &bx_options.usb[0], 1); - bx_write_sb16_options (fp, &bx_options.sb16); - fprintf (fp, "vga_update_interval: %u\n", SIM->get_param_num(BXPN_VGA_UPDATE_INTERVAL)->get()); - fprintf (fp, "vga: extension=%s\n", SIM->get_param_string(BXPN_VGA_EXTENSION)->getptr()); + bx_write_usb_options(fp, &bx_options.usb[0], 1); + bx_write_sb16_options(fp, &bx_options.sb16); + fprintf(fp, "vga_update_interval: %u\n", SIM->get_param_num(BXPN_VGA_UPDATE_INTERVAL)->get()); + fprintf(fp, "vga: extension=%s\n", SIM->get_param_string(BXPN_VGA_EXTENSION)->getptr()); #if BX_SUPPORT_SMP - fprintf (fp, "cpu: count=%u:%u:%u, ips=%u, reset_on_triple_fault=%d\n", + fprintf(fp, "cpu: count=%u:%u:%u, ips=%u, reset_on_triple_fault=%d\n", SIM->get_param_num(BXPN_CPU_NPROCESSORS)->get(), SIM->get_param_num(BXPN_CPU_NCORES)->get(), SIM->get_param_num(BXPN_CPU_NTHREADS)->get(), SIM->get_param_num(BXPN_IPS)->get(), SIM->get_param_bool(BXPN_RESET_ON_TRIPLE_FAULT)->get()); #else - fprintf (fp, "cpu: count=1, ips=%u, reset_on_triple_fault=%d\n", + fprintf(fp, "cpu: count=1, ips=%u, reset_on_triple_fault=%d\n", SIM->get_param_num(BXPN_IPS)->get(), SIM->get_param_bool(BXPN_RESET_ON_TRIPLE_FAULT)->get()); #endif - fprintf (fp, "text_snapshot_check: %d\n", bx_options.Otext_snapshot_check->get()); - fprintf (fp, "private_colormap: enabled=%d\n", SIM->get_param_bool(BXPN_PRIVATE_COLORMAP)->get()); + fprintf(fp, "text_snapshot_check: %d\n", bx_options.Otext_snapshot_check->get()); + fprintf(fp, "private_colormap: enabled=%d\n", SIM->get_param_bool(BXPN_PRIVATE_COLORMAP)->get()); #if BX_WITH_AMIGAOS - fprintf (fp, "fullscreen: enabled=%d\n", SIM->get_param_bool(BXPN_FULLSCREEN)->get()); - fprintf (fp, "screenmode: name=\"%s\"\n", SIM->get_param_string(BXPN_SCREENMODE)->getptr()); + fprintf(fp, "fullscreen: enabled=%d\n", SIM->get_param_bool(BXPN_FULLSCREEN)->get()); + fprintf(fp, "screenmode: name=\"%s\"\n", SIM->get_param_string(BXPN_SCREENMODE)->getptr()); #endif bx_write_clock_cmos_options(fp); bx_write_ne2k_options(fp, &bx_options.ne2k); bx_write_pnic_options(fp, &bx_options.pnic); bx_write_loader_options(fp); - bx_write_log_options (fp, &bx_options.log); + bx_write_log_options(fp, &bx_options.log); bx_write_keyboard_options(fp); fprintf(fp, "mouse: enabled=%d, type=%s\n", SIM->get_param_bool(BXPN_MOUSE_ENABLED)->get(), SIM->get_param_enum(BXPN_MOUSE_TYPE)->get_selected()); - fclose (fp); + fclose(fp); return 0; } diff --git a/bochs/gui/siminterface.cc b/bochs/gui/siminterface.cc index 7ecbfa175..1b753e372 100644 --- a/bochs/gui/siminterface.cc +++ b/bochs/gui/siminterface.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: siminterface.cc,v 1.120 2006-02-24 22:35:46 vruppert Exp $ +// $Id: siminterface.cc,v 1.121 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // See siminterface.h for description of the siminterface concept. @@ -61,10 +61,10 @@ public: virtual bx_param_enum_c *get_param_enum (bx_id id); // new param methods virtual bx_param_c *get_param(const char *pname, bx_param_c *base=NULL); - virtual bx_param_num_c *get_param_num(const char *pname); - virtual bx_param_string_c *get_param_string(const char *pname); - virtual bx_param_bool_c *get_param_bool(const char *pname); - virtual bx_param_enum_c *get_param_enum(const char *pname); + virtual bx_param_num_c *get_param_num(const char *pname, bx_param_c *base=NULL); + virtual bx_param_string_c *get_param_string(const char *pname, bx_param_c *base=NULL); + virtual bx_param_bool_c *get_param_bool(const char *pname, bx_param_c *base=NULL); + virtual bx_param_enum_c *get_param_enum(const char *pname, bx_param_c *base=NULL); virtual unsigned gen_param_id(); virtual int get_n_log_modules (); virtual char *get_prefix (int mod); @@ -90,7 +90,7 @@ public: virtual int set_log_prefix (char *prefix); virtual int get_debugger_log_file (char *path, int len); virtual int set_debugger_log_file (char *path); - virtual int get_cdrom_options (int drive, bx_atadevice_options *out, int *device = NULL); + virtual int get_cdrom_options(int drive, bx_list_c **out, int *device = NULL); virtual void set_notify_callback (bxevent_handler func, void *arg); virtual void get_notify_callback (bxevent_handler *func, void **arg); virtual BxEvent* sim_to_ci_event (BxEvent *event); @@ -112,12 +112,12 @@ public: bx_gui->handle_events (); } // find first hard drive or cdrom - bx_param_c *get_first_atadevice (Bit32u search_type); - bx_param_c *get_first_cdrom () { - return get_first_atadevice (BX_ATA_DEVICE_CDROM); + bx_param_c *get_first_atadevice(Bit32u search_type); + bx_param_c *get_first_cdrom() { + return get_first_atadevice(BX_ATA_DEVICE_CDROM); } - bx_param_c *get_first_hd () { - return get_first_atadevice (BX_ATA_DEVICE_DISK); + bx_param_c *get_first_hd() { + return get_first_atadevice(BX_ATA_DEVICE_DISK); } #if BX_DEBUGGER virtual void debug_break (); @@ -195,14 +195,14 @@ bx_param_c *find_param (const char *full_pname, const char *rest_of_pname, bx_pa } bx_param_c * -bx_real_sim_c::get_param (const char *pname, bx_param_c *base) +bx_real_sim_c::get_param(const char *pname, bx_param_c *base) { if (base == NULL) base = root_param; // to access top level object, look for parameter "." if (pname[0] == '.' && pname[1] == 0) return base; - return find_param (pname, pname, base); + return find_param(pname, pname, base); } bx_param_num_c * @@ -220,16 +220,16 @@ bx_real_sim_c::get_param_num (bx_id id) { } bx_param_num_c * -bx_real_sim_c::get_param_num (const char *pname) { - bx_param_c *generic = get_param(pname); +bx_real_sim_c::get_param_num (const char *pname, bx_param_c *base) { + bx_param_c *generic = get_param(pname, base); if (generic==NULL) { - BX_PANIC (("get_param_num(%s) could not find a parameter", pname)); + BX_PANIC(("get_param_num(%s) could not find a parameter", pname)); return NULL; } - int type = generic->get_type (); + int type = generic->get_type(); if (type == BXT_PARAM_NUM || type == BXT_PARAM_BOOL || type == BXT_PARAM_ENUM) return (bx_param_num_c *)generic; - BX_PANIC (("get_param_num(%s) could not find an integer parameter with that name", pname)); + BX_PANIC(("get_param_num(%s) could not find an integer parameter with that name", pname)); return NULL; } @@ -247,15 +247,15 @@ bx_real_sim_c::get_param_string (bx_id id) { } bx_param_string_c * -bx_real_sim_c::get_param_string (const char *pname) { - bx_param_c *generic = get_param(pname); +bx_real_sim_c::get_param_string(const char *pname, bx_param_c *base) { + bx_param_c *generic = get_param(pname, base); if (generic==NULL) { BX_PANIC (("get_param_string(%s) could not find a parameter", pname)); return NULL; } - if (generic->get_type () == BXT_PARAM_STRING) + if (generic->get_type() == BXT_PARAM_STRING) return (bx_param_string_c *)generic; - BX_PANIC (("get_param_string(%s) could not find an integer parameter with that name", pname)); + BX_PANIC(("get_param_string(%s) could not find an integer parameter with that name", pname)); return NULL; } @@ -273,15 +273,15 @@ bx_real_sim_c::get_param_bool (bx_id id) { } bx_param_bool_c * -bx_real_sim_c::get_param_bool (const char *pname) { - bx_param_c *generic = get_param(pname); +bx_real_sim_c::get_param_bool(const char *pname, bx_param_c *base) { + bx_param_c *generic = get_param(pname, base); if (generic==NULL) { - BX_PANIC (("get_param_bool(%s) could not find a parameter", pname)); + BX_PANIC(("get_param_bool(%s) could not find a parameter", pname)); return NULL; } if (generic->get_type () == BXT_PARAM_BOOL) return (bx_param_bool_c *)generic; - BX_PANIC (("get_param_bool(%s) could not find a bool parameter with that name", pname)); + BX_PANIC(("get_param_bool(%s) could not find a bool parameter with that name", pname)); return NULL; } @@ -299,15 +299,15 @@ bx_real_sim_c::get_param_enum (bx_id id) { } bx_param_enum_c * -bx_real_sim_c::get_param_enum (const char *pname) { - bx_param_c *generic = get_param(pname); +bx_real_sim_c::get_param_enum(const char *pname, bx_param_c *base) { + bx_param_c *generic = get_param(pname, base); if (generic==NULL) { - BX_PANIC (("get_param_enum(%s) could not find a parameter", pname)); + BX_PANIC(("get_param_enum(%s) could not find a parameter", pname)); return NULL; } - if (generic->get_type () == BXT_PARAM_ENUM) + if (generic->get_type() == BXT_PARAM_ENUM) return (bx_param_enum_c *)generic; - BX_PANIC (("get_param_enum(%s) could not find a enum parameter with that name", pname)); + BX_PANIC(("get_param_enum(%s) could not find a enum parameter with that name", pname)); return NULL; } @@ -445,7 +445,6 @@ bx_real_sim_c::quit_sim (int code) { BX_INFO (("quit_sim called with exit code %d", code)); exit_code = code; // use longjmp to quit cleanly, no matter where in the stack we are. - //fprintf (stderr, "using longjmp() to jump directly to the quit context!\n"); if (quit_context != NULL) { longjmp (*quit_context, 1); BX_PANIC (("in bx_real_sim_c::quit_sim, longjmp should never return")); @@ -534,20 +533,26 @@ bx_real_sim_c::set_debugger_log_file (char *path) } int -bx_real_sim_c::get_cdrom_options (int level, bx_atadevice_options *out, int *where) +bx_real_sim_c::get_cdrom_options(int level, bx_list_c **out, int *where) { + char pname[80]; + bx_list_c *devlist; + for (Bit8u channel=0; channelget() == BX_ATA_DEVICE_CDROM) { + sprintf(pname, "ata.%d.%s", channel, (device==0)?"master":"slave"); + devlist = (bx_list_c*) SIM->get_param(pname); + if (SIM->get_param_enum("type", devlist)->get() == BX_ATA_DEVICE_CDROM) { if (level==0) { - *out = bx_options.atadevice[channel][device]; - if (where != NULL) *where=(channel*2)+device; + *out = devlist; + if (where != NULL) *where = (channel * 2) + device; return 1; - } - else level--; - } + } else { + level--; + } } } + } return 0; } @@ -772,15 +777,20 @@ void bx_real_sim_c::refresh_ci () { } bx_param_c * -bx_real_sim_c::get_first_atadevice (Bit32u search_type) { +bx_real_sim_c::get_first_atadevice(Bit32u search_type) { + char pname[80]; for (int channel=0; channelget ()) + sprintf(pname, "ata.%d.resources.enabled", channel); + if (!SIM->get_param_bool(pname)->get()) continue; for (int slave=0; slave<2; slave++) { - Bit32u present = bx_options.atadevice[channel][slave].Opresent->get (); - Bit32u type = bx_options.atadevice[channel][slave].Otype->get (); + sprintf(pname, "ata.%d.%s.present", channel, (slave==0)?"master":"slave"); + Bit32u present = SIM->get_param_bool(pname)->get(); + sprintf(pname, "ata.%d.%s.type", channel, (slave==0)?"master":"slave"); + Bit32u type = SIM->get_param_enum(pname)->get(); if (present && (type == search_type)) { - return bx_options.atadevice[channel][slave].Omenu; + sprintf(pname, "ata.%d.%s", channel, (slave==0)?"master":"slave"); + return SIM->get_param(pname); } } } @@ -1042,9 +1052,9 @@ bx_param_num_c::set_enable_handler (param_enable_handler handler) this->enable_handler = handler; } -void bx_param_num_c::set_dependent_list (bx_list_c *l) { - dependent_list = l; - update_dependents (); +void bx_param_num_c::set_dependent_list(bx_list_c *l) { + dependent_list = l; + update_dependents(); } Bit64s @@ -1072,7 +1082,7 @@ bx_param_num_c::set (Bit64s newval) } if ((val.number < min || val.number > max) && (Bit64u)max != BX_MAX_BIT64U) BX_PANIC (("numerical parameter '%s' was set to " FMT_LL "d, which is out of range " FMT_LL "d to " FMT_LL "d", get_name (), val.number, min, max)); - if (dependent_list != NULL) update_dependents (); + if (dependent_list != NULL) update_dependents(); } void bx_param_num_c::set_range (Bit64u min, Bit64u max) @@ -1085,14 +1095,14 @@ void bx_param_num_c::set_initial_val (Bit64s initial_val) { this->val.number = this->initial_val = initial_val; } -void bx_param_num_c::update_dependents () +void bx_param_num_c::update_dependents() { if (dependent_list) { int en = val.number && enabled; - for (int i=0; iget_size (); i++) { - bx_param_c *param = dependent_list->get (i); + for (int i=0; iget_size(); i++) { + bx_param_c *param = dependent_list->get(i); if (param != this) - param->set_enabled (en); + param->set_enabled(en); } } } @@ -1573,7 +1583,7 @@ void bx_param_string_c::set_initial_val (char *buf) { set (initial_val); } -bx_list_c::bx_list_c (bx_id id, int maxsize) +bx_list_c::bx_list_c(bx_id id, int maxsize) : bx_param_c (id, "list", "") { set_type(BXT_LIST); @@ -1584,8 +1594,8 @@ bx_list_c::bx_list_c (bx_id id, int maxsize) init(""); } -bx_list_c::bx_list_c (bx_id id, char *name, char *title, int maxsize) - : bx_param_c (id, name, NULL) +bx_list_c::bx_list_c(bx_id id, char *name, char *title, int maxsize) + : bx_param_c(id, name, NULL) { set_type(BXT_LIST); this->size = 0; @@ -1595,9 +1605,9 @@ bx_list_c::bx_list_c (bx_id id, char *name, char *title, int maxsize) init(title); } -bx_list_c::bx_list_c (bx_param_c *parent, char *name, char *title, +bx_list_c::bx_list_c(bx_param_c *parent, char *name, char *title, int maxsize) - : bx_param_c (BXP_NULL, name, NULL) + : bx_param_c((bx_id)SIM->gen_param_id(), name, NULL) { set_type (BXT_LIST); this->size = 0; @@ -1607,12 +1617,12 @@ bx_list_c::bx_list_c (bx_param_c *parent, char *name, char *title, if (parent) { BX_ASSERT(parent->get_type() == BXT_LIST); this->parent = (bx_list_c *)parent; - this->parent->add (this); + this->parent->add(this); } init(title); } -bx_list_c::bx_list_c (bx_id id, char *name, char *title, bx_param_c **init_list) +bx_list_c::bx_list_c(bx_id id, char *name, char *title, bx_param_c **init_list) : bx_param_c (id, name, NULL) { set_type(BXT_LIST); @@ -1651,68 +1661,63 @@ bx_list_c::~bx_list_c() } } -void -bx_list_c::init(const char *list_title) +void bx_list_c::init(const char *list_title) { // the title defaults to the name - this->title = new bx_param_string_c (BXP_NULL, + this->title = new bx_param_string_c(BXP_NULL, "title of list", "", get_name(), 80); if ((list_title != NULL) && (strlen(list_title) > 0)) { this->title->set(strdup(list_title)); } - this->options = new bx_param_num_c (BXP_NULL, + this->options = new bx_param_num_c(BXP_NULL, "list_option", "", 0, BX_MAX_BIT64S, 0); - this->choice = new bx_param_num_c (BXP_NULL, + this->choice = new bx_param_num_c(BXP_NULL, "list_choice", "", 0, BX_MAX_BIT64S, 1); } -bx_list_c * -bx_list_c::clone () +bx_list_c* bx_list_c::clone() { - bx_list_c *newlist = new bx_list_c (get_parent(), name, description, maxsize); - for (int i=0; iadd (get(i)); - newlist->set_options (get_options ()); + bx_list_c *newlist = new bx_list_c(NULL, name, description, maxsize); + for (int i=0; iadd(get(i)); + newlist->set_options(get_options()); return newlist; } -void -bx_list_c::add (bx_param_c *param) +void bx_list_c::add(bx_param_c *param) { if (this->size >= this->maxsize) - BX_PANIC (("add param %u to bx_list_c id=%u: list capacity exceeded", param->get_id (), get_id ())); + BX_PANIC(("add param '%s' to bx_list_c '%s': list capacity exceeded", + param->get_name(), get_name())); list[size] = param; size++; } -bx_param_c * -bx_list_c::get (int index) +bx_param_c* bx_list_c::get(int index) { - BX_ASSERT (index >= 0 && index < size); + BX_ASSERT(index >= 0 && index < size); return list[index]; } -bx_param_c * -bx_list_c::get_by_name (const char *name) +bx_param_c* bx_list_c::get_by_name(const char *name) { - int i, imax = get_size (); + int i, imax = get_size(); for (i=0; iget_name ())) { + if (0 == strcmp (name, p->get_name())) { return p; } } return NULL; } -void -bx_list_c::reset() +void bx_list_c::reset() { - int i, imax = get_size (); + int i, imax = get_size(); for (i=0; ireset(); } diff --git a/bochs/gui/siminterface.h b/bochs/gui/siminterface.h index 949a8ab9a..d7835a7dd 100644 --- a/bochs/gui/siminterface.h +++ b/bochs/gui/siminterface.h @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: siminterface.h,v 1.165 2006-02-24 22:35:46 vruppert Exp $ +// $Id: siminterface.h,v 1.166 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // Intro to siminterface by Bryce Denney: @@ -186,179 +186,32 @@ typedef enum { #define BXPN_FLOPPYB_PATH "floppy.1.path" #define BXPN_FLOPPYB_TYPE "floppy.1.type" #define BXPN_FLOPPYB_STATUS "floppy.1.status" +#define BXPN_ATA0_RES "ata.0.resources" +#define BXPN_ATA1_RES "ata.1.resources" +#define BXPN_ATA2_RES "ata.2.resources" +#define BXPN_ATA3_RES "ata.3.resources" +#define BXPN_ATA0_ENABLED "ata.0.resources.enabled" +#define BXPN_ATA1_ENABLED "ata.1.resources.enabled" +#define BXPN_ATA0_MASTER "ata.0.master" +#define BXPN_ATA1_MASTER "ata.1.master" +#define BXPN_ATA2_MASTER "ata.2.master" +#define BXPN_ATA3_MASTER "ata.3.master" +#define BXPN_ATA0_SLAVE "ata.0.slave" +#define BXPN_ATA1_SLAVE "ata.1.slave" +#define BXPN_ATA2_SLAVE "ata.2.slave" +#define BXPN_ATA3_SLAVE "ata.3.slave" // base value for generated new parameter id #define BXP_NEW_PARAM_ID 1001 +#define BXP_PARAMS_PER_ATA_DEVICE 12 + // list if parameter id values. The actual values are not important; // it's only important that they all be different from each other. typedef enum { BXP_NULL = 301, BXP_TEXT_SNAPSHOT_CHECK, - BXP_ATA0_MENU, - BXP_ATA1_MENU, - BXP_ATA2_MENU, - BXP_ATA3_MENU, -#define BXP_ATAx_MENU(i) (BXP_ATA0_MENU + (i)) - BXP_ATA0, - BXP_ATA1, - BXP_ATA2, - BXP_ATA3, -#define BXP_ATAx(i) (BXP_ATA0 + (i)) - BXP_ATA0_PRESENT, - BXP_ATA1_PRESENT, - BXP_ATA2_PRESENT, - BXP_ATA3_PRESENT, -#define BXP_ATAx_PRESENT(i) (BXP_ATA0_PRESENT + (i)) - BXP_ATA0_IOADDR1, - BXP_ATA1_IOADDR1, - BXP_ATA2_IOADDR1, - BXP_ATA3_IOADDR1, -#define BXP_ATAx_IOADDR1(i) (BXP_ATA0_IOADDR1 + (i)) - BXP_ATA0_IOADDR2, - BXP_ATA1_IOADDR2, - BXP_ATA2_IOADDR2, - BXP_ATA3_IOADDR2, -#define BXP_ATAx_IOADDR2(i) (BXP_ATA0_IOADDR2 + (i)) - BXP_ATA0_IRQ, - BXP_ATA1_IRQ, - BXP_ATA2_IRQ, - BXP_ATA3_IRQ, -#define BXP_ATAx_IRQ(i) (BXP_ATA0_IRQ + (i)) - - BXP_ATA0_MASTER, - BXP_ATA0_SLAVE, - BXP_ATA1_MASTER, - BXP_ATA1_SLAVE, - BXP_ATA2_MASTER, - BXP_ATA2_SLAVE, - BXP_ATA3_MASTER, - BXP_ATA3_SLAVE, -#define BXP_ATAx_DEVICE(i, s) (BXP_ATA0_MASTER + (2*(i)) + (s)) - -#define BXP_PARAMS_PER_ATA_DEVICE 12 - - BXP_ATA0_MASTER_PRESENT, - BXP_ATA0_SLAVE_PRESENT, - BXP_ATA1_MASTER_PRESENT, - BXP_ATA1_SLAVE_PRESENT, - BXP_ATA2_MASTER_PRESENT, - BXP_ATA2_SLAVE_PRESENT, - BXP_ATA3_MASTER_PRESENT, - BXP_ATA3_SLAVE_PRESENT, -#define BXP_ATAx_DEVICE_PRESENT(i, s) (BXP_ATA0_MASTER_PRESENT + (2*(i)) + (s)) - - BXP_ATA0_MASTER_TYPE, - BXP_ATA0_SLAVE_TYPE, - BXP_ATA1_MASTER_TYPE, - BXP_ATA1_SLAVE_TYPE, - BXP_ATA2_MASTER_TYPE, - BXP_ATA2_SLAVE_TYPE, - BXP_ATA3_MASTER_TYPE, - BXP_ATA3_SLAVE_TYPE, -#define BXP_ATAx_DEVICE_TYPE(i, s) (BXP_ATA0_MASTER_TYPE + (2*(i)) + (s)) - - BXP_ATA0_MASTER_MODE, - BXP_ATA0_SLAVE_MODE, - BXP_ATA1_MASTER_MODE, - BXP_ATA1_SLAVE_MODE, - BXP_ATA2_MASTER_MODE, - BXP_ATA2_SLAVE_MODE, - BXP_ATA3_MASTER_MODE, - BXP_ATA3_SLAVE_MODE, -#define BXP_ATAx_DEVICE_MODE(i, s) (BXP_ATA0_MASTER_MODE + (2*(i)) + (s)) - - BXP_ATA0_MASTER_PATH, - BXP_ATA0_SLAVE_PATH, - BXP_ATA1_MASTER_PATH, - BXP_ATA1_SLAVE_PATH, - BXP_ATA2_MASTER_PATH, - BXP_ATA2_SLAVE_PATH, - BXP_ATA3_MASTER_PATH, - BXP_ATA3_SLAVE_PATH, -#define BXP_ATAx_DEVICE_PATH(i, s) (BXP_ATA0_MASTER_PATH + (2*(i)) + (s)) - - BXP_ATA0_MASTER_CYLINDERS, - BXP_ATA0_SLAVE_CYLINDERS, - BXP_ATA1_MASTER_CYLINDERS, - BXP_ATA1_SLAVE_CYLINDERS, - BXP_ATA2_MASTER_CYLINDERS, - BXP_ATA2_SLAVE_CYLINDERS, - BXP_ATA3_MASTER_CYLINDERS, - BXP_ATA3_SLAVE_CYLINDERS, -#define BXP_ATAx_DEVICE_CYLINDERS(i, s) (BXP_ATA0_MASTER_CYLINDERS + (2*(i)) + (s)) - - BXP_ATA0_MASTER_HEADS, - BXP_ATA0_SLAVE_HEADS, - BXP_ATA1_MASTER_HEADS, - BXP_ATA1_SLAVE_HEADS, - BXP_ATA2_MASTER_HEADS, - BXP_ATA2_SLAVE_HEADS, - BXP_ATA3_MASTER_HEADS, - BXP_ATA3_SLAVE_HEADS, -#define BXP_ATAx_DEVICE_HEADS(i, s) (BXP_ATA0_MASTER_HEADS + (2*(i)) + (s)) - - BXP_ATA0_MASTER_SPT, - BXP_ATA0_SLAVE_SPT, - BXP_ATA1_MASTER_SPT, - BXP_ATA1_SLAVE_SPT, - BXP_ATA2_MASTER_SPT, - BXP_ATA2_SLAVE_SPT, - BXP_ATA3_MASTER_SPT, - BXP_ATA3_SLAVE_SPT, -#define BXP_ATAx_DEVICE_SPT(i, s) (BXP_ATA0_MASTER_SPT + (2*(i)) + (s)) - - BXP_ATA0_MASTER_STATUS, - BXP_ATA0_SLAVE_STATUS, - BXP_ATA1_MASTER_STATUS, - BXP_ATA1_SLAVE_STATUS, - BXP_ATA2_MASTER_STATUS, - BXP_ATA2_SLAVE_STATUS, - BXP_ATA3_MASTER_STATUS, - BXP_ATA3_SLAVE_STATUS, -#define BXP_ATAx_DEVICE_STATUS(i, s) (BXP_ATA0_MASTER_STATUS + (2*(i)) + (s)) - - BXP_ATA0_MASTER_MODEL, - BXP_ATA0_SLAVE_MODEL, - BXP_ATA1_MASTER_MODEL, - BXP_ATA1_SLAVE_MODEL, - BXP_ATA2_MASTER_MODEL, - BXP_ATA2_SLAVE_MODEL, - BXP_ATA3_MASTER_MODEL, - BXP_ATA3_SLAVE_MODEL, -#define BXP_ATAx_DEVICE_MODEL(i, s) (BXP_ATA0_MASTER_MODEL + (2*(i)) + (s)) - - BXP_ATA0_MASTER_BIOSDETECT, - BXP_ATA0_SLAVE_BIOSDETECT, - BXP_ATA1_MASTER_BIOSDETECT, - BXP_ATA1_SLAVE_BIOSDETECT, - BXP_ATA2_MASTER_BIOSDETECT, - BXP_ATA2_SLAVE_BIOSDETECT, - BXP_ATA3_MASTER_BIOSDETECT, - BXP_ATA3_SLAVE_BIOSDETECT, -#define BXP_ATAx_DEVICE_BIOSDETECT(i, s) (BXP_ATA0_MASTER_BIOSDETECT + (2*(i)) + (s)) - - BXP_ATA0_MASTER_TRANSLATION, - BXP_ATA0_SLAVE_TRANSLATION, - BXP_ATA1_MASTER_TRANSLATION, - BXP_ATA1_SLAVE_TRANSLATION, - BXP_ATA2_MASTER_TRANSLATION, - BXP_ATA2_SLAVE_TRANSLATION, - BXP_ATA3_MASTER_TRANSLATION, - BXP_ATA3_SLAVE_TRANSLATION, -#define BXP_ATAx_DEVICE_TRANSLATION(i, s) (BXP_ATA0_MASTER_TRANSLATION + (2*(i)) + (s)) - - BXP_ATA0_MASTER_JOURNAL, - BXP_ATA0_SLAVE_JOURNAL, - BXP_ATA1_MASTER_JOURNAL, - BXP_ATA1_SLAVE_JOURNAL, - BXP_ATA2_MASTER_JOURNAL, - BXP_ATA2_SLAVE_JOURNAL, - BXP_ATA3_MASTER_JOURNAL, - BXP_ATA3_SLAVE_JOURNAL, -#define BXP_ATAx_DEVICE_JOURNAL(i, s) (BXP_ATA0_MASTER_JOURNAL + (2*(i)) + (s)) - #define BXP_PARAMS_PER_SERIAL_PORT 3 BXP_COM1_ENABLED, BXP_COM1_MODE, @@ -1348,29 +1201,6 @@ BOCHSAPI extern int n_atadevice_translation_names; BOCHSAPI extern char *clock_sync_names[]; BOCHSAPI extern int clock_sync_n_names; -typedef struct { - bx_param_enum_c *Odevtype; - bx_param_string_c *Opath; - bx_param_enum_c *Otype; - bx_param_enum_c *Ostatus; -} bx_floppy_options; - -typedef struct { - bx_list_c *Omenu; - bx_param_bool_c *Opresent; - bx_param_enum_c *Otype; - bx_param_enum_c *Omode; - bx_param_string_c *Opath; - bx_param_string_c *Ojournal; - bx_param_num_c *Ocylinders; - bx_param_num_c *Oheads; - bx_param_num_c *Ospt; - bx_param_enum_c *Ostatus; - bx_param_string_c *Omodel; - bx_param_enum_c *Obiosdetect; - bx_param_enum_c *Otranslation; -} bx_atadevice_options; - typedef struct { bx_param_bool_c *Oenabled; bx_param_enum_c *Omode; @@ -1435,10 +1265,10 @@ public: virtual bx_param_enum_c *get_param_enum(bx_id id) {return NULL;} // new param methods virtual bx_param_c *get_param(const char *pname, bx_param_c *base=NULL) {return NULL;} - virtual bx_param_num_c *get_param_num(const char *pname) {return NULL;} - virtual bx_param_string_c *get_param_string(const char *pname) {return NULL;} - virtual bx_param_bool_c *get_param_bool(const char *pname) {return NULL;} - virtual bx_param_enum_c *get_param_enum(const char *pname) {return NULL;} + virtual bx_param_num_c *get_param_num(const char *pname, bx_param_c *base=NULL) {return NULL;} + virtual bx_param_string_c *get_param_string(const char *pname, bx_param_c *base=NULL) {return NULL;} + virtual bx_param_bool_c *get_param_bool(const char *pname, bx_param_c *base=NULL) {return NULL;} + virtual bx_param_enum_c *get_param_enum(const char *pname, bx_param_c *base=NULL) {return NULL;} virtual unsigned gen_param_id() {return 0;} virtual int get_n_log_modules() {return -1;} virtual char *get_prefix(int mod) {return 0;} @@ -1469,7 +1299,7 @@ public: virtual int set_log_prefix(char *prefix) {return -1;} virtual int get_debugger_log_file(char *path, int len) {return -1;} virtual int set_debugger_log_file(char *path) {return -1;} - virtual int get_cdrom_options(int drive, bx_atadevice_options *out, int *where = NULL) {return -1;} + virtual int get_cdrom_options(int drive, bx_list_c **out, int *where = NULL) {return -1;} // The CI calls set_notify_callback to register its event handler function. // This event handler function is called whenever the simulator needs to diff --git a/bochs/gui/textconfig.cc b/bochs/gui/textconfig.cc index eaf4a95b9..8ce59878b 100644 --- a/bochs/gui/textconfig.cc +++ b/bochs/gui/textconfig.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: textconfig.cc,v 1.40 2006-02-24 22:35:46 vruppert Exp $ +// $Id: textconfig.cc,v 1.41 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // This is code for a text-mode configuration interface. Note that this file @@ -314,64 +314,64 @@ static char *runtime_menu_prompt = assert (0); } while (0) #ifndef WIN32 -void build_runtime_options_prompt (char *format, char *buf, int size) +void build_runtime_options_prompt(char *format, char *buf, int size) { - bx_atadevice_options cdromop; + bx_list_c *floppyop; + bx_list_c *cdromop = NULL; + char pname[80]; char buffer[6][128]; - char devtype[80], path[80], type[80], status[80]; + for (int i=0; i<2; i++) { - sprintf(devtype, "floppy.%d.devtype", i); - sprintf(path, "floppy.%d.path", i); - sprintf(type, "floppy.%d.type", i); - sprintf(status, "floppy.%d.status", i); - if (SIM->get_param_enum(devtype)->get() == BX_FLOPPY_NONE) + sprintf(pname, "floppy.%d", i); + floppyop = (bx_list_c*) SIM->get_param(pname); + if (SIM->get_param_enum("devtype", floppyop)->get() == BX_FLOPPY_NONE) strcpy(buffer[i], "(not present)"); else { - sprintf(buffer[i], "%s, size=%s, %s", SIM->get_param_string(path)->getptr(), - SIM->get_param_enum(type)->get_selected(), - SIM->get_param_enum(status)->get_selected()); - if (!SIM->get_param_string(path)->getptr()[0]) strcpy(buffer[i], "none"); + sprintf(buffer[i], "%s, size=%s, %s", SIM->get_param_string("path", floppyop)->getptr(), + SIM->get_param_enum("type", floppyop)->get_selected(), + SIM->get_param_enum("status", floppyop)->get_selected()); + if (!SIM->get_param_string("path", floppyop)->getptr()[0]) strcpy(buffer[i], "none"); } } // 4 cdroms supported at run time int device; for (Bit8u cdrom=0; cdrom<4; cdrom++) { - if (!SIM->get_cdrom_options (cdrom, &cdromop, &device) || !cdromop.Opresent->get ()) + if (!SIM->get_cdrom_options(cdrom, &cdromop, &device) || !SIM->get_param_bool("present", cdromop)->get()) sprintf (buffer[2+cdrom], "(not present)"); else sprintf (buffer[2+cdrom], "(%s on ata%d) %s, %s", - device&1?"slave":"master", device/2, cdromop.Opath->getptr (), - (cdromop.Ostatus->get () == BX_INSERTED)? "inserted" : "ejected"); + device&1?"slave":"master", device/2, SIM->get_param_string("path", cdromop)->getptr(), + (SIM->get_param_enum("status", cdromop)->get () == BX_INSERTED)? "inserted" : "ejected"); } - snprintf (buf, size, format, buffer[0], buffer[1], buffer[2], - buffer[3], buffer[4], buffer[5]); + snprintf(buf, size, format, buffer[0], buffer[1], buffer[2], + buffer[3], buffer[4], buffer[5]); } #endif -int do_menu (bx_id id) { - bx_list_c *menu = (bx_list_c *)SIM->get_param (id); +int do_menu(bx_id id) { + bx_list_c *menu = (bx_list_c *)SIM->get_param(id); while (1) { - menu->get_choice()->set (0); - int status = menu->text_ask (stdin, stderr); + menu->get_choice()->set(0); + int status = menu->text_ask(stdin, stderr); if (status < 0) return status; bx_param_num_c *choice = menu->get_choice(); - if (choice->get () < 1) - return choice->get (); + if (choice->get() < 1) + return choice->get(); else { - int index = choice->get () - 1; // choosing 1 means list[0] - bx_param_c *chosen = menu->get (index); + int index = choice->get() - 1; // choosing 1 means list[0] + bx_param_c *chosen = menu->get(index); assert (chosen != NULL); - if (chosen->get_enabled ()) { - if (chosen->get_type () == BXT_LIST) { - if (chosen->get_id() != BXP_NULL) { + if (chosen->get_enabled()) { + if (chosen->get_type() == BXT_LIST) { + if (chosen->get_id() < BXP_NEW_PARAM_ID) { do_menu(chosen->get_id()); } else { - do_menu2(chosen->get_name(), menu); + do_menu2(chosen->get_name(), chosen->get_parent()); } } else { - chosen->text_ask (stdin, stderr); + chosen->text_ask(stdin, stderr); } } } @@ -393,7 +393,7 @@ int do_menu2(const char *pname, bx_param_c *base) { assert(chosen != NULL); if (chosen->get_enabled()) { if (chosen->get_type() == BXT_LIST) { - if (chosen->get_id() != BXP_NULL) { + if (chosen->get_id() < BXP_NEW_PARAM_ID) { do_menu(chosen->get_id()); } else { do_menu2(chosen->get_name(), menu); @@ -507,50 +507,54 @@ int bx_config_interface (int menu) } break; case BX_CI_RUNTIME: - bx_atadevice_options cdromop; + { + bx_list_c *cdromop = NULL; + char pname[80]; #ifdef WIN32 - choice = RuntimeOptionsDialog(); + choice = RuntimeOptionsDialog(); #else - char prompt[1024]; - build_runtime_options_prompt (runtime_menu_prompt, prompt, 1024); - if (ask_uint (prompt, 1, BX_CI_RT_QUIT, BX_CI_RT_CONT, &choice, 10) < 0) return -1; + char prompt[1024]; + build_runtime_options_prompt(runtime_menu_prompt, prompt, 1024); + if (ask_uint(prompt, 1, BX_CI_RT_QUIT, BX_CI_RT_CONT, &choice, 10) < 0) return -1; #endif - switch (choice) { - case BX_CI_RT_FLOPPYA: - if (SIM->get_param_enum(BXPN_FLOPPYA_DEVTYPE)->get() != BX_FLOPPY_NONE) do_menu2(BXPN_FLOPPYA, NULL); - break; - case BX_CI_RT_FLOPPYB: - if (SIM->get_param_enum(BXPN_FLOPPYA_DEVTYPE)->get() != BX_FLOPPY_NONE) do_menu2(BXPN_FLOPPYB, NULL); - break; - case BX_CI_RT_CDROM1: - case BX_CI_RT_CDROM2: - case BX_CI_RT_CDROM3: - case BX_CI_RT_CDROM4: - int device; - if (SIM->get_cdrom_options (choice - 3, &cdromop, &device) && cdromop.Opresent->get ()) { - // disable type selection - SIM->get_param((bx_id)(BXP_ATA0_MASTER_TYPE + device))->set_enabled(0); - SIM->get_param((bx_id)(BXP_ATA0_MASTER_MODEL + device))->set_enabled(0); - SIM->get_param((bx_id)(BXP_ATA0_MASTER_BIOSDETECT + device))->set_enabled(0); - do_menu ((bx_id)(BXP_ATA0_MASTER + device)); - } - break; - case BX_CI_RT_IPS: - // not implemented yet because I would have to mess with - // resetting timers and pits and everything on the fly. - // askparam (BXP_IPS); - break; - case BX_CI_RT_LOGOPTS1: bx_log_options (0); break; - case BX_CI_RT_LOGOPTS2: bx_log_options (1); break; - case BX_CI_RT_INST_TR: NOT_IMPLEMENTED (choice); break; - case BX_CI_RT_MISC: do_menu (BXP_MENU_RUNTIME); break; - case BX_CI_RT_CONT: fprintf (stderr, "Continuing simulation\n"); return 0; - case BX_CI_RT_QUIT: - fprintf (stderr, "You chose quit on the configuration interface.\n"); - bx_user_quit = 1; - SIM->quit_sim (1); - return -1; - default: fprintf (stderr, "Menu choice %d not implemented.\n", choice); + switch (choice) { + case BX_CI_RT_FLOPPYA: + if (SIM->get_param_enum(BXPN_FLOPPYA_DEVTYPE)->get() != BX_FLOPPY_NONE) do_menu2(BXPN_FLOPPYA, NULL); + break; + case BX_CI_RT_FLOPPYB: + if (SIM->get_param_enum(BXPN_FLOPPYB_DEVTYPE)->get() != BX_FLOPPY_NONE) do_menu2(BXPN_FLOPPYB, NULL); + break; + case BX_CI_RT_CDROM1: + case BX_CI_RT_CDROM2: + case BX_CI_RT_CDROM3: + case BX_CI_RT_CDROM4: + int device; + if (SIM->get_cdrom_options(choice - BX_CI_RT_CDROM1, &cdromop, &device) && SIM->get_param_bool("present", cdromop)->get()) { + // disable type selection + SIM->get_param("type", cdromop)->set_enabled(0); + SIM->get_param("model", cdromop)->set_enabled(0); + SIM->get_param("biosdetect", cdromop)->set_enabled(0); + cdromop->get_param_path(pname, 80); + do_menu2(pname, NULL); + } + break; + case BX_CI_RT_IPS: + // not implemented yet because I would have to mess with + // resetting timers and pits and everything on the fly. + // askparam (BXP_IPS); + break; + case BX_CI_RT_LOGOPTS1: bx_log_options (0); break; + case BX_CI_RT_LOGOPTS2: bx_log_options (1); break; + case BX_CI_RT_INST_TR: NOT_IMPLEMENTED (choice); break; + case BX_CI_RT_MISC: do_menu (BXP_MENU_RUNTIME); break; + case BX_CI_RT_CONT: fprintf (stderr, "Continuing simulation\n"); return 0; + case BX_CI_RT_QUIT: + fprintf (stderr, "You chose quit on the configuration interface.\n"); + bx_user_quit = 1; + SIM->quit_sim (1); + return -1; + default: fprintf (stderr, "Menu choice %d not implemented.\n", choice); + } } break; default: @@ -735,7 +739,6 @@ ask: } void bx_config_interface_init () { - //fprintf (stderr, "bx_config_interface_init()\n"); SIM->set_notify_callback (config_interface_notify_callback, NULL); } @@ -745,8 +748,6 @@ void bx_config_interface_init () { void bx_param_num_c::text_print (FILE *fp) { - //fprintf (fp, "number parameter, id=%u, name=%s\n", get_id (), get_name ()); - //fprintf (fp, "value=%u\n", get ()); if (get_long_format()) { fprintf(fp, get_long_format(), get()); } else { @@ -920,7 +921,6 @@ int parse_raw_bytes (char *dest, char *src, int destsize, char separator) if (*src == 0) break; // try to read a byte of hex if (sscanf (src, "%02x", &n) == 1) { - //printf ("found a byte %02x\n", n); dest[i] = n; src+=2; } else { @@ -963,18 +963,17 @@ bx_param_string_c::text_ask (FILE *fpin, FILE *fpout) } } -int -bx_list_c::text_ask (FILE *fpin, FILE *fpout) +int bx_list_c::text_ask(FILE *fpin, FILE *fpout) { bx_list_c *child; - char *my_title = title->getptr (); + char *my_title = title->getptr(); fprintf (fpout, "\n"); int i, imax = strlen (my_title); for (i=0; iget ()); + fprintf(fpout, "\n"); if (options->get () & SERIES_ASK) { for (int i=0; iget_enabled()) { @@ -1009,12 +1008,12 @@ bx_list_c::text_ask (FILE *fpin, FILE *fpout) } } fprintf (fpout, "\n"); - Bit32u n = choice->get (); - int min = (options->get () & SHOW_PARENT) ? 0 : 1; + Bit32u n = choice->get(); + int min = (options->get() & SHOW_PARENT) ? 0 : 1; int max = size; - int status = ask_uint ("Please choose one: [%d] ", min, max, n, &n, 10); + int status = ask_uint("Please choose one: [%d] ", min, max, n, &n, 10); if (status < 0) return status; - choice->set (n); + choice->set(n); } return 0; } @@ -1024,7 +1023,6 @@ static int ci_callback (void *userdata, ci_command_t command) switch (command) { case CI_START: - //fprintf (stderr, "textconfig.cc: start\n"); bx_config_interface_init (); if (SIM->get_param_enum(BXP_BOCHS_START)->get () == BX_QUICK_START) bx_config_interface (BX_CI_START_SIMULATION); @@ -1038,7 +1036,6 @@ static int ci_callback (void *userdata, ci_command_t command) bx_config_interface (BX_CI_RUNTIME); break; case CI_SHUTDOWN: - //fprintf (stderr, "textconfig.cc: shutdown\n"); break; } return 0; diff --git a/bochs/gui/win32dialog.cc b/bochs/gui/win32dialog.cc index 2d6c1a592..0995f51af 100644 --- a/bochs/gui/win32dialog.cc +++ b/bochs/gui/win32dialog.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: win32dialog.cc,v 1.35 2006-02-24 22:35:46 vruppert Exp $ +// $Id: win32dialog.cc,v 1.36 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// #include "config.h" @@ -246,7 +246,7 @@ static BOOL CALLBACK FloppyDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP static BOOL CALLBACK Cdrom1DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) { - static bx_atadevice_options cdromop; + static bx_list_c *cdromop; int device; static char origpath[MAX_PATH]; char path[MAX_PATH]; @@ -254,18 +254,18 @@ static BOOL CALLBACK Cdrom1DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP switch (msg) { case WM_INITDIALOG: SIM->get_cdrom_options(0, &cdromop, &device); - lstrcpy(origpath, cdromop.Opath->getptr()); + lstrcpy(origpath, SIM->get_param_string("path", cdromop)->getptr()); if (lstrlen(origpath) && lstrcmp(origpath, "none")) { SetWindowText(GetDlgItem(hDlg, IDCDROM1), origpath); } - if (cdromop.Ostatus->get() == BX_INSERTED) { + if (SIM->get_param_enum("status", cdromop)->get() == BX_INSERTED) { SendMessage(GetDlgItem(hDlg, IDSTATUS1), BM_SETCHECK, BST_CHECKED, 0); } return TRUE; break; case WM_CLOSE: - if (lstrcmp(cdromop.Opath->getptr(), origpath)) { - cdromop.Opath->set(origpath); + if (lstrcmp(SIM->get_param_string("path", cdromop)->getptr(), origpath)) { + SIM->get_param_string("path", cdromop)->set(origpath); } EndDialog(hDlg, -1); break; @@ -273,9 +273,9 @@ static BOOL CALLBACK Cdrom1DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP switch (LOWORD(wParam)) { case IDBROWSE1: GetDlgItemText(hDlg, IDCDROM1, path, MAX_PATH); - cdromop.Opath->set(path); - if (AskFilename(hDlg, (bx_param_filename_c *)cdromop.Opath, "iso") > 0) { - SetWindowText(GetDlgItem(hDlg, IDCDROM1), cdromop.Opath->getptr()); + SIM->get_param_string("path", cdromop)->set(path); + if (AskFilename(hDlg, (bx_param_filename_c *)SIM->get_param_string("path", cdromop), "iso") > 0) { + SetWindowText(GetDlgItem(hDlg, IDCDROM1), SIM->get_param_string("path", cdromop)->getptr()); SendMessage(GetDlgItem(hDlg, IDSTATUS1), BM_SETCHECK, BST_CHECKED, 0); } break; @@ -283,21 +283,21 @@ static BOOL CALLBACK Cdrom1DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP if (SendMessage(GetDlgItem(hDlg, IDSTATUS1), BM_GETCHECK, 0, 0) == BST_CHECKED) { GetDlgItemText(hDlg, IDCDROM1, path, MAX_PATH); if (lstrlen(path)) { - cdromop.Ostatus->set(BX_INSERTED); - if (lstrcmp(path, cdromop.Opath->getptr())) { - cdromop.Opath->set(path); + SIM->get_param_enum("status", cdromop)->set(BX_INSERTED); + if (lstrcmp(path, SIM->get_param_string("path", cdromop)->getptr())) { + SIM->get_param_string("path", cdromop)->set(path); } } else { - cdromop.Ostatus->set(BX_EJECTED); + SIM->get_param_enum("status", cdromop)->set(BX_EJECTED); } } else { - cdromop.Ostatus->set(BX_EJECTED); + SIM->get_param_enum("status", cdromop)->set(BX_EJECTED); } EndDialog(hDlg, 1); break; case IDCANCEL: - if (lstrcmp(cdromop.Opath->getptr(), origpath)) { - cdromop.Opath->set(origpath); + if (lstrcmp(SIM->get_param_string("path", cdromop)->getptr(), origpath)) { + SIM->get_param_string("path", cdromop)->set(origpath); } EndDialog(hDlg, -1); break; @@ -370,7 +370,7 @@ void RuntimeDlgSetAdvLogOpt(HWND hDlg) static BOOL CALLBACK RTCdromDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam) { static int devcount; - static bx_atadevice_options cdromop[4]; + static bx_list_c *cdromop[4]; static char origpath[4][MAX_PATH]; static BOOL changed; int device; @@ -387,17 +387,18 @@ static BOOL CALLBACK RTCdromDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM l // 4 cdroms supported at run time devcount = 1; for (cdrom=1; cdrom<4; cdrom++) { - if (!SIM->get_cdrom_options (cdrom, &cdromop[cdrom], &device) || !cdromop[cdrom].Opresent->get ()) { + if (!SIM->get_cdrom_options(cdrom, &cdromop[cdrom], &device) || + !SIM->get_param_bool("present", cdromop[cdrom])->get()) { EnableWindow(GetDlgItem(hDlg, IDLABEL1+cdrom), FALSE); EnableWindow(GetDlgItem(hDlg, IDCDROM1+cdrom), FALSE); EnableWindow(GetDlgItem(hDlg, IDBROWSE1+cdrom), FALSE); EnableWindow(GetDlgItem(hDlg, IDSTATUS1+cdrom), FALSE); } else { - lstrcpy(origpath[cdrom], cdromop[cdrom].Opath->getptr()); + lstrcpy(origpath[cdrom], SIM->get_param_string("path", cdromop[cdrom])->getptr()); if (lstrlen(origpath[cdrom]) && lstrcmp(origpath[cdrom], "none")) { SetWindowText(GetDlgItem(hDlg, IDCDROM1+cdrom), origpath[cdrom]); } - if (cdromop[cdrom].Ostatus->get() == BX_INSERTED) { + if (SIM->get_param_enum("status", cdromop[cdrom])->get() == BX_INSERTED) { SendMessage(GetDlgItem(hDlg, IDSTATUS1+cdrom), BM_SETCHECK, BST_CHECKED, 0); } devcount++; @@ -414,23 +415,23 @@ static BOOL CALLBACK RTCdromDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM l if (SendMessage(GetDlgItem(hDlg, IDSTATUS1+device), BM_GETCHECK, 0, 0) == BST_CHECKED) { GetDlgItemText(hDlg, IDCDROM1+device, path, MAX_PATH); if (lstrlen(path)) { - cdromop[device].Ostatus->set(BX_INSERTED); - if (lstrcmp(path, cdromop[device].Opath->getptr())) { - cdromop[device].Opath->set(path); + SIM->get_param_enum("status", cdromop[device])->set(BX_INSERTED); + if (lstrcmp(path, SIM->get_param_string("path", cdromop[device])->getptr())) { + SIM->get_param_string("path", cdromop[device])->set(path); } } else { - cdromop[device].Ostatus->set(BX_EJECTED); + SIM->get_param_enum("status", cdromop[device])->set(BX_EJECTED); } } else { - cdromop[device].Ostatus->set(BX_EJECTED); + SIM->get_param_enum("status", cdromop[device])->set(BX_EJECTED); } } changed = FALSE; } else { if (changed) { for (device=1; devicegetptr(), origpath[device])) { - cdromop[device].Opath->set(origpath[device]); + if (lstrcmp(SIM->get_param_string("path", cdromop[device])->getptr(), origpath[device])) { + SIM->get_param_string("path", cdromop[device])->set(origpath[device]); } } } @@ -462,9 +463,9 @@ static BOOL CALLBACK RTCdromDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM l case IDBROWSE4: device = LOWORD(wParam) - IDBROWSE1; GetDlgItemText(hDlg, IDCDROM1+device, path, MAX_PATH); - cdromop[device].Opath->set(path); - if (AskFilename(hDlg, (bx_param_filename_c *)cdromop[device].Opath, "iso") > 0) { - SetWindowText(GetDlgItem(hDlg, IDCDROM1+device), cdromop[device].Opath->getptr()); + SIM->get_param_string("path", cdromop[device])->set(path); + if (AskFilename(hDlg, (bx_param_filename_c *)SIM->get_param_string("path", cdromop[device]), "iso") > 0) { + SetWindowText(GetDlgItem(hDlg, IDCDROM1+device), SIM->get_param_string("path", cdromop[device])->getptr()); SendMessage(GetDlgItem(hDlg, IDSTATUS1+device), BM_SETCHECK, BST_CHECKED, 0); } break; diff --git a/bochs/gui/wxdialog.cc b/bochs/gui/wxdialog.cc index 55f4aa715..e871f4659 100644 --- a/bochs/gui/wxdialog.cc +++ b/bochs/gui/wxdialog.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////// -// $Id: wxdialog.cc,v 1.85 2006-02-24 12:05:24 vruppert Exp $ +// $Id: wxdialog.cc,v 1.86 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////// // Define BX_PLUGGABLE in files that can be compiled into plugins. For @@ -1448,114 +1448,112 @@ void ParamDialog::EnableParam(const char *pname, bool enabled) if (pstr->u.window) pstr->u.window->Enable(enabled); } +void ParamDialog::EnableParam(const char *pname, bx_list_c *base, bool enabled) +{ + int param_id = SIM->get_param(pname, base)->get_id(); + ParamStruct *pstr = (ParamStruct*) paramHash->Get(param_id); + if (!pstr) return; + if (pstr->label) pstr->label->Enable(enabled); + if (pstr->browseButton) pstr->browseButton->Enable(enabled); + if (pstr->u.window) pstr->u.window->Enable(enabled); +} + void ParamDialog::EnumChanged (ParamStruct *pstr) { wxLogDebug ("EnumChanged"); - int id = pstr->param->get_id (); char pname[512]; - pstr->param->get_param_path(pname, 512); - switch (id) { - case BXP_ATA0_MASTER_TYPE: - case BXP_ATA0_SLAVE_TYPE: - case BXP_ATA1_MASTER_TYPE: - case BXP_ATA1_SLAVE_TYPE: - case BXP_ATA2_MASTER_TYPE: - case BXP_ATA2_SLAVE_TYPE: - case BXP_ATA3_MASTER_TYPE: - case BXP_ATA3_SLAVE_TYPE: { - int delta = id - BXP_ATA0_MASTER_TYPE; - // find out if "present" checkbox is checked - bx_id present_id = (bx_id) (BXP_ATA0_MASTER_PRESENT+delta); - ParamStruct *present = (ParamStruct*) paramHash->Get (present_id); - wxASSERT (present && present->param->get_type () == BXT_PARAM_BOOL); - if (!present->u.checkbox->GetValue ()) - break; // device not enabled, leave it alone - if (!present->u.checkbox->IsEnabled ()) - break; // enable button for the device is not enabled - wxASSERT (pstr->param->get_type () == BXT_PARAM_ENUM); - int type = pstr->u.choice->GetSelection (); - if (type == BX_ATA_DEVICE_DISK) { - // enable cylinders, heads, spt - wxLogDebug ("enabling disk parameters"); - EnableParam (BXP_ATA0_MASTER_MODE+delta, 1); - EnableParam (BXP_ATA0_MASTER_CYLINDERS+delta, 1); - EnableParam (BXP_ATA0_MASTER_HEADS+delta, 1); - EnableParam (BXP_ATA0_MASTER_SPT+delta, 1); - EnableParam (BXP_ATA0_MASTER_STATUS+delta, 0); - EnableParam (BXP_ATA0_MASTER_TRANSLATION+delta, 1); + Bit8u channel, device; - bx_id mode_id = (bx_id) (BXP_ATA0_MASTER_MODE+delta); + bx_list_c *base = (bx_list_c*) pstr->param->get_parent(); + base->get_param_path(pname, 512); + if (!strncmp(pname, "ata.", 4)) { + channel = pname[4] - '0'; + if (!strcmp(base->get_name(), "master")) { + device = 0; + } else { + device = 1; + } + if (!strcmp(pstr->param->get_name(), "type")) { + // find out if "present" checkbox is checked + int present_id = SIM->get_param_bool("present", base)->get_id(); + ParamStruct *present = (ParamStruct*) paramHash->Get(present_id); + wxASSERT(present && present->param->get_type() == BXT_PARAM_BOOL); + if (!present->u.checkbox->GetValue()) + return; // device not enabled, leave it alone + if (!present->u.checkbox->IsEnabled()) + return; // enable button for the device is not enabled + wxASSERT(pstr->param->get_type() == BXT_PARAM_ENUM); + int type = pstr->u.choice->GetSelection(); + if (type == BX_ATA_DEVICE_DISK) { + // enable cylinders, heads, spt + wxLogDebug ("enabling disk parameters"); + EnableParam("mode", base, 1); + EnableParam("cylinders", base, 1); + EnableParam("heads", base, 1); + EnableParam("spt", base, 1); + EnableParam("status", base, 0); + EnableParam("translation", base, 1); + + int mode_id = SIM->get_param_enum("mode", base)->get_id(); ParamStruct *mode_param = (ParamStruct*) paramHash->Get(mode_id); int mode = BX_ATA_MODE_FLAT; if(mode_param) mode=mode_param->u.choice->GetSelection(); switch(mode) { case BX_ATA_MODE_UNDOABLE: case BX_ATA_MODE_VOLATILE: - EnableParam (BXP_ATA0_MASTER_JOURNAL+delta, 1); + EnableParam("journal", base, 1); break; default: - EnableParam (BXP_ATA0_MASTER_JOURNAL+delta, 0); + EnableParam("journal", base, 0); break; } } else { - // enable inserted - wxLogDebug ("enabling cdrom parameters"); - EnableParam (BXP_ATA0_MASTER_MODE+delta, 0); - EnableParam (BXP_ATA0_MASTER_CYLINDERS+delta, 0); - EnableParam (BXP_ATA0_MASTER_HEADS+delta, 0); - EnableParam (BXP_ATA0_MASTER_SPT+delta, 0); - EnableParam (BXP_ATA0_MASTER_STATUS+delta, 1); - EnableParam (BXP_ATA0_MASTER_JOURNAL+delta, 0); - EnableParam (BXP_ATA0_MASTER_TRANSLATION+delta, 0); + // enable inserted + wxLogDebug ("enabling cdrom parameters"); + EnableParam("mode", base, 0); + EnableParam("cylinders", base, 0); + EnableParam("heads", base, 0); + EnableParam("spt", base, 0); + EnableParam("status", base, 1); + EnableParam("translation", base, 0); + EnableParam("journal", base, 0); } - } - break; - case BXP_ATA0_MASTER_MODE: - case BXP_ATA0_SLAVE_MODE: - case BXP_ATA1_MASTER_MODE: - case BXP_ATA1_SLAVE_MODE: - case BXP_ATA2_MASTER_MODE: - case BXP_ATA2_SLAVE_MODE: - case BXP_ATA3_MASTER_MODE: - case BXP_ATA3_SLAVE_MODE: { - int delta = id - BXP_ATA0_MASTER_MODE; + } else if (!strcmp(pstr->param->get_name(), "mode")) { // find out if "present" checkbox is checked - bx_id present_id = (bx_id) (BXP_ATA0_MASTER_PRESENT+delta); - ParamStruct *present = (ParamStruct*) paramHash->Get (present_id); - wxASSERT (present && present->param->get_type () == BXT_PARAM_BOOL); + int present_id = SIM->get_param_bool("present", base)->get_id(); + ParamStruct *present = (ParamStruct*) paramHash->Get(present_id); + wxASSERT (present && present->param->get_type() == BXT_PARAM_BOOL); if (!present->u.checkbox->GetValue ()) - break; // device not enabled, leave it alone + return; // device not enabled, leave it alone if (!present->u.checkbox->IsEnabled ()) - break; // enable button for the device is not enabled - wxASSERT (pstr->param->get_type () == BXT_PARAM_ENUM); - int mode = pstr->u.choice->GetSelection (); + return; // enable button for the device is not enabled + wxASSERT(pstr->param->get_type() == BXT_PARAM_ENUM); + int mode = pstr->u.choice->GetSelection(); switch(mode) { case BX_ATA_MODE_UNDOABLE: case BX_ATA_MODE_VOLATILE: - EnableParam (BXP_ATA0_MASTER_JOURNAL+delta, 1); + EnableParam("journal", base, 1); break; default: - EnableParam (BXP_ATA0_MASTER_JOURNAL+delta, 0); + EnableParam("journal", base, 0); break; - } - } - break; - default: { - if (!strcmp(pname, BXPN_LOAD32BITOS_WHICH)) { - int os = pstr->u.choice->GetSelection(); - if (os != Load32bitOSNone) { - EnableParam(BXPN_LOAD32BITOS_PATH, 1); - EnableParam(BXPN_LOAD32BITOS_IOLOG, 1); - EnableParam(BXPN_LOAD32BITOS_INITRD, 1); - } else { - EnableParam(BXPN_LOAD32BITOS_PATH, 0); - EnableParam(BXPN_LOAD32BITOS_IOLOG, 0); - EnableParam(BXPN_LOAD32BITOS_INITRD, 0); - } } } - + } else { + pstr->param->get_param_path(pname, 512); + if (!strcmp(pname, BXPN_LOAD32BITOS_WHICH)) { + int os = pstr->u.choice->GetSelection(); + if (os != Load32bitOSNone) { + EnableParam(BXPN_LOAD32BITOS_PATH, 1); + EnableParam(BXPN_LOAD32BITOS_IOLOG, 1); + EnableParam(BXPN_LOAD32BITOS_INITRD, 1); + } else { + EnableParam(BXPN_LOAD32BITOS_PATH, 0); + EnableParam(BXPN_LOAD32BITOS_IOLOG, 0); + EnableParam(BXPN_LOAD32BITOS_INITRD, 0); + } + } } } diff --git a/bochs/gui/wxdialog.h b/bochs/gui/wxdialog.h index 8ed044f13..9b5416808 100644 --- a/bochs/gui/wxdialog.h +++ b/bochs/gui/wxdialog.h @@ -1,5 +1,5 @@ //////////////////////////////////////////////////////////////////// -// $Id: wxdialog.h,v 1.58 2006-02-23 22:48:57 vruppert Exp $ +// $Id: wxdialog.h,v 1.59 2006-02-26 19:11:20 vruppert Exp $ //////////////////////////////////////////////////////////////////// // // wxWidgets dialogs for Bochs @@ -478,6 +478,7 @@ protected: virtual void EnableChanged (); void EnableParam(int param_id, bool enabled); void EnableParam(const char *pname, bool enabled); + void EnableParam(const char *pname, bx_list_c *base, bool enabled); void EnumChanged (ParamStruct *pstr); void EnableChangedRecursive (bx_list_c *list, bool en, ParamStruct *pstrOfCheckbox); void EnableChanged (ParamStruct *pstr); diff --git a/bochs/gui/wxmain.cc b/bochs/gui/wxmain.cc index d40f607b2..2ca514458 100644 --- a/bochs/gui/wxmain.cc +++ b/bochs/gui/wxmain.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////// -// $Id: wxmain.cc,v 1.119 2006-02-24 22:35:46 vruppert Exp $ +// $Id: wxmain.cc,v 1.120 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////// // // wxmain.cc implements the wxWidgets frame, toolbar, menus, and dialogs. @@ -892,6 +892,9 @@ void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event)) // update the menu items, status bar, etc. void MyFrame::simStatusChanged (StatusChange change, bx_bool popupNotify) { + char ata_name[20]; + bx_list_c *base; + switch (change) { case Start: // running wxLogStatus ("Starting Bochs simulation"); @@ -926,12 +929,19 @@ void MyFrame::simStatusChanged (StatusChange change, bx_bool popupNotify) { menuConfiguration->Enable (ID_Config_Read, canConfigure); // only enabled ATA channels with a cdrom connected are available at runtime for (unsigned i=0; i<4; i++) { - if (!SIM->get_param_bool((bx_id)(BXP_ATA0_PRESENT+i))->get ()) { + sprintf(ata_name, "ata.%d.resources", i); + base = (bx_list_c*) SIM->get_param(ata_name); + if (!SIM->get_param_bool("enabled", base)->get()) { menuEdit->Enable (ID_Edit_ATA0+i, canConfigure); } else { - if ( (SIM->get_param_num((bx_id)(BXP_ATA0_MASTER_TYPE+i*2))->get () != BX_ATA_DEVICE_CDROM) && - (SIM->get_param_num((bx_id)(BXP_ATA0_SLAVE_TYPE+i*2))->get () != BX_ATA_DEVICE_CDROM) ) { - menuEdit->Enable (ID_Edit_ATA0+i, canConfigure); + sprintf(ata_name, "ata.%d.master", i); + base = (bx_list_c*) SIM->get_param(ata_name); + if (SIM->get_param_enum("type", base)->get () != BX_ATA_DEVICE_CDROM) { + sprintf(ata_name, "ata.%d.slave", i); + base = (bx_list_c*) SIM->get_param(ata_name); + if (SIM->get_param_enum("type", base)->get () != BX_ATA_DEVICE_CDROM) { + menuEdit->Enable(ID_Edit_ATA0+i, canConfigure); + } } } } @@ -1297,17 +1307,18 @@ void MyFrame::editFirstCdrom () dlg.ShowModal (); } -void MyFrame::OnEditATA (wxCommandEvent& event) +void MyFrame::OnEditATA(wxCommandEvent& event) { int id = event.GetId (); int channel = id - ID_Edit_ATA0; - ParamDialog dlg (this, -1); - wxString str; - str.Printf ("Configure ATA%d", channel); - dlg.SetTitle (str); - dlg.SetRuntimeFlag (sim_thread != NULL); - dlg.AddParam (SIM->get_param ((bx_id)(BXP_ATA0_MENU+channel))); - dlg.ShowModal (); + char ata_name[10]; + sprintf(ata_name, "ata.%d", channel); + ParamDialog dlg(this, -1); + bx_list_c *list = (bx_list_c*) SIM->get_param(ata_name); + dlg.SetTitle(list->get_title()->getptr()); + dlg.AddParam(list); + dlg.SetRuntimeFlag(sim_thread != NULL); + dlg.ShowModal(); } void MyFrame::OnToolbarClick(wxCommandEvent& event) diff --git a/bochs/iodev/harddrv.cc b/bochs/iodev/harddrv.cc index b84b8ed31..143b33c3b 100644 --- a/bochs/iodev/harddrv.cc +++ b/bochs/iodev/harddrv.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: harddrv.cc,v 1.162 2006-02-23 22:48:57 vruppert Exp $ +// $Id: harddrv.cc,v 1.163 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -143,14 +143,18 @@ bx_hard_drive_c::init(void) Bit8u channel; char string[5]; char sbtext[8]; + char ata_name[20]; + bx_list_c *base; - BX_DEBUG(("Init $Id: harddrv.cc,v 1.162 2006-02-23 22:48:57 vruppert Exp $")); + BX_DEBUG(("Init $Id: harddrv.cc,v 1.163 2006-02-26 19:11:20 vruppert Exp $")); for (channel=0; channelget() == 1) { - BX_HD_THIS channels[channel].ioaddr1 = bx_options.ata[channel].Oioaddr1->get(); - BX_HD_THIS channels[channel].ioaddr2 = bx_options.ata[channel].Oioaddr2->get(); - BX_HD_THIS channels[channel].irq = bx_options.ata[channel].Oirq->get(); + sprintf(ata_name, "ata.%d.resources", channel); + base = (bx_list_c*) SIM->get_param(ata_name); + if (SIM->get_param_bool("enabled", base)->get() == 1) { + BX_HD_THIS channels[channel].ioaddr1 = SIM->get_param_num("ioaddr1", base)->get(); + BX_HD_THIS channels[channel].ioaddr2 = SIM->get_param_num("ioaddr2", base)->get(); + BX_HD_THIS channels[channel].irq = SIM->get_param_num("irq", base)->get(); // Coherency check if ( (BX_HD_THIS channels[channel].ioaddr1 == 0) || @@ -205,8 +209,10 @@ bx_hard_drive_c::init(void) channel = 0; for (channel=0; channelget_param(ata_name); - // Initialize controller state, even if device is not present + // Initialize controller state, even if device is not present BX_CONTROLLER(channel,device).status.busy = 0; BX_CONTROLLER(channel,device).status.drive_ready = 1; BX_CONTROLLER(channel,device).status.write_fault = 0; @@ -238,48 +244,48 @@ bx_hard_drive_c::init(void) BX_HD_THIS channels[channel].drives[device].device_type = IDE_NONE; BX_HD_THIS channels[channel].drives[device].statusbar_id = -1; BX_HD_THIS channels[channel].drives[device].iolight_counter = 0; - if (!bx_options.atadevice[channel][device].Opresent->get()) { + if (!SIM->get_param_bool("present", base)->get()) { continue; } // Make model string strncpy((char*)BX_HD_THIS channels[channel].drives[device].model_no, - bx_options.atadevice[channel][device].Omodel->getptr(), 40); + SIM->get_param_string("model", base)->getptr(), 40); while (strlen((char *)BX_HD_THIS channels[channel].drives[device].model_no) < 40) { strcat ((char*)BX_HD_THIS channels[channel].drives[device].model_no, " "); - } + } - if (bx_options.atadevice[channel][device].Otype->get() == BX_ATA_DEVICE_DISK) { + if (SIM->get_param_enum("type", base)->get() == BX_ATA_DEVICE_DISK) { BX_DEBUG(( "Hard-Disk on target %d/%d",channel,device)); BX_HD_THIS channels[channel].drives[device].device_type = IDE_DISK; sprintf(sbtext, "HD:%d-%s", channel, device?"S":"M"); BX_HD_THIS channels[channel].drives[device].statusbar_id = bx_gui->register_statusitem(sbtext); - int cyl = bx_options.atadevice[channel][device].Ocylinders->get (); - int heads = bx_options.atadevice[channel][device].Oheads->get (); - int spt = bx_options.atadevice[channel][device].Ospt->get (); + int cyl = SIM->get_param_num("cylinders", base)->get(); + int heads = SIM->get_param_num("heads", base)->get(); + int spt = SIM->get_param_num("spt", base)->get(); Bit64u disk_size = (Bit64u)cyl * heads * spt * 512; /* instantiate the right class */ - switch (bx_options.atadevice[channel][device].Omode->get()) { + switch (SIM->get_param_enum("mode", base)->get()) { case BX_ATA_MODE_FLAT: - BX_INFO(("HD on ata%d-%d: '%s' 'flat' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + BX_INFO(("HD on ata%d-%d: '%s' 'flat' mode ", channel, device, + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new default_image_t(); break; case BX_ATA_MODE_CONCAT: BX_INFO(("HD on ata%d-%d: '%s' 'concat' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new concat_image_t(); break; #if EXTERNAL_DISK_SIMULATOR case BX_ATA_MODE_EXTDISKSIM: BX_INFO(("HD on ata%d-%d: '%s' 'External Simulator' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new EXTERNAL_DISK_SIMULATOR_CLASS(); break; #endif //EXTERNAL_DISK_SIMULATOR @@ -287,41 +293,41 @@ bx_hard_drive_c::init(void) #if DLL_HD_SUPPORT case BX_ATA_MODE_DLL_HD: BX_INFO(("HD on ata%d-%d: '%s' 'dll' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new dll_image_t(); break; #endif //DLL_HD_SUPPORT case BX_ATA_MODE_SPARSE: BX_INFO(("HD on ata%d-%d: '%s' 'sparse' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new sparse_image_t(); break; case BX_ATA_MODE_VMWARE3: BX_INFO(("HD on ata%d-%d: '%s' 'vmware3' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new vmware3_image_t(); break; case BX_ATA_MODE_UNDOABLE: BX_INFO(("HD on ata%d-%d: '%s' 'undoable' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new undoable_image_t(disk_size, - bx_options.atadevice[channel][device].Ojournal->getptr()); + SIM->get_param_string("journal", base)->getptr()); break; case BX_ATA_MODE_GROWING: BX_INFO(("HD on ata%d-%d: '%s' 'growing' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new growing_image_t(disk_size); break; case BX_ATA_MODE_VOLATILE: BX_INFO(("HD on ata%d-%d: '%s' 'volatile' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new volatile_image_t(disk_size, - bx_options.atadevice[channel][device].Ojournal->getptr()); + SIM->get_param_string("journal", base)->getptr()); break; #if BX_COMPRESSED_HD_SUPPORT @@ -329,9 +335,9 @@ bx_hard_drive_c::init(void) BX_PANIC(("z-undoable disk support not implemented")); #if 0 BX_INFO(("HD on ata%d-%d: '%s' 'z-undoable' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new z_undoable_image_t(disk_size, - bx_options.atadevice[channel][device].Ojournal->getptr()); + SIM->get_param_string("journal", base)->getptr()); #endif break; @@ -339,17 +345,17 @@ bx_hard_drive_c::init(void) BX_PANIC(("z-volatile disk support not implemented")); #if 0 BX_INFO(("HD on ata%d-%d: '%s' 'z-volatile' mode ", channel, device, - bx_options.atadevice[channel][device].Opath->getptr ())); + SIM->get_param_string("path", base)->getptr())); channels[channel].drives[device].hard_drive = new z_volatile_image_t(disk_size, - bx_options.atadevice[channel][device].Ojournal->getptr()); + SIM->get_param_string("journal", base)->getptr()); #endif break; #endif //BX_COMPRESSED_HD_SUPPORT default: BX_PANIC(("HD on ata%d-%d: '%s' unsupported HD mode : %s", channel, device, - bx_options.atadevice[channel][device].Opath->getptr (), - atadevice_mode_names[bx_options.atadevice[channel][device].Omode->get()])); + SIM->get_param_string("path", base)->getptr(), + atadevice_mode_names[SIM->get_param_enum("mode", base)->get()])); break; } @@ -357,7 +363,7 @@ bx_hard_drive_c::init(void) BX_HD_THIS channels[channel].drives[device].hard_drive->heads = heads; BX_HD_THIS channels[channel].drives[device].hard_drive->sectors = spt; - if (bx_options.atadevice[channel][device].Omode->get() == BX_ATA_MODE_FLAT) { + if (SIM->get_param_enum("mode", base)->get() == BX_ATA_MODE_FLAT) { if ((heads == 0) || (spt == 0)) { BX_PANIC(("ata%d/%d cannot have zero heads, or sectors/track", channel, device)); } @@ -368,11 +374,11 @@ bx_hard_drive_c::init(void) } /* open hard drive image file */ - if ((BX_HD_THIS channels[channel].drives[device].hard_drive->open(bx_options.atadevice[channel][device].Opath->getptr ())) < 0) { - BX_PANIC(("ata%d-%d: could not open hard drive image file '%s'", channel, device, bx_options.atadevice[channel][device].Opath->getptr ())); + if ((BX_HD_THIS channels[channel].drives[device].hard_drive->open(SIM->get_param_string("path", base)->getptr())) < 0) { + BX_PANIC(("ata%d-%d: could not open hard drive image file '%s'", channel, device, SIM->get_param_string("path", base)->getptr())); } - if (bx_options.atadevice[channel][device].Omode->get() == BX_ATA_MODE_FLAT) { + if (SIM->get_param_enum("mode", base)->get() == BX_ATA_MODE_FLAT) { if (cyl > 0) { if (disk_size != (Bit64u)BX_HD_THIS channels[channel].drives[device].hard_drive->hd_size) { BX_PANIC(("ata%d/%d image size doesn't match specified geometry", channel, device)); @@ -382,11 +388,11 @@ bx_hard_drive_c::init(void) disk_size = BX_HD_THIS channels[channel].drives[device].hard_drive->hd_size; cyl = (int)(disk_size / (heads * spt * 512)); BX_HD_THIS channels[channel].drives[device].hard_drive->cylinders = cyl; - bx_options.atadevice[channel][device].Ocylinders->set (cyl); + SIM->get_param_num("cylinders", base)->set(cyl); BX_INFO(("ata%d-%d: autodetect geometry: CHS=%d/%d/%d", channel, device, cyl, heads, spt)); } } - } else if (bx_options.atadevice[channel][device].Otype->get() == BX_ATA_DEVICE_CDROM) { + } else if (SIM->get_param_enum("type", base)->get() == BX_ATA_DEVICE_CDROM) { BX_DEBUG(( "CDROM on target %d/%d",channel,device)); BX_HD_THIS channels[channel].drives[device].device_type = IDE_CDROM; BX_HD_THIS channels[channel].drives[device].cdrom.locked = 0; @@ -421,10 +427,10 @@ bx_hard_drive_c::init(void) // allocate low level driver #ifdef LOWLEVEL_CDROM - BX_HD_THIS channels[channel].drives[device].cdrom.cd = new LOWLEVEL_CDROM(bx_options.atadevice[channel][device].Opath->getptr ()); - BX_INFO(("CD on ata%d-%d: '%s'",channel, device, bx_options.atadevice[channel][device].Opath->getptr ())); + BX_HD_THIS channels[channel].drives[device].cdrom.cd = new LOWLEVEL_CDROM(SIM->get_param_string("path", base)->getptr()); + BX_INFO(("CD on ata%d-%d: '%s'",channel, device, SIM->get_param_string("path", base)->getptr())); - if (bx_options.atadevice[channel][device].Ostatus->get () == BX_INSERTED) { + if (SIM->get_param_enum("status", base)->get() == BX_INSERTED) { if (BX_HD_THIS channels[channel].drives[device].cdrom.cd->insert_cdrom()) { BX_INFO(( "Media present in CD-ROM drive")); BX_HD_THIS channels[channel].drives[device].cdrom.ready = 1; @@ -434,7 +440,7 @@ bx_hard_drive_c::init(void) } else { BX_INFO(( "Could not locate CD-ROM, continuing with media not present")); BX_HD_THIS channels[channel].drives[device].cdrom.ready = 0; - bx_options.atadevice[channel][device].Ostatus->set(BX_EJECTED); + SIM->get_param_enum("status", base)->set(BX_EJECTED); } } else @@ -452,65 +458,69 @@ bx_hard_drive_c::init(void) DEV_cmos_set_reg(0x12, 0x00); // start out with: no drive 0, no drive 1 if (BX_DRIVE_IS_HD(0,0)) { + base = (bx_list_c*) SIM->get_param(BXPN_ATA0_MASTER); // Flag drive type as Fh, use extended CMOS location as real type DEV_cmos_set_reg(0x12, (DEV_cmos_get_reg(0x12) & 0x0f) | 0xf0); DEV_cmos_set_reg(0x19, 47); // user definable type // AMI BIOS: 1st hard disk #cyl low byte - DEV_cmos_set_reg(0x1b, (bx_options.atadevice[0][0].Ocylinders->get () & 0x00ff)); + DEV_cmos_set_reg(0x1b, (SIM->get_param_num("cylinders", base)->get() & 0x00ff)); // AMI BIOS: 1st hard disk #cyl high byte - DEV_cmos_set_reg(0x1c, (bx_options.atadevice[0][0].Ocylinders->get () & 0xff00) >> 8); + DEV_cmos_set_reg(0x1c, (SIM->get_param_num("cylinders", base)->get() & 0xff00) >> 8); // AMI BIOS: 1st hard disk #heads - DEV_cmos_set_reg(0x1d, (bx_options.atadevice[0][0].Oheads->get ())); + DEV_cmos_set_reg(0x1d, (SIM->get_param_num("heads", base)->get())); // AMI BIOS: 1st hard disk write precompensation cylinder, low byte DEV_cmos_set_reg(0x1e, 0xff); // -1 // AMI BIOS: 1st hard disk write precompensation cylinder, high byte DEV_cmos_set_reg(0x1f, 0xff); // -1 // AMI BIOS: 1st hard disk control byte - DEV_cmos_set_reg(0x20, (0xc0 | ((bx_options.atadevice[0][0].Oheads->get () > 8) << 3))); + DEV_cmos_set_reg(0x20, (0xc0 | ((SIM->get_param_num("heads", base)->get() > 8) << 3))); // AMI BIOS: 1st hard disk landing zone, low byte DEV_cmos_set_reg(0x21, DEV_cmos_get_reg(0x1b)); // AMI BIOS: 1st hard disk landing zone, high byte DEV_cmos_set_reg(0x22, DEV_cmos_get_reg(0x1c)); // AMI BIOS: 1st hard disk sectors/track - DEV_cmos_set_reg(0x23, bx_options.atadevice[0][0].Ospt->get ()); + DEV_cmos_set_reg(0x23, SIM->get_param_num("spt", base)->get()); } //set up cmos for second hard drive if (BX_DRIVE_IS_HD(0,1)) { + base = (bx_list_c*) SIM->get_param(BXPN_ATA0_SLAVE); BX_DEBUG(("1: I will put 0xf into the second hard disk field")); // fill in lower 4 bits of 0x12 for second HD DEV_cmos_set_reg(0x12, (DEV_cmos_get_reg(0x12) & 0xf0) | 0x0f); DEV_cmos_set_reg(0x1a, 47); // user definable type // AMI BIOS: 2nd hard disk #cyl low byte - DEV_cmos_set_reg(0x24, (bx_options.atadevice[0][1].Ocylinders->get () & 0x00ff)); + DEV_cmos_set_reg(0x24, (SIM->get_param_num("cylinders", base)->get() & 0x00ff)); // AMI BIOS: 2nd hard disk #cyl high byte - DEV_cmos_set_reg(0x25, (bx_options.atadevice[0][1].Ocylinders->get () & 0xff00) >> 8); + DEV_cmos_set_reg(0x25, (SIM->get_param_num("cylinders", base)->get() & 0xff00) >> 8); // AMI BIOS: 2nd hard disk #heads - DEV_cmos_set_reg(0x26, (bx_options.atadevice[0][1].Oheads->get ())); + DEV_cmos_set_reg(0x26, (SIM->get_param_num("heads", base)->get())); // AMI BIOS: 2nd hard disk write precompensation cylinder, low byte DEV_cmos_set_reg(0x27, 0xff); // -1 // AMI BIOS: 2nd hard disk write precompensation cylinder, high byte DEV_cmos_set_reg(0x28, 0xff); // -1 // AMI BIOS: 2nd hard disk, 0x80 if heads>8 - DEV_cmos_set_reg(0x29, (bx_options.atadevice[0][1].Oheads->get () > 8) ? 0x80 : 0x00); + DEV_cmos_set_reg(0x29, (SIM->get_param_num("heads", base)->get() > 8) ? 0x80 : 0x00); // AMI BIOS: 2nd hard disk landing zone, low byte DEV_cmos_set_reg(0x2a, DEV_cmos_get_reg(0x24)); // AMI BIOS: 2nd hard disk landing zone, high byte DEV_cmos_set_reg(0x2b, DEV_cmos_get_reg(0x25)); // AMI BIOS: 2nd hard disk sectors/track - DEV_cmos_set_reg(0x2c, bx_options.atadevice[0][1].Ospt->get ()); + DEV_cmos_set_reg(0x2c, SIM->get_param_num("spt", base)->get()); } DEV_cmos_set_reg(0x39, 0); DEV_cmos_set_reg(0x3a, 0); for (channel=0; channelget()) { + sprintf(ata_name, "ata.%d.%s", channel, (device==0)?"master":"slave"); + base = (bx_list_c*) SIM->get_param(ata_name); + if (SIM->get_param_bool("present", base)->get()) { if (BX_DRIVE_IS_HD(channel,device)) { - Bit16u cylinders = bx_options.atadevice[channel][device].Ocylinders->get(); - Bit16u heads = bx_options.atadevice[channel][device].Oheads->get(); - Bit16u spt = bx_options.atadevice[channel][device].Ospt->get(); - Bit8u translation = bx_options.atadevice[channel][device].Otranslation->get(); + Bit16u cylinders = SIM->get_param_num("cylinders", base)->get(); + Bit16u heads = SIM->get_param_num("heads", base)->get(); + Bit16u spt = SIM->get_param_num("spt", base)->get(); + Bit8u translation = SIM->get_param_enum("translation", base)->get(); Bit8u reg = 0x39 + channel/2; Bit8u bitshift = 2 * (device+(2 * (channel%2))); @@ -1345,6 +1355,7 @@ bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len) case 0x1b: // start stop unit { + char ata_name[20]; //bx_bool Immed = (BX_SELECTED_CONTROLLER(channel).buffer[1] >> 0) & 1; bx_bool LoEj = (BX_SELECTED_CONTROLLER(channel).buffer[4] >> 1) & 1; bx_bool Start = (BX_SELECTED_CONTROLLER(channel).buffer[4] >> 0) & 1; @@ -1368,7 +1379,9 @@ bx_hard_drive_c::write(Bit32u address, Bit32u value, unsigned io_len) BX_SELECTED_DRIVE(channel).cdrom.cd->eject_cdrom(); #endif BX_SELECTED_DRIVE(channel).cdrom.ready = 0; - bx_options.atadevice[channel][BX_SLAVE_SELECTED(channel)].Ostatus->set(BX_EJECTED); + sprintf(ata_name, "ata.%d.%s", channel, BX_SLAVE_SELECTED(channel)?"slave":"master"); + bx_list_c *base = (bx_list_c*) SIM->get_param(ata_name); + SIM->get_param_enum("status", base)->set(BX_EJECTED); bx_gui->update_drive_status_buttons(); } raise_interrupt(channel); @@ -3175,21 +3188,25 @@ bx_hard_drive_c::atapi_cmd_nop(Bit8u channel) void bx_hard_drive_c::init_mode_sense_single(Bit8u channel, const void* src, int size) { - // Header - BX_SELECTED_CONTROLLER(channel).buffer[0] = (size+6) >> 8; - BX_SELECTED_CONTROLLER(channel).buffer[1] = (size+6) & 0xff; - if (bx_options.atadevice[channel][BX_HD_THIS channels[channel].drive_select].Ostatus->get () == BX_INSERTED) - BX_SELECTED_CONTROLLER(channel).buffer[2] = 0x12; // media present 120mm CD-ROM (CD-R) data/audio door closed - else - BX_SELECTED_CONTROLLER(channel).buffer[2] = 0x70; // no media present - BX_SELECTED_CONTROLLER(channel).buffer[3] = 0; // reserved - BX_SELECTED_CONTROLLER(channel).buffer[4] = 0; // reserved - BX_SELECTED_CONTROLLER(channel).buffer[5] = 0; // reserved - BX_SELECTED_CONTROLLER(channel).buffer[6] = 0; // reserved - BX_SELECTED_CONTROLLER(channel).buffer[7] = 0; // reserved + char ata_name[20]; - // Data - memcpy(BX_SELECTED_CONTROLLER(channel).buffer + 8, src, size); + // Header + BX_SELECTED_CONTROLLER(channel).buffer[0] = (size+6) >> 8; + BX_SELECTED_CONTROLLER(channel).buffer[1] = (size+6) & 0xff; + sprintf(ata_name, "ata.%d.%s", channel, BX_HD_THIS channels[channel].drive_select?"slave":"master"); + bx_list_c *base = (bx_list_c*) SIM->get_param(ata_name); + if (SIM->get_param_enum("status", base)->get() == BX_INSERTED) + BX_SELECTED_CONTROLLER(channel).buffer[2] = 0x12; // media present 120mm CD-ROM (CD-R) data/audio door closed + else + BX_SELECTED_CONTROLLER(channel).buffer[2] = 0x70; // no media present + BX_SELECTED_CONTROLLER(channel).buffer[3] = 0; // reserved + BX_SELECTED_CONTROLLER(channel).buffer[4] = 0; // reserved + BX_SELECTED_CONTROLLER(channel).buffer[5] = 0; // reserved + BX_SELECTED_CONTROLLER(channel).buffer[6] = 0; // reserved + BX_SELECTED_CONTROLLER(channel).buffer[7] = 0; // reserved + + // Data + memcpy(BX_SELECTED_CONTROLLER(channel).buffer + 8, src, size); } void BX_CPP_AttrRegparmN(1) @@ -3266,12 +3283,16 @@ bx_hard_drive_c::get_cd_media_status(Bit32u handle) unsigned bx_hard_drive_c::set_cd_media_status(Bit32u handle, unsigned status) { + char ata_name[20]; + BX_DEBUG (("set_cd_media_status handle=%d status=%d", handle, status)); if ( handle >= BX_MAX_ATA_CHANNEL*2 ) return 0; Bit8u channel = handle / 2; Bit8u device = handle % 2; + sprintf(ata_name, "ata.%d.%s", channel, (device==0)?"master":"slave"); + bx_list_c *base = (bx_list_c*) SIM->get_param(ata_name); // if setting to the current value, nothing to do if (status == BX_HD_THIS channels[channel].drives[device].cdrom.ready) return(status); @@ -3287,18 +3308,18 @@ bx_hard_drive_c::set_cd_media_status(Bit32u handle, unsigned status) BX_HD_THIS channels[channel].drives[device].cdrom.cd->eject_cdrom(); #endif BX_HD_THIS channels[channel].drives[device].cdrom.ready = 0; - bx_options.atadevice[channel][device].Ostatus->set(BX_EJECTED); - } + SIM->get_param_enum("status", base)->set(BX_EJECTED); + } } else { // insert cdrom #ifdef LOWLEVEL_CDROM - if (BX_HD_THIS channels[channel].drives[device].cdrom.cd->insert_cdrom(bx_options.atadevice[channel][device].Opath->getptr())) { + if (BX_HD_THIS channels[channel].drives[device].cdrom.cd->insert_cdrom(SIM->get_param_string("path", base)->getptr())) { BX_INFO(( "Media present in CD-ROM drive")); BX_HD_THIS channels[channel].drives[device].cdrom.ready = 1; Bit32u capacity = BX_HD_THIS channels[channel].drives[device].cdrom.cd->capacity(); BX_HD_THIS channels[channel].drives[device].cdrom.capacity = capacity; BX_INFO(("Capacity is %d sectors (%.2f MB)", capacity, (float)capacity / 512.0)); - bx_options.atadevice[channel][device].Ostatus->set(BX_INSERTED); + SIM->get_param_enum("status", base)->set(BX_INSERTED); BX_SELECTED_DRIVE(channel).sense.sense_key = SENSE_UNIT_ATTENTION; BX_SELECTED_DRIVE(channel).sense.asc = 0; BX_SELECTED_DRIVE(channel).sense.ascq = 0; @@ -3309,7 +3330,7 @@ bx_hard_drive_c::set_cd_media_status(Bit32u handle, unsigned status) { BX_INFO(( "Could not locate CD-ROM, continuing with media not present")); BX_HD_THIS channels[channel].drives[device].cdrom.ready = 0; - bx_options.atadevice[channel][device].Ostatus->set(BX_EJECTED); + SIM->get_param_enum("status", base)->set(BX_EJECTED); } } return (BX_HD_THIS channels[channel].drives[device].cdrom.ready); diff --git a/bochs/iodev/pci_ide.cc b/bochs/iodev/pci_ide.cc index 72d819ae5..65ede1500 100644 --- a/bochs/iodev/pci_ide.cc +++ b/bochs/iodev/pci_ide.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: pci_ide.cc,v 1.19 2005-11-15 17:19:28 vruppert Exp $ +// $Id: pci_ide.cc,v 1.20 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -119,11 +119,11 @@ bx_pci_ide_c::reset(unsigned type) BX_PIDE_THIS s.pci_conf[0x04] = 0x01; BX_PIDE_THIS s.pci_conf[0x06] = 0x80; BX_PIDE_THIS s.pci_conf[0x07] = 0x02; - if (bx_options.ata[0].Opresent->get ()) { + if (SIM->get_param_bool(BXPN_ATA0_ENABLED)->get()) { BX_PIDE_THIS s.pci_conf[0x40] = 0x00; BX_PIDE_THIS s.pci_conf[0x41] = 0x80; } - if (bx_options.ata[1].Opresent->get ()) { + if (SIM->get_param_bool(BXPN_ATA1_ENABLED)->get()) { BX_PIDE_THIS s.pci_conf[0x42] = 0x00; BX_PIDE_THIS s.pci_conf[0x43] = 0x80; } diff --git a/bochs/main.cc b/bochs/main.cc index cd4a4aa71..96af0c4c7 100644 --- a/bochs/main.cc +++ b/bochs/main.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: main.cc,v 1.317 2006-02-23 22:48:56 vruppert Exp $ +// $Id: main.cc,v 1.318 2006-02-26 19:11:20 vruppert Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -205,16 +205,18 @@ void print_tree(bx_param_c *node, int level) case BXT_PARAM_BOOL: printf ("%s = %s (boolean)\n", node->get_name(), ((bx_param_bool_c*)node)->get()?"true":"false"); break; - case BXT_PARAM: case BXT_PARAM_ENUM: + printf ("%s = '%s' (enum)\n", node->get_name(), ((bx_param_enum_c*)node)->get_selected()); + break; + case BXT_PARAM: case BXT_PARAM_STRING: printf ("%s = '%s' (string)\n", node->get_name(), ((bx_param_string_c*)node)->getptr()); break; case BXT_LIST: { - printf ("%s = \n", node->get_name ()); + printf ("%s = \n", node->get_name()); bx_list_c *list = (bx_list_c*)node; - for (i=0; i < list->get_size (); i++) { + for (i=0; i < list->get_size(); i++) { print_tree(list->get(i), level+1); } break;