mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- ata/atapi options rewritten to a parameter tree

Browse Source 
- siminterface get_param_*() methods num support a base parameter like the generic
  get_param() method
- new parameter lists now also have a generated id
- test function print_tree() now handles enum parameters correctly
- proposed parameter tree updated
This commit is contained in:
Volker Ruppert 2006-02-26 19:11:20 +00:00
parent 6cd4ffff28
commit 15efba10dd
13 changed files with 972 additions and 1223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
bochs/PARAM_TREE.txt
View File

@ -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

11
bochs/bochs.h
View File

@ -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];

1162
bochs/config.cc
View File

File diff suppressed because it is too large Load Diff

171
bochs/gui/siminterface.cc
View File

@ -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; channel<BX_MAX_ATA_CHANNEL; channel++) {
for (Bit8u device=0; device<2; device++) {
if (bx_options.atadevice[channel][device].Otype->get() == 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; channel<BX_MAX_ATA_CHANNEL; channel++) {
if (!bx_options.ata[channel].Opresent->get ())
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; i<dependent_list->get_size (); i++) {
bx_param_c *param = dependent_list->get (i);
for (int i=0; i<dependent_list->get_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; i<get_size (); i++)
newlist->add (get(i));
newlist->set_options (get_options ());
bx_list_c *newlist = new bx_list_c(NULL, name, description, maxsize);
for (int i=0; i<get_size(); i++)
newlist->add(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; i<imax; i++) {
bx_param_c *p = get(i);
if (0 == strcmp (name, p->get_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; i<imax; i++) {
get(i)->reset();
}

214
bochs/gui/siminterface.h
View File

@ -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

171
bochs/gui/textconfig.cc
View File

@ -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; i<imax; i++) fprintf (fpout, "-");
fprintf (fpout, "\n%s\n", my_title);
for (i=0; i<imax; i++) fprintf (fpout, "-");
fprintf (fpout, "\n"); //fprintf (fp, "options=%s\n", options->get ());
fprintf(fpout, "\n");
if (options->get () & SERIES_ASK) {
for (int i=0; i<size; i++) {
if (list[i]->get_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;

61
bochs/gui/win32dialog.cc
View File

@ -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; device<devcount; device++) {
if (lstrcmp(cdromop[device].Opath->getptr(), 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;

158
bochs/gui/wxdialog.cc
View File

@ -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);
}
}
}
}

3
bochs/gui/wxdialog.h
View File

@ -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);

37
bochs/gui/wxmain.cc
View File

@ -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)

177
bochs/iodev/harddrv.cc
View File

@ -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; channel<BX_MAX_ATA_CHANNEL; channel++) {
if (bx_options.ata[channel].Opresent->get() == 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; channel<BX_MAX_ATA_CHANNEL; channel++) {
for (Bit8u device=0; device<2; device ++) {
sprintf(ata_name, "ata.%d.%s", channel, (device==0)?"master":"slave");
base = (bx_list_c*) SIM->get_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; channel<BX_MAX_ATA_CHANNEL; channel++) {
for (Bit8u device=0; device<2; device ++) {
if (bx_options.atadevice[channel][device].Opresent->get()) {
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);

6
bochs/iodev/pci_ide.cc
View File

@ -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;
}

10
bochs/main.cc
View File

@ -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;