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

Generate USB devices list from available USB plugins list and removed hardcoded

Browse Source 
device handling. Added some code to handle plugins that provide more than one
device type (usb_hid, usb_msd) or with different name (usb_cbi). The device
type member is now only used by multi-function devices.
This commit is contained in:
Volker Ruppert 2021-02-17 16:22:55 +00:00
parent 2ab50c7d66
commit dcdceb96f6
12 changed files with 159 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bochs/CHANGES
View File

@ -5,7 +5,8 @@ Changes after 2.6.11:
- Improved plugins handling: all available plugins in path are detected at - Improved plugins handling: all available plugins in path are detected at
startup (including externally developed ones). These types are supported in startup (including externally developed ones). These types are supported in
Bochs configuration: display libraries, VGA compatile adapters, optional Bochs configuration: display libraries, VGA compatile adapters, optional
PCI/ISA devices, disk image, networking and sound driver modules. PCI/ISA devices, pluggable USB devices, disk image, networking and sound
driver modules.
- Save/Restore bugfixes - Save/Restore bugfixes
- Removed legacy "load32bitOShack" feature. - Removed legacy "load32bitOShack" feature.
- Removed "svga" display library designed for the obsolete Linux SVGALib. - Removed "svga" display library designed for the obsolete Linux SVGALib.

3
bochs/iodev/usb/usb_cbi.cc
View File

@ -63,7 +63,7 @@ class bx_usb_cbi_locator_c : public usbdev_locator_c {
public: public:
bx_usb_cbi_locator_c(void) : usbdev_locator_c("usb_cbi") {} bx_usb_cbi_locator_c(void) : usbdev_locator_c("usb_cbi") {}
protected: protected:
usb_device_c *allocate(usbdev_type devtype) { usb_device_c *allocate(const char *devname) {
return (new usb_cbi_device_c()); return (new usb_cbi_device_c());
} }
} bx_usb_cbi_match; } bx_usb_cbi_match;
@ -320,7 +320,6 @@ usb_cbi_device_c::usb_cbi_device_c()
bx_param_bool_c *readonly; bx_param_bool_c *readonly;
bx_param_enum_c *status, *mode; bx_param_enum_c *status, *mode;
d.type = USB_DEV_TYPE_FLOPPY;
d.speed = d.minspeed = d.maxspeed = USB_SPEED_FULL; d.speed = d.minspeed = d.maxspeed = USB_SPEED_FULL;
memset((void*)&s, 0, sizeof(s)); memset((void*)&s, 0, sizeof(s));
strcpy(d.devname, "BOCHS USB CBI FLOPPY"); strcpy(d.devname, "BOCHS USB CBI FLOPPY");

130
bochs/iodev/usb/usb_common.cc
View File

