mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
255143fa87
Bochs/bochs/iodev/usb_msd.cc
Volker Ruppert a342f0bfe6 - usb_msd: return status packet after partial disk write (Win98SE needs this) 
- usb_hub: removed unnecessary include
- don't accept IN and OUT packets if a device is stalled (SETUP packet clears
  this mode)
2009-04-10 20:26:14 +00:00

684 lines
19 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////
// $Id: usb_msd.cc,v 1.23 2009-04-10 20:26:14 vruppert Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2009 Volker Ruppert
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
/////////////////////////////////////////////////////////////////////////
// USB mass storage device support ported from the Qemu project
// Define BX_PLUGGABLE in files that can be compiled into plugins. For
// platforms that require a special tag on exported symbols, BX_PLUGGABLE
// is used to know when we are exporting symbols and when we are importing.
#define BX_PLUGGABLE
#define NO_DEVICE_INCLUDES
#include "iodev.h"
#if BX_SUPPORT_PCI && BX_SUPPORT_PCIUSB
#include "usb_common.h"
#include "cdrom.h"
#include "hdimage.h"
#include "scsi_device.h"
#include "usb_msd.h"
#define LOG_THIS
enum USBMSDMode {
USB_MSDM_CBW,
USB_MSDM_DATAOUT,
USB_MSDM_DATAIN,
USB_MSDM_CSW
};
struct usb_msd_cbw {
Bit32u sig;
Bit32u tag;
Bit32u data_len;
Bit8u flags;
Bit8u lun;
Bit8u cmd_len;
Bit8u cmd[16];
};
struct usb_msd_csw {
Bit32u sig;
Bit32u tag;
Bit32u residue;
Bit8u status;
};
// USB requests
#define MassStorageReset 0xff
#define GetMaxLun 0xfe
static const Bit8u bx_msd_dev_descriptor[] = {
0x12, /* u8 bLength; */
0x01, /* u8 bDescriptorType; Device */
0x00, 0x02, /* u16 bcdUSB; v2.0 */
0x00, /* u8 bDeviceClass; */
0x00, /* u8 bDeviceSubClass; */
0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
0x40, /* u8 bMaxPacketSize0; 64 Bytes */
/* Vendor and product id are arbitrary. */
0x00, 0x00, /* u16 idVendor; */
0x00, 0x00, /* u16 idProduct; */
0x00, 0x01, /* u16 bcdDevice */
0x01, /* u8 iManufacturer; */
0x02, /* u8 iProduct; */
0x03, /* u8 iSerialNumber; */
0x01 /* u8 bNumConfigurations; */
};
static const Bit8u bx_msd_config_descriptor[] = {
/* one configuration */
0x09, /* u8 bLength; */
0x02, /* u8 bDescriptorType; Configuration */
0x20, 0x00, /* u16 wTotalLength; */
0x01, /* u8 bNumInterfaces; (1) */
0x01, /* u8 bConfigurationValue; */
0x00, /* u8 iConfiguration; */
0xc0, /* u8 bmAttributes;
Bit 7: must be set,
6: Self-powered,
5: Remote wakeup,
4..0: resvd */
0x00, /* u8 MaxPower; */
/* one interface */
0x09, /* u8 if_bLength; */
0x04, /* u8 if_bDescriptorType; Interface */
0x00, /* u8 if_bInterfaceNumber; */
0x00, /* u8 if_bAlternateSetting; */
0x02, /* u8 if_bNumEndpoints; */
0x08, /* u8 if_bInterfaceClass; MASS STORAGE */
0x06, /* u8 if_bInterfaceSubClass; SCSI */
0x50, /* u8 if_bInterfaceProtocol; Bulk Only */
0x00, /* u8 if_iInterface; */
/* Bulk-In endpoint */
0x07, /* u8 ep_bLength; */
0x05, /* u8 ep_bDescriptorType; Endpoint */
0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
0x02, /* u8 ep_bmAttributes; Bulk */
0x40, 0x00, /* u16 ep_wMaxPacketSize; */
0x00, /* u8 ep_bInterval; */
/* Bulk-Out endpoint */
0x07, /* u8 ep_bLength; */
0x05, /* u8 ep_bDescriptorType; Endpoint */
0x02, /* u8 ep_bEndpointAddress; OUT Endpoint 2 */
0x02, /* u8 ep_bmAttributes; Bulk */
0x40, 0x00, /* u16 ep_wMaxPacketSize; */
0x00 /* u8 ep_bInterval; */
};
static int cdrom_count = 0;
usb_msd_device_c::usb_msd_device_c(usbdev_type type, const char *filename)
{
char pname[10];
char label[32];
bx_param_string_c *path;
bx_param_bool_c *status;
d.type = type;
d.speed = USB_SPEED_FULL;
memset((void*)&s, 0, sizeof(s));
s.fname = filename;
if (d.type == USB_DEV_TYPE_DISK) {
strcpy(d.devname, "BOCHS USB HARDDRIVE");
} else if (d.type == USB_DEV_TYPE_CDROM) {
strcpy(d.devname, "BOCHS USB CDROM");
// config options
bx_list_c *usb_rt = (bx_list_c*)SIM->get_param(BXPN_MENU_RUNTIME_USB);
sprintf(pname, "cdrom%d", ++cdrom_count);
sprintf(label, "USB CD-ROM #%d Configuration", cdrom_count);
s.config = new bx_list_c(usb_rt, pname, label, 2);
s.config->set_options(bx_list_c::SERIES_ASK | bx_list_c::USE_BOX_TITLE);
s.config->set_runtime_param(1);
s.config->set_device_param(this);
path = new bx_param_string_c(s.config, "path", "Path", "", "", BX_PATHNAME_LEN);
path->set(s.fname);
path->set_handler(cd_param_string_handler);
path->set_runtime_param(1);
status = new bx_param_bool_c(s.config, "status", "Inserted", "", 1);
status->set_handler(cd_param_handler);
status->set_runtime_param(1);
// TODO: status
#if BX_WITH_WX
bx_list_c *usb = (bx_list_c*)SIM->get_param("ports.usb");
usb->add(s.config);
#endif
}
put("USBMS");
}
usb_msd_device_c::~usb_msd_device_c(void)
{
if (s.scsi_dev != NULL)
delete s.scsi_dev;
if (s.hdimage != NULL) {
delete s.hdimage;
} else if (s.cdrom != NULL) {
delete s.cdrom;
#if BX_WITH_WX
bx_list_c *usb = (bx_list_c*)SIM->get_param("ports.usb");
usb->remove(s.config->get_name());
#endif
bx_list_c *usb_rt = (bx_list_c*)SIM->get_param(BXPN_MENU_RUNTIME_USB);
usb_rt->remove(s.config->get_name());
}
}
bx_bool usb_msd_device_c::init()
{
if (d.type == USB_DEV_TYPE_DISK) {
s.hdimage = new default_image_t();
if (s.hdimage->open(s.fname) < 0) {
BX_ERROR(("could not open hard drive image file '%s'", s.fname));
return 0;
} else {
s.scsi_dev = new scsi_device_t(s.hdimage, 0, usb_msd_command_complete, (void*)this);
}
} else if (d.type == USB_DEV_TYPE_CDROM) {
s.cdrom = new LOWLEVEL_CDROM(s.fname);
if (!s.cdrom->insert_cdrom()) {
BX_ERROR(("could not open cdrom image file '%s'", s.fname));
return 0;
} else {
s.scsi_dev = new scsi_device_t(s.cdrom, 0, usb_msd_command_complete, (void*)this);
}
}
s.scsi_dev->register_state(s.sr_list, "scsidev");
s.mode = USB_MSDM_CBW;
d.connected = 1;
return 1;
}
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", 8);
new bx_shadow_num_c(s.sr_list, "mode", &s.mode);
new bx_shadow_num_c(s.sr_list, "scsi_len", &s.scsi_len);
new bx_shadow_num_c(s.sr_list, "usb_len", &s.usb_len);
new bx_shadow_num_c(s.sr_list, "data_len", &s.data_len);
new bx_shadow_num_c(s.sr_list, "residue", &s.residue);
new bx_shadow_num_c(s.sr_list, "tag", &s.tag);
new bx_shadow_num_c(s.sr_list, "result", &s.result);
}
void usb_msd_device_c::handle_reset()
{
BX_DEBUG(("Reset"));
s.mode = USB_MSDM_CBW;
}
int usb_msd_device_c::handle_control(int request, int value, int index, int length, Bit8u *data)
{
int ret = 0;
switch (request) {
case DeviceRequest | USB_REQ_GET_STATUS:
case EndpointRequest | USB_REQ_GET_STATUS:
data[0] = (1 << USB_DEVICE_SELF_POWERED) |
(d.remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
data[1] = 0x00;
ret = 2;
break;
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
d.remote_wakeup = 0;
} else {
goto fail;
}
ret = 0;
break;
case DeviceOutRequest | USB_REQ_SET_FEATURE:
if (value == USB_DEVICE_REMOTE_WAKEUP) {
d.remote_wakeup = 1;
} else {
goto fail;
}
ret = 0;
break;
case DeviceOutRequest | USB_REQ_SET_ADDRESS:
d.addr = value;
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
switch(value >> 8) {
case USB_DT_DEVICE:
memcpy(data, bx_msd_dev_descriptor, sizeof(bx_msd_dev_descriptor));
ret = sizeof(bx_msd_dev_descriptor);
break;
case USB_DT_CONFIG:
memcpy(data, bx_msd_config_descriptor, sizeof(bx_msd_config_descriptor));
ret = sizeof(bx_msd_config_descriptor);
break;
case USB_DT_STRING:
switch(value & 0xff) {
case 0:
// language IDs
data[0] = 4;
data[1] = 3;
data[2] = 0x09;
data[3] = 0x04;
ret = 4;
break;
case 1:
// vendor description
ret = set_usb_string(data, "BOCHS");
break;
case 2:
// product description
if (strlen(d.devname) > 0) {
ret = set_usb_string(data, d.devname);
} else {
goto fail;
}
break;
case 3:
// serial number
ret = set_usb_string(data, s.scsi_dev->get_serial_number());
break;
default:
BX_ERROR(("USB MSD handle_control: unknown string descriptor 0x%02x", value & 0xff));
goto fail;
}
break;
case USB_DT_DEVICE_QUALIFIER:
// device qualifier
data[0] = 10;
data[1] = USB_DT_DEVICE_QUALIFIER;
memcpy(data+2, bx_msd_dev_descriptor+2, 6);
data[8] = 1;
data[9] = 0;
ret = 10;
break;
default:
BX_ERROR(("USB MSD handle_control: unknown descriptor type 0x%02x", value >> 8));
goto fail;
}
break;
case DeviceRequest | USB_REQ_GET_CONFIGURATION:
data[0] = 1;
ret = 1;
break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
ret = 0;
break;
case DeviceRequest | USB_REQ_GET_INTERFACE:
data[0] = 0;
ret = 1;
break;
case DeviceOutRequest | USB_REQ_SET_INTERFACE:
case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
ret = 0;
break;
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
if (value == 0 && index != 0x81) { /* clear ep halt */
goto fail;
}
ret = 0;
break;
// Class specific requests
case InterfaceOutClassRequest | MassStorageReset:
case MassStorageReset:
s.mode = USB_MSDM_CBW;
ret = 0;
break;
case InterfaceInClassRequest | GetMaxLun:
case GetMaxLun:
data[0] = 0;
ret = 1;
break;
default:
BX_ERROR(("USB MSD handle_control: unknown request 0x%04x", request));
fail:
d.stall = 1;
ret = USB_RET_STALL;
break;
}
return ret;
}
int usb_msd_device_c::handle_data(USBPacket *p)
{
struct usb_msd_cbw cbw;
int ret = 0;
Bit8u devep = p->devep;
Bit8u *data = p->data;
int len = p->len;
switch (p->pid) {
case USB_TOKEN_OUT:
usb_dump_packet(data, len);
if (devep != 2)
goto fail;
switch (s.mode) {
case USB_MSDM_CBW:
if (len != 31) {
BX_ERROR(("bad CBW len"));
goto fail;
}
memcpy(&cbw, data, 31);
if (dtoh32(cbw.sig) != 0x43425355) {
BX_ERROR(("bad signature %08x", dtoh32(cbw.sig)));
goto fail;
}
BX_DEBUG(("command on LUN %d", cbw.lun));
s.tag = dtoh32(cbw.tag);
s.data_len = dtoh32(cbw.data_len);
if (s.data_len == 0) {
s.mode = USB_MSDM_CSW;
} else if (cbw.flags & 0x80) {
s.mode = USB_MSDM_DATAIN;
} else {
s.mode = USB_MSDM_DATAOUT;
}
BX_DEBUG(("command tag 0x%x flags %08x len %d data %d",
s.tag, cbw.flags, cbw.cmd_len, s.data_len));
s.residue = 0;
s.scsi_dev->scsi_send_command(s.tag, cbw.cmd, cbw.lun);
if (s.residue == 0) {
if (s.mode == USB_MSDM_DATAIN) {
s.scsi_dev->scsi_read_data(s.tag);
} else if (s.mode == USB_MSDM_DATAOUT) {
s.scsi_dev->scsi_write_data(s.tag);
}
}
ret = len;
break;
case USB_MSDM_DATAOUT:
BX_DEBUG(("data out %d/%d", len, s.data_len));
if (len > (int)s.data_len)
goto fail;
s.usb_buf = data;
s.usb_len = len;
if (s.scsi_len) {
copy_data();
}
if (s.residue && s.usb_len) {
s.data_len -= s.usb_len;
if (s.data_len == 0)
s.mode = USB_MSDM_CSW;
s.usb_len = 0;
}
if (s.usb_len) {
BX_INFO(("deferring packet %p", p));
usb_defer_packet(p, this);
s.packet = p;
ret = USB_RET_ASYNC;
} else {
ret = len;
}
break;
default:
BX_ERROR(("USB MSD handle_data: unexpected mode at USB_TOKEN_OUT"));
goto fail;
}
break;
case USB_TOKEN_IN:
if (devep != 1)
goto fail;
switch (s.mode) {
case USB_MSDM_DATAOUT:
if ((s.data_len > 0) && (len == 13)) {
s.usb_len = len;
s.usb_buf = data;
send_status();
ret = 13;
break;
}
if (s.data_len != 0 || len < 13)
goto fail;
usb_defer_packet(p, this);
s.packet = p;
ret = USB_RET_ASYNC;
break;
case USB_MSDM_CSW:
BX_DEBUG(("command status %d tag 0x%x, len %d",
s.result, s.tag, len));
if (len < 13)
return ret;
s.usb_len = len;
s.usb_buf = data;
send_status();
s.mode = USB_MSDM_CBW;
ret = 13;
break;
case USB_MSDM_DATAIN:
BX_DEBUG(("data in %d/%d", len, s.data_len));
if (len > (int)s.data_len)
len = s.data_len;
s.usb_buf = data;
s.usb_len = len;
if (s.scsi_len) {
copy_data();
}
if (s.residue && s.usb_len) {
s.data_len -= s.usb_len;
memset(s.usb_buf, 0, s.usb_len);
if (s.data_len == 0)
s.mode = USB_MSDM_CSW;
s.usb_len = 0;
}
if (s.usb_len) {
BX_INFO(("deferring packet %p", p));
usb_defer_packet(p, this);
s.packet = p;
ret = USB_RET_ASYNC;
} else {
ret = len;
}
break;
default:
BX_ERROR(("USB MSD handle_data: unexpected mode at USB_TOKEN_IN"));
goto fail;
}
if (ret > 0) usb_dump_packet(data, ret);
break;
default:
BX_ERROR(("USB MSD handle_data: bad token"));
fail:
d.stall = 1;
ret = USB_RET_STALL;
break;
}
return ret;
}
void usb_msd_device_c::copy_data()
{
Bit32u len = s.usb_len;
if (len > s.scsi_len)
len = s.scsi_len;
if (s.mode == USB_MSDM_DATAIN) {
memcpy(s.usb_buf, s.scsi_buf, len);
} else {
memcpy(s.scsi_buf, s.usb_buf, len);
}
s.usb_len -= len;
s.scsi_len -= len;
s.usb_buf += len;
s.scsi_buf += len;
s.data_len -= len;
if (s.scsi_len == 0) {
if (s.mode == USB_MSDM_DATAIN) {
s.scsi_dev->scsi_read_data(s.tag);
} else if (s.mode == USB_MSDM_DATAOUT) {
s.scsi_dev->scsi_write_data(s.tag);
}
}
}
void usb_msd_device_c::send_status()
{
struct usb_msd_csw csw;
csw.sig = htod32(0x53425355);
csw.tag = htod32(s.tag);
csw.residue = s.residue;
csw.status = s.result;
memcpy(s.usb_buf, &csw, 13);
}
void usb_msd_device_c::usb_msd_command_complete(void *this_ptr, int reason, Bit32u tag, Bit32u arg)
{
usb_msd_device_c *class_ptr = (usb_msd_device_c *) this_ptr;
class_ptr->command_complete(reason, tag, arg);
}
void usb_msd_device_c::command_complete(int reason, Bit32u tag, Bit32u arg)
{
USBPacket *p = s.packet;
if (tag != s.tag) {
BX_ERROR(("usb-msd_command_complete: unexpected SCSI tag 0x%x", tag));
}
if (reason == SCSI_REASON_DONE) {
BX_DEBUG(("command complete %d", arg));
s.residue = s.data_len;
s.result = arg != 0;
if (s.packet) {
if (s.data_len == 0 && s.mode == USB_MSDM_DATAOUT) {
send_status();
s.mode = USB_MSDM_CBW;
} else {
if (s.data_len) {
s.data_len -= s.usb_len;
if (s.mode == USB_MSDM_DATAIN)
memset(s.usb_buf, 0, s.usb_len);
s.usb_len = 0;
}
if (s.data_len == 0)
s.mode = USB_MSDM_CSW;
}
s.packet = NULL;
} else if (s.data_len == 0) {
s.mode = USB_MSDM_CSW;
}
return;
}
s.scsi_len = arg;
s.scsi_buf = s.scsi_dev->scsi_get_buf(tag);
if (p) {
copy_data();
if (s.usb_len == 0) {
BX_INFO(("packet complete %p", p));
s.packet = NULL;
}
}
}
void usb_msd_device_c::cancel_packet(USBPacket *p)
{
s.scsi_dev->scsi_cancel_io(s.tag);
s.packet = NULL;
s.scsi_len = 0;
}
void usb_msd_device_c::set_inserted(bx_bool value)
{
const char *path;
if (value) {
path = SIM->get_param_string("path", s.config)->getptr();
if (!s.cdrom->insert_cdrom(path)) {
SIM->get_param_bool("status", s.config)->set(0);
return;
}
} else {
s.cdrom->eject_cdrom();
}
s.scsi_dev->set_inserted(value);
}
bx_bool usb_msd_device_c::get_inserted()
{
return s.scsi_dev->get_inserted();
}
#undef LOG_THIS
#define LOG_THIS cdrom->
// USB hub runtime parameter handlers
const char *usb_msd_device_c::cd_param_string_handler(bx_param_string_c *param, int set,
const char *oldval, const char *val, int maxlen)
{
usb_msd_device_c *cdrom;
if (set) {
cdrom = (usb_msd_device_c*) param->get_parent()->get_device_param();
if (cdrom != NULL) {
bx_bool empty = ((strlen(val) == 0) || (!strcmp(val, "none")));
if (!empty) {
if (cdrom->get_inserted()) {
BX_ERROR(("direct path change not supported (setting to 'none')"));
param->set("none");
}
} else {
SIM->get_param_bool("status", param->get_parent())->set(0);
}
} else {
BX_PANIC(("cd_param_string_handler: cdrom not found"));
}
}
return val;
}
Bit64s usb_msd_device_c::cd_param_handler(bx_param_c *param, int set, Bit64s val)
{
usb_msd_device_c *cdrom;
const char *path;
if (set) {
cdrom = (usb_msd_device_c*) param->get_parent()->get_device_param();
if (cdrom != NULL) {
path = SIM->get_param_string("path", param->get_parent())->getptr();
val &= ((strlen(path) > 0) && (strcmp(path, "none")));
if (val != cdrom->get_inserted()) {
cdrom->set_inserted(val);
}
} else {
BX_PANIC(("cd_param_string_handler: cdrom not found"));
}
}
return val;
}
#endif // BX_SUPPORT_PCI && BX_SUPPORT_PCIUSB
Reference in New Issue View Git Blame Copy Permalink