Revision eb5e680a
| b/hw/usb-msd.c | ||
|---|---|---|
| 315 | 315 |
return ret; |
| 316 | 316 |
} |
| 317 | 317 |
|
| 318 |
static void usb_msd_cancel_io(USBPacket *p, void *opaque)
|
|
| 318 |
static void usb_msd_cancel_io(USBDevice *dev, USBPacket *p)
|
|
| 319 | 319 |
{
|
| 320 |
MSDState *s = opaque;
|
|
| 320 |
MSDState *s = DO_UPCAST(MSDState, dev, dev);
|
|
| 321 | 321 |
s->scsi_dev->info->cancel_io(s->scsi_dev, s->tag); |
| 322 | 322 |
s->packet = NULL; |
| 323 | 323 |
s->scsi_len = 0; |
| ... | ... | |
| 398 | 398 |
} |
| 399 | 399 |
if (s->usb_len) {
|
| 400 | 400 |
DPRINTF("Deferring packet %p\n", p);
|
| 401 |
usb_defer_packet(p, usb_msd_cancel_io, s); |
|
| 402 | 401 |
s->packet = p; |
| 403 | 402 |
ret = USB_RET_ASYNC; |
| 404 | 403 |
} else {
|
| ... | ... | |
| 421 | 420 |
if (s->data_len != 0 || len < 13) |
| 422 | 421 |
goto fail; |
| 423 | 422 |
/* Waiting for SCSI write to complete. */ |
| 424 |
usb_defer_packet(p, usb_msd_cancel_io, s); |
|
| 425 | 423 |
s->packet = p; |
| 426 | 424 |
ret = USB_RET_ASYNC; |
| 427 | 425 |
break; |
| ... | ... | |
| 455 | 453 |
} |
| 456 | 454 |
if (s->usb_len) {
|
| 457 | 455 |
DPRINTF("Deferring packet %p\n", p);
|
| 458 |
usb_defer_packet(p, usb_msd_cancel_io, s); |
|
| 459 | 456 |
s->packet = p; |
| 460 | 457 |
ret = USB_RET_ASYNC; |
| 461 | 458 |
} else {
|
| ... | ... | |
| 604 | 601 |
.usb_desc = &desc, |
| 605 | 602 |
.init = usb_msd_initfn, |
| 606 | 603 |
.handle_packet = usb_generic_handle_packet, |
| 604 |
.cancel_packet = usb_msd_cancel_io, |
|
| 607 | 605 |
.handle_attach = usb_desc_attach, |
| 608 | 606 |
.handle_reset = usb_msd_handle_reset, |
| 609 | 607 |
.handle_control = usb_msd_handle_control, |
| b/hw/usb.c | ||
|---|---|---|
| 345 | 345 |
void usb_cancel_packet(USBPacket * p) |
| 346 | 346 |
{
|
| 347 | 347 |
assert(p->owner != NULL); |
| 348 |
p->cancel_cb(p, p->cancel_opaque);
|
|
| 348 |
p->owner->info->cancel_packet(p->owner, p);
|
|
| 349 | 349 |
p->owner = NULL; |
| 350 | 350 |
} |
| b/hw/usb.h | ||
|---|---|---|
| 194 | 194 |
int (*handle_packet)(USBDevice *dev, USBPacket *p); |
| 195 | 195 |
|
| 196 | 196 |
/* |
| 197 |
* Called when a packet is canceled. |
|
| 198 |
*/ |
|
| 199 |
void (*cancel_packet)(USBDevice *dev, USBPacket *p); |
|
| 200 |
|
|
| 201 |
/* |
|
| 197 | 202 |
* Called when device is destroyed. |
| 198 | 203 |
*/ |
| 199 | 204 |
void (*handle_destroy)(USBDevice *dev); |
| ... | ... | |
| 263 | 268 |
int len; |
| 264 | 269 |
/* Internal use by the USB layer. */ |
| 265 | 270 |
USBDevice *owner; |
| 266 |
USBCallback *cancel_cb; |
|
| 267 |
void *cancel_opaque; |
|
| 268 | 271 |
}; |
| 269 | 272 |
|
| 270 | 273 |
int usb_handle_packet(USBDevice *dev, USBPacket *p); |
| 271 | 274 |
void usb_packet_complete(USBDevice *dev, USBPacket *p); |
| 272 | 275 |
void usb_cancel_packet(USBPacket * p); |
| 273 | 276 |
|
| 274 |
/* Defer completion of a USB packet. The hadle_packet routine should then |
|
| 275 |
return USB_RET_ASYNC. Packets that complete immediately (before |
|
| 276 |
handle_packet returns) should not call this method. */ |
|
| 277 |
static inline void usb_defer_packet(USBPacket *p, USBCallback *cancel, |
|
| 278 |
void * opaque) |
|
| 279 |
{
|
|
| 280 |
p->cancel_cb = cancel; |
|
| 281 |
p->cancel_opaque = opaque; |
|
| 282 |
} |
|
| 283 |
|
|
| 284 | 277 |
void usb_attach(USBPort *port, USBDevice *dev); |
| 285 | 278 |
void usb_wakeup(USBDevice *dev); |
| 286 | 279 |
int usb_generic_handle_packet(USBDevice *s, USBPacket *p); |
| b/usb-linux.c | ||
|---|---|---|
| 335 | 335 |
} |
| 336 | 336 |
} |
| 337 | 337 |
|
| 338 |
static void async_cancel(USBPacket *p, void *opaque)
|
|
| 338 |
static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
|
|
| 339 | 339 |
{
|
| 340 |
USBHostDevice *s = opaque;
|
|
| 340 |
USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
|
|
| 341 | 341 |
AsyncURB *aurb; |
| 342 | 342 |
|
| 343 | 343 |
QLIST_FOREACH(aurb, &s->aurbs, next) {
|
| ... | ... | |
| 736 | 736 |
} |
| 737 | 737 |
} |
| 738 | 738 |
|
| 739 |
usb_defer_packet(p, async_cancel, s); |
|
| 740 | 739 |
return USB_RET_ASYNC; |
| 741 | 740 |
} |
| 742 | 741 |
|
| ... | ... | |
| 868 | 867 |
} |
| 869 | 868 |
} |
| 870 | 869 |
|
| 871 |
usb_defer_packet(p, async_cancel, s); |
|
| 872 | 870 |
return USB_RET_ASYNC; |
| 873 | 871 |
} |
| 874 | 872 |
|
| ... | ... | |
| 1197 | 1195 |
.qdev.size = sizeof(USBHostDevice), |
| 1198 | 1196 |
.init = usb_host_initfn, |
| 1199 | 1197 |
.handle_packet = usb_generic_handle_packet, |
| 1198 |
.cancel_packet = usb_host_async_cancel, |
|
| 1200 | 1199 |
.handle_data = usb_host_handle_data, |
| 1201 | 1200 |
.handle_control = usb_host_handle_control, |
| 1202 | 1201 |
.handle_reset = usb_host_handle_reset, |
Also available in: Unified diff