@ -37,6 +37,10 @@
bx_usbdev_ctl_c bx_usbdev_ctl; bx_usbdev_ctl_c bx_usbdev_ctl;
const char **usb_module_names;
const char **usb_device_names;
Bit8u *usb_module_id;
bx_usbdev_ctl_c::bx_usbdev_ctl_c() bx_usbdev_ctl_c::bx_usbdev_ctl_c()
{ {
put("usbdevctl", "USBCTL"); put("usbdevctl", "USBCTL");
@ -44,40 +48,55 @@ bx_usbdev_ctl_c::bx_usbdev_ctl_c()
void bx_usbdev_ctl_c::init(void) void bx_usbdev_ctl_c::init(void)
{ {
// TODO Bit8u i, j, count;
count = PLUG_get_plugins_count(PLUGTYPE_USB);
usb_module_names = (const char**) malloc(count * sizeof(char*));
usb_device_names = (const char**) malloc((count + 5) * sizeof(char*));
usb_module_id = (Bit8u*) malloc((count + 5) * sizeof(Bit8u));
usb_device_names[0] = "none";
usb_module_id[0] = 0xff;
j = 1;
for (i = 0; i < count; i++) {
usb_module_names[i] = PLUG_get_plugin_name(PLUGTYPE_USB, i);
if (!strcmp(usb_module_names[i], "usb_hid")) {
usb_device_names[j] = "mouse";
usb_module_id[j++] = i;
usb_device_names[j] = "tablet";
usb_module_id[j++] = i;
usb_device_names[j] = "keypad";
usb_module_id[j++] = i;
usb_device_names[j] = "keyboard";
usb_module_id[j] = i;
} else if (!strcmp(usb_module_names[i], "usb_msd")) {
usb_device_names[j] = "disk";
usb_module_id[j++] = i;
usb_device_names[j] = "cdrom";
usb_module_id[j] = i;
} else if (!strcmp(usb_module_names[i], "usb_cbi")) {
usb_device_names[j] = "floppy";
usb_module_id[j] = i;
} else {
if (!strncmp(usb_module_names[i], "usb_", 4)) {
usb_device_names[j] = &usb_module_names[i][4];
} else {
usb_device_names[j] = usb_module_names[i];
}
usb_module_id[j] = i;
}
j++;
}
usb_device_names[j] = NULL;
} }
void bx_usbdev_ctl_c::exit(void) void bx_usbdev_ctl_c::exit(void)
{ {
// TODO free(usb_module_names);
free(usb_device_names);
free(usb_module_id);
usbdev_locator_c::cleanup(); usbdev_locator_c::cleanup();
} }
const char *usbmod_names[] =
{
"none",
"usb_cbi",
"usb_hid",
"usb_hub",
"usb_msd",
"usb_printer"
};
const char *usb_device_names[] =
{
"none",
"mouse",
"tablet",
"keypad",
"keyboard",
"disk",
"cdrom",
"hub",
"printer",
"floppy",
NULL
};
const char **bx_usbdev_ctl_c::get_device_names(void) const char **bx_usbdev_ctl_c::get_device_names(void)
{ {
return usb_device_names; return usb_device_names;
@ -110,48 +129,16 @@ void bx_usbdev_ctl_c::list_devices(void)
bool bx_usbdev_ctl_c::init_device(bx_list_c *portconf, logfunctions *hub, void **dev) bool bx_usbdev_ctl_c::init_device(bx_list_c *portconf, logfunctions *hub, void **dev)
{ {
usbmod_type modtype = USB_MOD_TYPE_NONE; Bit8u devtype, modtype;
usbdev_type devtype = USB_DEV_TYPE_NONE;
usb_device_c **device = (usb_device_c**)dev; usb_device_c **device = (usb_device_c**)dev;
const char *devname, *options, *options2; const char *options, *options2;
char new_options[BX_PATHNAME_LEN]; char new_options[BX_PATHNAME_LEN];
bx_param_string_c *opts2; bx_param_string_c *opts2;
devname = ((bx_param_enum_c*)portconf->get_by_name("device"))->get_selected(); devtype = (Bit8u)((bx_param_enum_c*)portconf->get_by_name("device"))->get();
modtype = usb_module_id[devtype];
options = ((bx_param_string_c*)portconf->get_by_name("options"))->getptr(); options = ((bx_param_string_c*)portconf->get_by_name("options"))->getptr();
opts2 = (bx_param_string_c*)portconf->get_by_name("options2"); opts2 = (bx_param_string_c*)portconf->get_by_name("options2");
if (!strcmp(devname, "mouse")) {
modtype = USB_MOD_TYPE_HID;
devtype = USB_DEV_TYPE_MOUSE;
} else if (!strcmp(devname, "tablet")) {
modtype = USB_MOD_TYPE_HID;
devtype = USB_DEV_TYPE_TABLET;
} else if (!strcmp(devname, "keypad")) {
modtype = USB_MOD_TYPE_HID;
devtype = USB_DEV_TYPE_KEYPAD;
} else if (!strcmp(devname, "keyboard")) {
modtype = USB_MOD_TYPE_HID;
devtype = USB_DEV_TYPE_KEYBOARD;
} else if (!strcmp(devname, "disk")) {
modtype = USB_MOD_TYPE_MSD;
devtype = USB_DEV_TYPE_DISK;
} else if (!strcmp(devname, "cdrom")) {
modtype = USB_MOD_TYPE_MSD;
devtype = USB_DEV_TYPE_CDROM;
} else if (!strcmp(devname, "hub")) {
modtype = USB_MOD_TYPE_HUB;
devtype = USB_DEV_TYPE_HUB;
} else if (!strcmp(devname, "printer")) {
modtype = USB_MOD_TYPE_PRINTER;
devtype = USB_DEV_TYPE_PRINTER;
} else if (!strncmp(devname, "floppy", 6)) {
modtype = USB_MOD_TYPE_CBI;
devtype = USB_DEV_TYPE_FLOPPY;
} else {
hub->panic("unknown USB device: %s", devname);
delete [] devname;
return devtype;
}
if (opts2 != NULL) { if (opts2 != NULL) {
// backward compatibility code // backward compatibility code
options2 = opts2->getptr(); options2 = opts2->getptr();
@ -163,14 +150,15 @@ bool bx_usbdev_ctl_c::init_device(bx_list_c *portconf, logfunctions *hub, void *
((bx_param_string_c*)portconf->get_by_name("options"))->set(new_options); ((bx_param_string_c*)portconf->get_by_name("options"))->set(new_options);
portconf->remove("options2"); portconf->remove("options2");
} }
if (!usbdev_locator_c::module_present(usbmod_names[modtype])) { if (!usbdev_locator_c::module_present(usb_module_names[modtype])) {
#if BX_PLUGINS #if BX_PLUGINS
PLUG_load_plugin_var(usbmod_names[modtype], PLUGTYPE_USB); PLUG_load_plugin_var(usb_module_names[modtype], PLUGTYPE_USB);
#else #else
BX_PANIC(("could not find USB device '%s'", usbmod_names[modtype])); BX_PANIC(("could not find USB module '%s'", usb_module_names[modtype]));
#endif #endif
} }
*device = usbdev_locator_c::create(usbmod_names[modtype], devtype); *device = usbdev_locator_c::create(usb_module_names[modtype],
usb_device_names[devtype]);
if (*device != NULL) { if (*device != NULL) {
parse_port_options(*device, portconf); parse_port_options(*device, portconf);
} }
@ -181,9 +169,11 @@ void bx_usbdev_ctl_c::parse_port_options(usb_device_c *device, bx_list_c *portco
{ {
const char *raw_options; const char *raw_options;
int i, optc, speed = USB_SPEED_LOW; // assume LOW speed device if parameter not given. int i, optc, speed = USB_SPEED_LOW; // assume LOW speed device if parameter not given.
Bit8u devtype;
char *opts[16]; char *opts[16];
memset(opts, 0, sizeof(opts)); memset(opts, 0, sizeof(opts));
devtype = ((bx_param_enum_c*)portconf->get_by_name("device"))->get();
raw_options = ((bx_param_string_c*)portconf->get_by_name("options"))->getptr(); raw_options = ((bx_param_string_c*)portconf->get_by_name("options"))->getptr();
optc = bx_split_option_list("USB port options", raw_options, opts, 16); optc = bx_split_option_list("USB port options", raw_options, opts, 16);
for (i = 0; i < optc; i++) { for (i = 0; i < optc; i++) {
@ -201,7 +191,7 @@ void bx_usbdev_ctl_c::parse_port_options(usb_device_c *device, bx_list_c *portco
} }
if (!device->set_speed(speed)) { if (!device->set_speed(speed)) {
BX_PANIC(("USB device '%s' doesn't support '%s' speed", BX_PANIC(("USB device '%s' doesn't support '%s' speed",
usb_device_names[device->get_type()], opts[i]+6)); usb_device_names[devtype], opts[i]+6));
} }
} else if (!strcmp(opts[i], "debug")) { } else if (!strcmp(opts[i], "debug")) {
device->set_debug_mode(); device->set_debug_mode();
@ -275,13 +265,13 @@ void usbdev_locator_c::cleanup()
// Called by USB HC emulations to locate and create a usb_device_c // Called by USB HC emulations to locate and create a usb_device_c
// object // object
// //
usb_device_c* usbdev_locator_c::create(const char *type, usbdev_type devtype) usb_device_c* usbdev_locator_c::create(const char *type, const char *devname)
{ {
usbdev_locator_c *ptr = 0; usbdev_locator_c *ptr = 0;
for (ptr = all; ptr != NULL; ptr = ptr->next) { for (ptr = all; ptr != NULL; ptr = ptr->next) {
if (strcmp(type, ptr->type) == 0) if (strcmp(type, ptr->type) == 0)
return (ptr->allocate(devtype)); return (ptr->allocate(devname));
} }
return NULL; return NULL;
} }

30
bochs/iodev/usb/usb_common.h
View File

@ -146,28 +146,6 @@ typedef struct USBAsync {
struct USBAsync *next; struct USBAsync *next;
} USBAsync; } USBAsync;
enum usbmod_type {
USB_MOD_TYPE_NONE=0,
USB_MOD_TYPE_CBI,
USB_MOD_TYPE_HID,
USB_MOD_TYPE_HUB,
USB_MOD_TYPE_MSD,
USB_MOD_TYPE_PRINTER
};
enum usbdev_type {
USB_DEV_TYPE_NONE=0,
USB_DEV_TYPE_MOUSE,
USB_DEV_TYPE_TABLET,
USB_DEV_TYPE_KEYPAD,
USB_DEV_TYPE_KEYBOARD,
USB_DEV_TYPE_DISK,
USB_DEV_TYPE_CDROM,
USB_DEV_TYPE_HUB,
USB_DEV_TYPE_PRINTER,
USB_DEV_TYPE_FLOPPY
};
class BOCHSAPI bx_usbdev_ctl_c : public logfunctions { class BOCHSAPI bx_usbdev_ctl_c : public logfunctions {
public: public:
bx_usbdev_ctl_c(); bx_usbdev_ctl_c();
@ -182,7 +160,6 @@ private:
}; };
BOCHSAPI extern bx_usbdev_ctl_c bx_usbdev_ctl; BOCHSAPI extern bx_usbdev_ctl_c bx_usbdev_ctl;
BOCHSAPI extern const char *usb_device_names[];
class BOCHSAPI usb_device_c : public logfunctions { class BOCHSAPI usb_device_c : public logfunctions {
public: public:
@ -205,7 +182,6 @@ public:
virtual void runtime_config() {} virtual void runtime_config() {}
bool get_connected() {return d.connected;} bool get_connected() {return d.connected;}
int get_type() {return (int)d.type;}
int get_speed() {return d.speed;} int get_speed() {return d.speed;}
bool set_speed(int speed) bool set_speed(int speed)
{ {
@ -231,7 +207,7 @@ public:
protected: protected:
struct { struct {
enum usbdev_type type; Bit8u type;
bool connected; bool connected;
int minspeed; int minspeed;
int maxspeed; int maxspeed;
@ -389,11 +365,11 @@ class BOCHSAPI_MSVCONLY usbdev_locator_c {
public: public:
static bool module_present(const char *type); static bool module_present(const char *type);
static void cleanup(); static void cleanup();
static usb_device_c *create(const char *type, usbdev_type devtype); static usb_device_c *create(const char *type, const char *devname);
protected: protected:
usbdev_locator_c(const char *type); usbdev_locator_c(const char *type);
virtual ~usbdev_locator_c(); virtual ~usbdev_locator_c();
virtual usb_device_c *allocate(usbdev_type devtype) = 0; virtual usb_device_c *allocate(const char *devname) = 0;
private: private:
static usbdev_locator_c *all; static usbdev_locator_c *all;
usbdev_locator_c *next; usbdev_locator_c *next;

102
bochs/iodev/usb/usb_hid.cc
View File

@ -78,11 +78,17 @@ class bx_usb_hid_locator_c : public usbdev_locator_c {
public: public:
bx_usb_hid_locator_c(void) : usbdev_locator_c("usb_hid") {} bx_usb_hid_locator_c(void) : usbdev_locator_c("usb_hid") {}
protected: protected:
usb_device_c *allocate(usbdev_type devtype) { usb_device_c *allocate(const char *devtype) {
return (new usb_hid_device_c(devtype)); return (new usb_hid_device_c(devtype));
} }
} bx_usb_hid_match; } bx_usb_hid_match;
/* supported HID device types */
#define USB_HID_TYPE_MOUSE 0
#define USB_HID_TYPE_TABLET 1
#define USB_HID_TYPE_KEYPAD 2
#define USB_HID_TYPE_KEYBOARD 3
/* HID IDLE time constant */ /* HID IDLE time constant */
#define HID_IDLE_TIME 4000 #define HID_IDLE_TIME 4000
@ -682,27 +688,35 @@ struct USBKBD usbkbd_conv[BX_KEY_NBKEYS] = {
0x00, 0 /* BX_KEY_WAKE */ 0x00, 0 /* BX_KEY_WAKE */
}; };
usb_hid_device_c::usb_hid_device_c(usbdev_type type) usb_hid_device_c::usb_hid_device_c(const char *devname)
{ {
d.type = type; if (!strcmp(devname, "mouse")) {
d.type = USB_HID_TYPE_MOUSE;
} else if (!strcmp(devname, "tablet")) {
d.type = USB_HID_TYPE_TABLET;
} else if (!strcmp(devname, "keypad")) {
d.type = USB_HID_TYPE_KEYPAD;
} else {
d.type = USB_HID_TYPE_KEYBOARD;
}
d.minspeed = USB_SPEED_LOW; d.minspeed = USB_SPEED_LOW;
d.maxspeed = USB_SPEED_HIGH; d.maxspeed = USB_SPEED_HIGH;
d.speed = d.minspeed; d.speed = d.minspeed;
if (d.type == USB_DEV_TYPE_MOUSE) { if (d.type == USB_HID_TYPE_MOUSE) {
strcpy(d.devname, "USB Mouse"); strcpy(d.devname, "USB Mouse");
DEV_register_removable_mouse((void*)this, mouse_enq_static, mouse_enabled_changed); DEV_register_removable_mouse((void*)this, mouse_enq_static, mouse_enabled_changed);
} else if (d.type == USB_DEV_TYPE_TABLET) { } else if (d.type == USB_HID_TYPE_TABLET) {
strcpy(d.devname, "USB Tablet"); strcpy(d.devname, "USB Tablet");
DEV_register_removable_mouse((void*)this, mouse_enq_static, mouse_enabled_changed); DEV_register_removable_mouse((void*)this, mouse_enq_static, mouse_enabled_changed);
bx_gui->set_mouse_mode_absxy(1); bx_gui->set_mouse_mode_absxy(1);
} else if ((d.type == USB_DEV_TYPE_KEYPAD) || (d.type == USB_DEV_TYPE_KEYBOARD)) { } else if ((d.type == USB_HID_TYPE_KEYPAD) || (d.type == USB_HID_TYPE_KEYBOARD)) {
Bit8u led_mask; Bit8u led_mask;
if (d.type == USB_DEV_TYPE_KEYPAD) { if (d.type == USB_HID_TYPE_KEYPAD) {
strcpy(d.devname, "USB/PS2 Keypad"); strcpy(d.devname, "USB/PS2 Keypad");
} else { } else {
strcpy(d.devname, "USB/PS2 Keyboard"); strcpy(d.devname, "USB/PS2 Keyboard");
} }
if (d.type == USB_DEV_TYPE_KEYPAD) { if (d.type == USB_HID_TYPE_KEYPAD) {
led_mask = BX_KBD_LED_MASK_NUM; led_mask = BX_KBD_LED_MASK_NUM;
} else { } else {
led_mask = BX_KBD_LED_MASK_ALL; led_mask = BX_KBD_LED_MASK_ALL;
@ -723,12 +737,12 @@ usb_hid_device_c::usb_hid_device_c(usbdev_type type)
usb_hid_device_c::~usb_hid_device_c(void) usb_hid_device_c::~usb_hid_device_c(void)
{ {
d.sr->clear(); d.sr->clear();
if ((d.type == USB_DEV_TYPE_MOUSE) || if ((d.type == USB_HID_TYPE_MOUSE) ||
(d.type == USB_DEV_TYPE_TABLET)) { (d.type == USB_HID_TYPE_TABLET)) {
bx_gui->set_mouse_mode_absxy(0); bx_gui->set_mouse_mode_absxy(0);
DEV_unregister_removable_mouse((void*)this); DEV_unregister_removable_mouse((void*)this);
} else if ((d.type == USB_DEV_TYPE_KEYPAD) || } else if ((d.type == USB_HID_TYPE_KEYPAD) ||
(d.type == USB_DEV_TYPE_KEYBOARD)) { (d.type == USB_HID_TYPE_KEYBOARD)) {
DEV_unregister_removable_keyboard((void*)this); DEV_unregister_removable_keyboard((void*)this);
} }
bx_pc_system.unregisterTimer(timer_index); bx_pc_system.unregisterTimer(timer_index);
@ -736,8 +750,8 @@ usb_hid_device_c::~usb_hid_device_c(void)
bool usb_hid_device_c::init() bool usb_hid_device_c::init()
{ {
if ((d.type == USB_DEV_TYPE_MOUSE) || if ((d.type == USB_HID_TYPE_MOUSE) ||
(d.type == USB_DEV_TYPE_TABLET)) { (d.type == USB_HID_TYPE_TABLET)) {
if (d.speed == USB_SPEED_HIGH) { if (d.speed == USB_SPEED_HIGH) {
d.dev_descriptor = bx_mouse_dev_descriptor2; d.dev_descriptor = bx_mouse_dev_descriptor2;
d.device_desc_size = sizeof(bx_mouse_dev_descriptor2); d.device_desc_size = sizeof(bx_mouse_dev_descriptor2);
@ -745,7 +759,7 @@ bool usb_hid_device_c::init()
d.dev_descriptor = bx_mouse_dev_descriptor; d.dev_descriptor = bx_mouse_dev_descriptor;
d.device_desc_size = sizeof(bx_mouse_dev_descriptor); d.device_desc_size = sizeof(bx_mouse_dev_descriptor);
} }
if (d.type == USB_DEV_TYPE_MOUSE) { if (d.type == USB_HID_TYPE_MOUSE) {
if (d.speed == USB_SPEED_HIGH) { if (d.speed == USB_SPEED_HIGH) {
d.config_descriptor = bx_mouse_config_descriptor2; d.config_descriptor = bx_mouse_config_descriptor2;
d.config_desc_size = sizeof(bx_mouse_config_descriptor2); d.config_desc_size = sizeof(bx_mouse_config_descriptor2);
@ -797,7 +811,7 @@ void usb_hid_device_c::register_state_specific(bx_list_c *parent)
BXRS_HEX_PARAM_FIELD(list, b_state, s.b_state); BXRS_HEX_PARAM_FIELD(list, b_state, s.b_state);
BXRS_DEC_PARAM_FIELD(list, mouse_event_count, s.mouse_event_count); BXRS_DEC_PARAM_FIELD(list, mouse_event_count, s.mouse_event_count);
new bx_shadow_data_c(list, "mouse_event_buf", (Bit8u*)s.mouse_event_buf, 6 * BX_KBD_ELEMENTS, 1); new bx_shadow_data_c(list, "mouse_event_buf", (Bit8u*)s.mouse_event_buf, 6 * BX_KBD_ELEMENTS, 1);
if ((d.type == USB_DEV_TYPE_KEYPAD) || (d.type == USB_DEV_TYPE_KEYBOARD)) { if ((d.type == USB_HID_TYPE_KEYPAD) || (d.type == USB_HID_TYPE_KEYBOARD)) {
new bx_shadow_data_c(list, "kbd_packet", s.kbd_packet, 8, 1); new bx_shadow_data_c(list, "kbd_packet", s.kbd_packet, 8, 1);
BXRS_HEX_PARAM_FIELD(list, indicators, s.indicators); BXRS_HEX_PARAM_FIELD(list, indicators, s.indicators);
BXRS_DEC_PARAM_FIELD(list, kbd_event_count, s.kbd_event_count); BXRS_DEC_PARAM_FIELD(list, kbd_event_count, s.kbd_event_count);
@ -858,16 +872,16 @@ int usb_hid_device_c::handle_control(int request, int value, int index, int leng
case InterfaceRequest | USB_REQ_GET_DESCRIPTOR: case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
switch(value >> 8) { switch(value >> 8) {
case 0x21: case 0x21:
if (d.type == USB_DEV_TYPE_MOUSE) { if (d.type == USB_HID_TYPE_MOUSE) {
memcpy(data, bx_mouse_hid_descriptor, memcpy(data, bx_mouse_hid_descriptor,
sizeof(bx_mouse_hid_descriptor)); sizeof(bx_mouse_hid_descriptor));
ret = sizeof(bx_mouse_hid_descriptor); ret = sizeof(bx_mouse_hid_descriptor);
} else if (d.type == USB_DEV_TYPE_TABLET) { } else if (d.type == USB_HID_TYPE_TABLET) {
memcpy(data, bx_tablet_hid_descriptor, memcpy(data, bx_tablet_hid_descriptor,
sizeof(bx_tablet_hid_descriptor)); sizeof(bx_tablet_hid_descriptor));
ret = sizeof(bx_tablet_hid_descriptor); ret = sizeof(bx_tablet_hid_descriptor);
} else if ((d.type == USB_DEV_TYPE_KEYPAD) || } else if ((d.type == USB_HID_TYPE_KEYPAD) ||
(d.type == USB_DEV_TYPE_KEYBOARD)) { (d.type == USB_HID_TYPE_KEYBOARD)) {
memcpy(data, bx_keypad_hid_descriptor, memcpy(data, bx_keypad_hid_descriptor,
sizeof(bx_keypad_hid_descriptor)); sizeof(bx_keypad_hid_descriptor));
ret = sizeof(bx_keypad_hid_descriptor); ret = sizeof(bx_keypad_hid_descriptor);
@ -876,16 +890,16 @@ int usb_hid_device_c::handle_control(int request, int value, int index, int leng
} }
break; break;
case 0x22: case 0x22:
if (d.type == USB_DEV_TYPE_MOUSE) { if (d.type == USB_HID_TYPE_MOUSE) {
memcpy(data, bx_mouse_hid_report_descriptor, memcpy(data, bx_mouse_hid_report_descriptor,
sizeof(bx_mouse_hid_report_descriptor)); sizeof(bx_mouse_hid_report_descriptor));
ret = sizeof(bx_mouse_hid_report_descriptor); ret = sizeof(bx_mouse_hid_report_descriptor);
} else if (d.type == USB_DEV_TYPE_TABLET) { } else if (d.type == USB_HID_TYPE_TABLET) {
memcpy(data, bx_tablet_hid_report_descriptor, memcpy(data, bx_tablet_hid_report_descriptor,
sizeof(bx_tablet_hid_report_descriptor)); sizeof(bx_tablet_hid_report_descriptor));
ret = sizeof(bx_tablet_hid_report_descriptor); ret = sizeof(bx_tablet_hid_report_descriptor);
} else if ((d.type == USB_DEV_TYPE_KEYPAD) || } else if ((d.type == USB_HID_TYPE_KEYPAD) ||
(d.type == USB_DEV_TYPE_KEYBOARD)) { (d.type == USB_HID_TYPE_KEYBOARD)) {
memcpy(data, bx_keypad_hid_report_descriptor, memcpy(data, bx_keypad_hid_report_descriptor,
sizeof(bx_keypad_hid_report_descriptor)); sizeof(bx_keypad_hid_report_descriptor));
ret = sizeof(bx_keypad_hid_report_descriptor); ret = sizeof(bx_keypad_hid_report_descriptor);
@ -907,25 +921,25 @@ int usb_hid_device_c::handle_control(int request, int value, int index, int leng
} }
break; break;
case GET_REPORT: case GET_REPORT:
if ((d.type == USB_DEV_TYPE_MOUSE) || if ((d.type == USB_HID_TYPE_MOUSE) ||
(d.type == USB_DEV_TYPE_TABLET)) { (d.type == USB_HID_TYPE_TABLET)) {
ret = mouse_poll(data, length, 1); ret = mouse_poll(data, length, 1);
} else if ((d.type == USB_DEV_TYPE_KEYPAD) || } else if ((d.type == USB_HID_TYPE_KEYPAD) ||
(d.type == USB_DEV_TYPE_KEYBOARD)) { (d.type == USB_HID_TYPE_KEYBOARD)) {
ret = keyboard_poll(data, length, 1); ret = keyboard_poll(data, length, 1);
} else { } else {
goto fail; goto fail;
} }
break; break;
case SET_REPORT: case SET_REPORT:
if (((d.type == USB_DEV_TYPE_KEYPAD) || if (((d.type == USB_HID_TYPE_KEYPAD) ||
(d.type == USB_DEV_TYPE_KEYBOARD)) && (value = 0x200)) { (d.type == USB_HID_TYPE_KEYBOARD)) && (value = 0x200)) {
modchange = (data[0] ^ s.indicators); modchange = (data[0] ^ s.indicators);
if (modchange != 0) { if (modchange != 0) {
if (modchange & 0x01) { if (modchange & 0x01) {
DEV_kbd_set_indicator(1, BX_KBD_LED_NUM, data[0] & 0x01); DEV_kbd_set_indicator(1, BX_KBD_LED_NUM, data[0] & 0x01);
BX_DEBUG(("NUM_LOCK %s", (data[0] & 0x01) ? "on" : "off")); BX_DEBUG(("NUM_LOCK %s", (data[0] & 0x01) ? "on" : "off"));
} else if (d.type == USB_DEV_TYPE_KEYBOARD) { } else if (d.type == USB_HID_TYPE_KEYBOARD) {
if (modchange & 0x02) { if (modchange & 0x02) {
DEV_kbd_set_indicator(1, BX_KBD_LED_CAPS, data[0] & 0x02); DEV_kbd_set_indicator(1, BX_KBD_LED_CAPS, data[0] & 0x02);
BX_DEBUG(("CAPS_LOCK %s", (data[0] & 0x02) ? "on" : "off")); BX_DEBUG(("CAPS_LOCK %s", (data[0] & 0x02) ? "on" : "off"));
@ -970,11 +984,11 @@ int usb_hid_device_c::handle_data(USBPacket *p)
switch(p->pid) { switch(p->pid) {
case USB_TOKEN_IN: case USB_TOKEN_IN:
if (p->devep == 1) { if (p->devep == 1) {
if ((d.type == USB_DEV_TYPE_MOUSE) || if ((d.type == USB_HID_TYPE_MOUSE) ||
(d.type == USB_DEV_TYPE_TABLET)) { (d.type == USB_HID_TYPE_TABLET)) {
ret = mouse_poll(p->data, p->len, 0); ret = mouse_poll(p->data, p->len, 0);
} else if ((d.type == USB_DEV_TYPE_KEYPAD) || } else if ((d.type == USB_HID_TYPE_KEYPAD) ||
(d.type == USB_DEV_TYPE_KEYBOARD)) { (d.type == USB_HID_TYPE_KEYBOARD)) {
ret = keyboard_poll(p->data, p->len, 0); ret = keyboard_poll(p->data, p->len, 0);
} else { } else {
goto fail; goto fail;
@ -998,7 +1012,7 @@ int usb_hid_device_c::mouse_poll(Bit8u *buf, int len, bool force)
{ {
int l = USB_RET_NAK; int l = USB_RET_NAK;
if (d.type == USB_DEV_TYPE_MOUSE) { if (d.type == USB_HID_TYPE_MOUSE) {
if (!s.has_events) { if (!s.has_events) {
// if there's no new movement, handle delayed one // if there's no new movement, handle delayed one
mouse_enq(0, 0, s.mouse_z, s.b_state, 0); mouse_enq(0, 0, s.mouse_z, s.b_state, 0);
@ -1012,7 +1026,7 @@ int usb_hid_device_c::mouse_poll(Bit8u *buf, int len, bool force)
s.has_events = (s.mouse_event_count > 0); s.has_events = (s.mouse_event_count > 0);
start_idle_timer(); start_idle_timer();
} }
} else if (d.type == USB_DEV_TYPE_TABLET) { } else if (d.type == USB_HID_TYPE_TABLET) {
if (s.has_events || force) { if (s.has_events || force) {
if (s.mouse_event_count > 0) { if (s.mouse_event_count > 0) {
l = get_mouse_packet(buf, len); l = get_mouse_packet(buf, len);
@ -1030,7 +1044,7 @@ int usb_hid_device_c::create_mouse_packet(Bit8u *buf, int len)
{ {
int l; int l;
if (d.type == USB_DEV_TYPE_TABLET) { if (d.type == USB_HID_TYPE_TABLET) {
buf[0] = (Bit8u) s.b_state; buf[0] = (Bit8u) s.b_state;
buf[1] = (Bit8u)(s.mouse_x & 0xff); buf[1] = (Bit8u)(s.mouse_x & 0xff);
buf[2] = (Bit8u)(s.mouse_x >> 8); buf[2] = (Bit8u)(s.mouse_x >> 8);
@ -1059,7 +1073,7 @@ int usb_hid_device_c::get_mouse_packet(Bit8u *buf, int len)
int l = USB_RET_NAK; int l = USB_RET_NAK;
if (s.mouse_event_count > 0) { if (s.mouse_event_count > 0) {
if (d.type == USB_DEV_TYPE_TABLET) { if (d.type == USB_HID_TYPE_TABLET) {
l = 6; l = 6;
} else if (len >= 4) { } else if (len >= 4) {
l = 4; l = 4;
@ -1089,7 +1103,7 @@ void usb_hid_device_c::mouse_enq(int delta_x, int delta_y, int delta_z, unsigned
{ {
Bit16s prev_x, prev_y; Bit16s prev_x, prev_y;
if (d.type == USB_DEV_TYPE_MOUSE) { if (d.type == USB_HID_TYPE_MOUSE) {
// scale down the motion // scale down the motion
if ((delta_x < -1) || (delta_x > 1)) if ((delta_x < -1) || (delta_x > 1))
delta_x /= 2; delta_x /= 2;
@ -1135,7 +1149,7 @@ void usb_hid_device_c::mouse_enq(int delta_x, int delta_y, int delta_z, unsigned
} }
s.has_events = 1; s.has_events = 1;
} }
} else if (d.type == USB_DEV_TYPE_TABLET) { } else if (d.type == USB_HID_TYPE_TABLET) {
prev_x = s.mouse_x; prev_x = s.mouse_x;
prev_y = s.mouse_y; prev_y = s.mouse_y;
if (absxy) { if (absxy) {
@ -1167,8 +1181,8 @@ int usb_hid_device_c::keyboard_poll(Bit8u *buf, int len, bool force)
{ {
int l = USB_RET_NAK; int l = USB_RET_NAK;
if ((d.type == USB_DEV_TYPE_KEYPAD) || if ((d.type == USB_HID_TYPE_KEYPAD) ||
(d.type == USB_DEV_TYPE_KEYBOARD)) { (d.type == USB_HID_TYPE_KEYBOARD)) {
if (s.has_events || force) { if (s.has_events || force) {
memcpy(buf, s.kbd_packet, len); memcpy(buf, s.kbd_packet, len);
l = 8; l = 8;
@ -1198,7 +1212,7 @@ bool usb_hid_device_c::gen_scancode(Bit32u key)
code = usbkbd_conv[key & ~BX_KEY_RELEASED].code; code = usbkbd_conv[key & ~BX_KEY_RELEASED].code;
modkey = usbkbd_conv[key & ~BX_KEY_RELEASED].modkey; modkey = usbkbd_conv[key & ~BX_KEY_RELEASED].modkey;
if (d.type == USB_DEV_TYPE_KEYPAD) { if (d.type == USB_HID_TYPE_KEYPAD) {
if ((code < 0x53) || (code > 0x63)) { if ((code < 0x53) || (code > 0x63)) {
return 0; return 0;
} }

2
bochs/iodev/usb/usb_hid.h
View File

@ -35,7 +35,7 @@
class usb_hid_device_c : public usb_device_c { class usb_hid_device_c : public usb_device_c {
public: public:
usb_hid_device_c(usbdev_type type); usb_hid_device_c(const char *devname);
virtual ~usb_hid_device_c(void); virtual ~usb_hid_device_c(void);
virtual bool init(); virtual bool init();

11
bochs/iodev/usb/usb_hub.cc
View File

@ -57,7 +57,7 @@ class bx_usb_hub_locator_c : public usbdev_locator_c {
public: public:
bx_usb_hub_locator_c(void) : usbdev_locator_c("usb_hub") {} bx_usb_hub_locator_c(void) : usbdev_locator_c("usb_hub") {}
protected: protected:
usb_device_c *allocate(usbdev_type devtype) { usb_device_c *allocate(const char *devname) {
return (new usb_hub_device_c()); return (new usb_hub_device_c());
} }
} bx_usb_hub_match; } bx_usb_hub_match;
@ -196,7 +196,6 @@ usb_hub_device_c::usb_hub_device_c()
char pname[10]; char pname[10];
char label[32]; char label[32];
d.type = USB_DEV_TYPE_HUB;
d.speed = d.minspeed = d.maxspeed = USB_SPEED_FULL; d.speed = d.minspeed = d.maxspeed = USB_SPEED_FULL;
strcpy(d.devname, "Bochs USB HUB"); strcpy(d.devname, "Bochs USB HUB");
d.dev_descriptor = bx_hub_dev_descriptor; d.dev_descriptor = bx_hub_dev_descriptor;
@ -269,9 +268,11 @@ bool usb_hub_device_c::init()
sprintf(label, "Port #%d Configuration", i+1); sprintf(label, "Port #%d Configuration", i+1);
port = new bx_list_c(hub.config, pname, label); port = new bx_list_c(hub.config, pname, label);
port->set_options(port->SERIES_ASK | port->USE_BOX_TITLE); port->set_options(port->SERIES_ASK | port->USE_BOX_TITLE);
device = new bx_param_enum_c(port, "device", "Device", "", usb_device_names, 0, 0); device = new bx_param_enum_c(port, "device", "Device", "",
bx_usbdev_ctl.get_device_names(), 0, 0);
device->set_handler(hub_param_handler); device->set_handler(hub_param_handler);
options = new bx_param_string_c(port, "options", "Options", "", "", BX_PATHNAME_LEN); options = new bx_param_string_c(port, "options", "Options", "", "",
BX_PATHNAME_LEN);
deplist = new bx_list_c(NULL); deplist = new bx_list_c(NULL);
deplist->add(options); deplist->add(options);
device->set_dependent_list(deplist, 1); device->set_dependent_list(deplist, 1);
@ -281,7 +282,7 @@ bool usb_hub_device_c::init()
bx_list_c *usb = (bx_list_c*)SIM->get_param("ports.usb"); bx_list_c *usb = (bx_list_c*)SIM->get_param("ports.usb");
usb->add(hub.config); usb->add(hub.config);
} }
sprintf(hub.info_txt, "ports = %d", hub.n_ports); sprintf(hub.info_txt, "%d-port USB hub", hub.n_ports);
d.connected = 1; d.connected = 1;
return 1; return 1;
} }

2
bochs/iodev/usb/usb_hub.h
View File

@ -59,7 +59,7 @@ private:
bx_list_c *config; bx_list_c *config;
bx_list_c *state; bx_list_c *state;
char serial_number[16]; char serial_number[16];
char info_txt[16]; char info_txt[18];
struct { struct {
// our data // our data
usb_device_c *device; // device connected to this port usb_device_c *device; // device connected to this port

37
bochs/iodev/usb/usb_msd.cc
View File

@ -57,11 +57,14 @@ class bx_usb_msd_locator_c : public usbdev_locator_c {
public: public:
bx_usb_msd_locator_c(void) : usbdev_locator_c("usb_msd") {} bx_usb_msd_locator_c(void) : usbdev_locator_c("usb_msd") {}
protected: protected:
usb_device_c *allocate(usbdev_type devtype) { usb_device_c *allocate(const char *devname) {
return (new usb_msd_device_c(devtype)); return (new usb_msd_device_c(devname));
} }
} bx_usb_msd_match; } bx_usb_msd_match;
#define USB_MSD_TYPE_DISK 0
#define USB_MSD_TYPE_CDROM 1
enum USBMSDMode { enum USBMSDMode {
USB_MSDM_CBW, USB_MSDM_CBW,
USB_MSDM_DATAOUT, USB_MSDM_DATAOUT,
@ -333,26 +336,30 @@ void usb_msd_restore_handler(void *dev, bx_list_c *conf);
static Bit8u usb_cdrom_count = 0; static Bit8u usb_cdrom_count = 0;
usb_msd_device_c::usb_msd_device_c(usbdev_type type) usb_msd_device_c::usb_msd_device_c(const char *devname)
{ {
char pname[10]; char pname[10];
char label[32]; char label[32];
bx_param_string_c *path; bx_param_string_c *path;
bx_param_enum_c *status; bx_param_enum_c *status;
d.type = type; if (!strcmp(devname, "disk")) {
d.type = USB_MSD_TYPE_DISK;
} else {
d.type = USB_MSD_TYPE_CDROM;
}
d.minspeed = USB_SPEED_FULL; d.minspeed = USB_SPEED_FULL;
d.maxspeed = USB_SPEED_SUPER; d.maxspeed = USB_SPEED_SUPER;
d.speed = d.minspeed; d.speed = d.minspeed;
memset((void*)&s, 0, sizeof(s)); memset((void*)&s, 0, sizeof(s));
if (d.type == USB_DEV_TYPE_DISK) { if (d.type == USB_MSD_TYPE_DISK) {
strcpy(d.devname, "BOCHS USB HARDDRIVE"); strcpy(d.devname, "BOCHS USB HARDDRIVE");
s.fname[0] = 0; s.fname[0] = 0;
s.image_mode = strdup("flat"); s.image_mode = strdup("flat");
s.journal[0] = 0; s.journal[0] = 0;
s.size = 0; s.size = 0;
s.sect_size = 512; s.sect_size = 512;
} else if (d.type == USB_DEV_TYPE_CDROM) { } else if (d.type == USB_MSD_TYPE_CDROM) {
strcpy(d.devname, "BOCHS USB CDROM"); strcpy(d.devname, "BOCHS USB CDROM");
// config options // config options
bx_list_c *usb_rt = (bx_list_c*)SIM->get_param(BXPN_MENU_RUNTIME_USB); bx_list_c *usb_rt = (bx_list_c*)SIM->get_param(BXPN_MENU_RUNTIME_USB);
@ -412,7 +419,7 @@ bool usb_msd_device_c::set_option(const char *option)
if (!strncmp(option, "path:", 5)) { if (!strncmp(option, "path:", 5)) {
strcpy(filename, option+5); strcpy(filename, option+5);
if (d.type == USB_DEV_TYPE_DISK) { if (d.type == USB_MSD_TYPE_DISK) {
ptr1 = strtok(filename, ":"); ptr1 = strtok(filename, ":");
ptr2 = strtok(NULL, ":"); ptr2 = strtok(NULL, ":");
if ((ptr2 == NULL) || (strlen(ptr1) < 2)) { if ((ptr2 == NULL) || (strlen(ptr1) < 2)) {
@ -430,14 +437,14 @@ bool usb_msd_device_c::set_option(const char *option)
} }
return 1; return 1;
} else if (!strncmp(option, "journal:", 8)) { } else if (!strncmp(option, "journal:", 8)) {
if (d.type == USB_DEV_TYPE_DISK) { if (d.type == USB_MSD_TYPE_DISK) {
strcpy(s.journal, option+8); strcpy(s.journal, option+8);
return 1; return 1;
} else { } else {
BX_ERROR(("Option 'journal' is only valid for USB disks")); BX_ERROR(("Option 'journal' is only valid for USB disks"));
} }
} else if (!strncmp(option, "size:", 5)) { } else if (!strncmp(option, "size:", 5)) {
if ((d.type == USB_DEV_TYPE_DISK) && (!strcmp(s.image_mode, "vvfat"))) { if ((d.type == USB_MSD_TYPE_DISK) && (!strcmp(s.image_mode, "vvfat"))) {
s.size = (int)strtol(option+5, &suffix, 10); s.size = (int)strtol(option+5, &suffix, 10);
if (!strcmp(suffix, "G")) { if (!strcmp(suffix, "G")) {
s.size <<= 10; s.size <<= 10;
@ -456,7 +463,7 @@ bool usb_msd_device_c::set_option(const char *option)
BX_ERROR(("Option 'size' is only valid for USB VVFAT disks")); BX_ERROR(("Option 'size' is only valid for USB VVFAT disks"));
} }
} else if (!strncmp(option, "sect_size:", 10)) { } else if (!strncmp(option, "sect_size:", 10)) {
if (d.type == USB_DEV_TYPE_DISK) { if (d.type == USB_MSD_TYPE_DISK) {
s.sect_size = (unsigned)strtol(option+10, &suffix, 10); s.sect_size = (unsigned)strtol(option+10, &suffix, 10);
if (strlen(suffix) > 0) { if (strlen(suffix) > 0) {
BX_ERROR(("Option 'sect_size': ignoring extra data")); BX_ERROR(("Option 'sect_size': ignoring extra data"));
@ -475,7 +482,7 @@ bool usb_msd_device_c::set_option(const char *option)
bool usb_msd_device_c::init() bool usb_msd_device_c::init()
{ {
if (d.type == USB_DEV_TYPE_DISK) { if (d.type == USB_MSD_TYPE_DISK) {
if (strlen(s.fname) > 0) { if (strlen(s.fname) > 0) {
s.hdimage = DEV_hdimage_init_image(s.image_mode, 0, s.journal); s.hdimage = DEV_hdimage_init_image(s.image_mode, 0, s.journal);
if (!strcmp(s.image_mode, "vvfat")) { if (!strcmp(s.image_mode, "vvfat")) {
@ -499,7 +506,7 @@ bool usb_msd_device_c::init()
BX_ERROR(("USB HD: disk image not specified")); BX_ERROR(("USB HD: disk image not specified"));
return 0; return 0;
} }
} else if (d.type == USB_DEV_TYPE_CDROM) { } else if (d.type == USB_MSD_TYPE_CDROM) {
s.cdrom = DEV_hdimage_init_cdrom(s.fname); s.cdrom = DEV_hdimage_init_cdrom(s.fname);
s.scsi_dev = new scsi_device_t(s.cdrom, 0, usb_msd_command_complete, (void*)this); s.scsi_dev = new scsi_device_t(s.cdrom, 0, usb_msd_command_complete, (void*)this);
if (set_inserted(1)) { if (set_inserted(1)) {
@ -543,12 +550,12 @@ const char* usb_msd_device_c::get_info()
void usb_msd_device_c::register_state_specific(bx_list_c *parent) void usb_msd_device_c::register_state_specific(bx_list_c *parent)
{ {
s.sr_list = new bx_list_c(parent, "s", "USB MSD Device State"); s.sr_list = new bx_list_c(parent, "s", "USB MSD Device State");
if (d.type == USB_DEV_TYPE_CDROM) { if (d.type == USB_MSD_TYPE_CDROM) {
bx_list_c *rt_config = new bx_list_c(s.sr_list, "rt_config"); bx_list_c *rt_config = new bx_list_c(s.sr_list, "rt_config");
rt_config->add(s.config->get_by_name("path")); rt_config->add(s.config->get_by_name("path"));
rt_config->add(s.config->get_by_name("status")); rt_config->add(s.config->get_by_name("status"));
rt_config->set_restore_handler(this, usb_msd_restore_handler); rt_config->set_restore_handler(this, usb_msd_restore_handler);
} else if ((d.type == USB_DEV_TYPE_DISK) && (s.hdimage != NULL)) { } else if ((d.type == USB_MSD_TYPE_DISK) && (s.hdimage != NULL)) {
s.hdimage->register_state(s.sr_list); s.hdimage->register_state(s.sr_list);
} }
BXRS_DEC_PARAM_FIELD(s.sr_list, mode, s.mode); BXRS_DEC_PARAM_FIELD(s.sr_list, mode, s.mode);
@ -964,7 +971,7 @@ bool usb_msd_device_c::get_locked()
void usb_msd_device_c::runtime_config(void) void usb_msd_device_c::runtime_config(void)
{ {
if (d.type == USB_DEV_TYPE_CDROM) { if (d.type == USB_MSD_TYPE_CDROM) {
if (s.status_changed) { if (s.status_changed) {
set_inserted(0); set_inserted(0);
if (SIM->get_param_enum("status", s.config)->get() == BX_INSERTED) { if (SIM->get_param_enum("status", s.config)->get() == BX_INSERTED) {

2
bochs/iodev/usb/usb_msd.h
View File

@ -32,7 +32,7 @@ class scsi_device_t;
class usb_msd_device_c : public usb_device_c { class usb_msd_device_c : public usb_device_c {
public: public:
usb_msd_device_c(usbdev_type type); usb_msd_device_c(const char *devname);
virtual ~usb_msd_device_c(void); virtual ~usb_msd_device_c(void);
virtual bool init(); virtual bool init();

7
bochs/iodev/usb/usb_printer.cc
View File

@ -52,8 +52,8 @@ class bx_usb_printer_locator_c : public usbdev_locator_c {
public: public:
bx_usb_printer_locator_c(void) : usbdev_locator_c("usb_printer") {} bx_usb_printer_locator_c(void) : usbdev_locator_c("usb_printer") {}
protected: protected:
usb_device_c *allocate(usbdev_type devtype) { usb_device_c *allocate(const char *devname) {
return (new usb_printer_device_c(devtype)); return (new usb_printer_device_c());
} }
} bx_usb_printer_match; } bx_usb_printer_match;
@ -135,13 +135,12 @@ static const Bit8u bx_device_id_string[] =
static Bit8u usb_printer_count = 0; static Bit8u usb_printer_count = 0;
usb_printer_device_c::usb_printer_device_c(usbdev_type type) usb_printer_device_c::usb_printer_device_c()
{ {
char pname[12]; char pname[12];
char label[32]; char label[32];
bx_param_string_c *fname; bx_param_string_c *fname;
d.type = type;
d.speed = d.minspeed = d.maxspeed = USB_SPEED_FULL; d.speed = d.minspeed = d.maxspeed = USB_SPEED_FULL;
memset((void*)&s, 0, sizeof(s)); memset((void*)&s, 0, sizeof(s));
strcpy(d.devname, "USB Printer"); strcpy(d.devname, "USB Printer");

2
bochs/iodev/usb/usb_printer.h
View File

@ -25,7 +25,7 @@
class usb_printer_device_c : public usb_device_c { class usb_printer_device_c : public usb_device_c {
public: public:
usb_printer_device_c(usbdev_type type); usb_printer_device_c(void);
virtual ~usb_printer_device_c(void); virtual ~usb_printer_device_c(void);
virtual bool init(); virtual bool init();