Revision 007fd62f
| b/hw/bt-hid.c | ||
|---|---|---|
| 323 | 323 |
break; |
| 324 | 324 |
} |
| 325 | 325 |
s->proto = parameter; |
| 326 |
s->usbdev->info->handle_control(s->usbdev, SET_PROTOCOL, s->proto, 0, 0, |
|
| 326 |
s->usbdev->info->handle_control(s->usbdev, NULL, SET_PROTOCOL, s->proto, 0, 0,
|
|
| 327 | 327 |
NULL); |
| 328 | 328 |
ret = BT_HS_SUCCESSFUL; |
| 329 | 329 |
break; |
| ... | ... | |
| 333 | 333 |
ret = BT_HS_ERR_INVALID_PARAMETER; |
| 334 | 334 |
break; |
| 335 | 335 |
} |
| 336 |
s->usbdev->info->handle_control(s->usbdev, GET_IDLE, 0, 0, 1, |
|
| 336 |
s->usbdev->info->handle_control(s->usbdev, NULL, GET_IDLE, 0, 0, 1,
|
|
| 337 | 337 |
s->control->sdu_out(s->control, 1)); |
| 338 | 338 |
s->control->sdu_submit(s->control); |
| 339 | 339 |
break; |
| ... | ... | |
| 346 | 346 |
|
| 347 | 347 |
/* We don't need to know about the Idle Rate here really, |
| 348 | 348 |
* so just pass it on to the device. */ |
| 349 |
ret = s->usbdev->info->handle_control(s->usbdev, |
|
| 349 |
ret = s->usbdev->info->handle_control(s->usbdev, NULL,
|
|
| 350 | 350 |
SET_IDLE, data[1], 0, 0, NULL) ? |
| 351 | 351 |
BT_HS_SUCCESSFUL : BT_HS_ERR_INVALID_PARAMETER; |
| 352 | 352 |
/* XXX: Does this generate a handshake? */ |
| b/hw/usb-bt.c | ||
|---|---|---|
| 372 | 372 |
s->altsetting = 0; |
| 373 | 373 |
} |
| 374 | 374 |
|
| 375 |
static int usb_bt_handle_control(USBDevice *dev, int request, int value,
|
|
| 376 |
int index, int length, uint8_t *data) |
|
| 375 |
static int usb_bt_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 376 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 377 | 377 |
{
|
| 378 | 378 |
struct USBBtState *s = (struct USBBtState *) dev->opaque; |
| 379 | 379 |
int ret; |
| 380 | 380 |
|
| 381 |
ret = usb_desc_handle_control(dev, request, value, index, length, data); |
|
| 381 |
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
| 382 | 382 |
if (ret >= 0) {
|
| 383 | 383 |
switch (request) {
|
| 384 | 384 |
case DeviceRequest | USB_REQ_GET_CONFIGURATION: |
| b/hw/usb-ccid.c | ||
|---|---|---|
| 602 | 602 |
ccid_reset(s); |
| 603 | 603 |
} |
| 604 | 604 |
|
| 605 |
static int ccid_handle_control(USBDevice *dev, int request, int value,
|
|
| 606 |
int index, int length, uint8_t *data)
|
|
| 605 |
static int ccid_handle_control(USBDevice *dev, USBPacket *p, int request,
|
|
| 606 |
int value, int index, int length, uint8_t *data)
|
|
| 607 | 607 |
{
|
| 608 | 608 |
USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev); |
| 609 | 609 |
int ret = 0; |
| b/hw/usb-desc.c | ||
|---|---|---|
| 390 | 390 |
return ret; |
| 391 | 391 |
} |
| 392 | 392 |
|
| 393 |
int usb_desc_handle_control(USBDevice *dev, int request, int value,
|
|
| 394 |
int index, int length, uint8_t *data)
|
|
| 393 |
int usb_desc_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 394 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 395 | 395 |
{
|
| 396 | 396 |
const USBDesc *desc = dev->info->usb_desc; |
| 397 | 397 |
int i, ret = -1; |
| b/hw/usb-desc.h | ||
|---|---|---|
| 106 | 106 |
const char *usb_desc_get_string(USBDevice *dev, uint8_t index); |
| 107 | 107 |
int usb_desc_string(USBDevice *dev, int index, uint8_t *dest, size_t len); |
| 108 | 108 |
int usb_desc_get_descriptor(USBDevice *dev, int value, uint8_t *dest, size_t len); |
| 109 |
int usb_desc_handle_control(USBDevice *dev, int request, int value,
|
|
| 110 |
int index, int length, uint8_t *data);
|
|
| 109 |
int usb_desc_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 110 |
int request, int value, int index, int length, uint8_t *data);
|
|
| 111 | 111 |
|
| 112 | 112 |
#endif /* QEMU_HW_USB_DESC_H */ |
| b/hw/usb-hid.c | ||
|---|---|---|
| 727 | 727 |
s->next_idle_clock = curtime + (get_ticks_per_sec() * s->idle * 4) / 1000; |
| 728 | 728 |
} |
| 729 | 729 |
|
| 730 |
static int usb_hid_handle_control(USBDevice *dev, int request, int value,
|
|
| 731 |
int index, int length, uint8_t *data)
|
|
| 730 |
static int usb_hid_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 731 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 732 | 732 |
{
|
| 733 | 733 |
USBHIDState *s = (USBHIDState *)dev; |
| 734 | 734 |
int ret; |
| 735 | 735 |
|
| 736 |
ret = usb_desc_handle_control(dev, request, value, index, length, data); |
|
| 736 |
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
| 737 | 737 |
if (ret >= 0) {
|
| 738 | 738 |
return ret; |
| 739 | 739 |
} |
| b/hw/usb-hub.c | ||
|---|---|---|
| 285 | 285 |
/* XXX: do it */ |
| 286 | 286 |
} |
| 287 | 287 |
|
| 288 |
static int usb_hub_handle_control(USBDevice *dev, int request, int value,
|
|
| 289 |
int index, int length, uint8_t *data)
|
|
| 288 |
static int usb_hub_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 289 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 290 | 290 |
{
|
| 291 | 291 |
USBHubState *s = (USBHubState *)dev; |
| 292 | 292 |
int ret; |
| 293 | 293 |
|
| 294 |
ret = usb_desc_handle_control(dev, request, value, index, length, data); |
|
| 294 |
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
| 295 | 295 |
if (ret >= 0) {
|
| 296 | 296 |
return ret; |
| 297 | 297 |
} |
| b/hw/usb-msd.c | ||
|---|---|---|
| 272 | 272 |
s->mode = USB_MSDM_CBW; |
| 273 | 273 |
} |
| 274 | 274 |
|
| 275 |
static int usb_msd_handle_control(USBDevice *dev, int request, int value,
|
|
| 276 |
int index, int length, uint8_t *data)
|
|
| 275 |
static int usb_msd_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 276 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 277 | 277 |
{
|
| 278 | 278 |
MSDState *s = (MSDState *)dev; |
| 279 | 279 |
int ret; |
| 280 | 280 |
|
| 281 |
ret = usb_desc_handle_control(dev, request, value, index, length, data); |
|
| 281 |
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
| 282 | 282 |
if (ret >= 0) {
|
| 283 | 283 |
return ret; |
| 284 | 284 |
} |
| b/hw/usb-net.c | ||
|---|---|---|
| 1042 | 1042 |
{
|
| 1043 | 1043 |
} |
| 1044 | 1044 |
|
| 1045 |
static int usb_net_handle_control(USBDevice *dev, int request, int value,
|
|
| 1046 |
int index, int length, uint8_t *data) |
|
| 1045 |
static int usb_net_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 1046 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 1047 | 1047 |
{
|
| 1048 | 1048 |
USBNetState *s = (USBNetState *) dev; |
| 1049 | 1049 |
int ret; |
| 1050 | 1050 |
|
| 1051 |
ret = usb_desc_handle_control(dev, request, value, index, length, data); |
|
| 1051 |
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
| 1052 | 1052 |
if (ret >= 0) {
|
| 1053 | 1053 |
return ret; |
| 1054 | 1054 |
} |
| b/hw/usb-serial.c | ||
|---|---|---|
| 219 | 219 |
return ret; |
| 220 | 220 |
} |
| 221 | 221 |
|
| 222 |
static int usb_serial_handle_control(USBDevice *dev, int request, int value,
|
|
| 223 |
int index, int length, uint8_t *data)
|
|
| 222 |
static int usb_serial_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 223 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 224 | 224 |
{
|
| 225 | 225 |
USBSerialState *s = (USBSerialState *)dev; |
| 226 | 226 |
int ret; |
| 227 | 227 |
|
| 228 | 228 |
DPRINTF("got control %x, value %x\n",request, value);
|
| 229 |
ret = usb_desc_handle_control(dev, request, value, index, length, data); |
|
| 229 |
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
| 230 | 230 |
if (ret >= 0) {
|
| 231 | 231 |
return ret; |
| 232 | 232 |
} |
| b/hw/usb-wacom.c | ||
|---|---|---|
| 250 | 250 |
s->mode = WACOM_MODE_HID; |
| 251 | 251 |
} |
| 252 | 252 |
|
| 253 |
static int usb_wacom_handle_control(USBDevice *dev, int request, int value,
|
|
| 254 |
int index, int length, uint8_t *data)
|
|
| 253 |
static int usb_wacom_handle_control(USBDevice *dev, USBPacket *p,
|
|
| 254 |
int request, int value, int index, int length, uint8_t *data)
|
|
| 255 | 255 |
{
|
| 256 | 256 |
USBWacomState *s = (USBWacomState *) dev; |
| 257 | 257 |
int ret; |
| 258 | 258 |
|
| 259 |
ret = usb_desc_handle_control(dev, request, value, index, length, data); |
|
| 259 |
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
|
| 260 | 260 |
if (ret >= 0) {
|
| 261 | 261 |
return ret; |
| 262 | 262 |
} |
| b/hw/usb.c | ||
|---|---|---|
| 82 | 82 |
request = (s->setup_buf[0] << 8) | s->setup_buf[1]; |
| 83 | 83 |
value = (s->setup_buf[3] << 8) | s->setup_buf[2]; |
| 84 | 84 |
index = (s->setup_buf[5] << 8) | s->setup_buf[4]; |
| 85 |
|
|
| 85 |
|
|
| 86 | 86 |
if (s->setup_buf[0] & USB_DIR_IN) {
|
| 87 |
ret = s->info->handle_control(s, request, value, index,
|
|
| 87 |
ret = s->info->handle_control(s, p, request, value, index,
|
|
| 88 | 88 |
s->setup_len, s->data_buf); |
| 89 | 89 |
if (ret < 0) |
| 90 | 90 |
return ret; |
| ... | ... | |
| 123 | 123 |
switch(s->setup_state) {
|
| 124 | 124 |
case SETUP_STATE_ACK: |
| 125 | 125 |
if (!(s->setup_buf[0] & USB_DIR_IN)) {
|
| 126 |
s->setup_state = SETUP_STATE_IDLE; |
|
| 127 |
ret = s->info->handle_control(s, request, value, index, |
|
| 126 |
ret = s->info->handle_control(s, p, request, value, index, |
|
| 128 | 127 |
s->setup_len, s->data_buf); |
| 128 |
if (ret == USB_RET_ASYNC) {
|
|
| 129 |
return USB_RET_ASYNC; |
|
| 130 |
} |
|
| 131 |
s->setup_state = SETUP_STATE_IDLE; |
|
| 129 | 132 |
if (ret > 0) |
| 130 | 133 |
return 0; |
| 131 | 134 |
return ret; |
| b/hw/usb.h | ||
|---|---|---|
| 214 | 214 |
* |
| 215 | 215 |
* Returns length or one of the USB_RET_ codes. |
| 216 | 216 |
*/ |
| 217 |
int (*handle_control)(USBDevice *dev, int request, int value, |
|
| 217 |
int (*handle_control)(USBDevice *dev, USBPacket *p, int request, int value,
|
|
| 218 | 218 |
int index, int length, uint8_t *data); |
| 219 | 219 |
|
| 220 | 220 |
/* |
| b/usb-bsd.c | ||
|---|---|---|
| 126 | 126 |
* and return appropriate response |
| 127 | 127 |
*/ |
| 128 | 128 |
static int usb_host_handle_control(USBDevice *dev, |
| 129 |
USBPacket *p, |
|
| 129 | 130 |
int request, |
| 130 | 131 |
int value, |
| 131 | 132 |
int index, |
Also available in: Unified diff