Revision 079d0b7f
| b/hw/usb-audio.c | ||
|---|---|---|
| 607 | 607 |
|
| 608 | 608 |
switch (p->pid) {
|
| 609 | 609 |
case USB_TOKEN_OUT: |
| 610 |
switch (p->devep) {
|
|
| 610 |
switch (p->ep->nr) {
|
|
| 611 | 611 |
case 1: |
| 612 | 612 |
ret = usb_audio_handle_dataout(s, p); |
| 613 | 613 |
break; |
| ... | ... | |
| 624 | 624 |
if (ret == USB_RET_STALL && s->debug) {
|
| 625 | 625 |
fprintf(stderr, "usb-audio: failed data transaction: " |
| 626 | 626 |
"pid 0x%x ep 0x%x len 0x%zx\n", |
| 627 |
p->pid, p->devep, p->iov.size);
|
|
| 627 |
p->pid, p->ep->nr, p->iov.size);
|
|
| 628 | 628 |
} |
| 629 | 629 |
return ret; |
| 630 | 630 |
} |
| b/hw/usb-bt.c | ||
|---|---|---|
| 423 | 423 |
|
| 424 | 424 |
switch (p->pid) {
|
| 425 | 425 |
case USB_TOKEN_IN: |
| 426 |
switch (p->devep & 0xf) {
|
|
| 426 |
switch (p->ep->nr) {
|
|
| 427 | 427 |
case USB_EVT_EP: |
| 428 | 428 |
ret = usb_bt_fifo_dequeue(&s->evt, p); |
| 429 | 429 |
break; |
| ... | ... | |
| 442 | 442 |
break; |
| 443 | 443 |
|
| 444 | 444 |
case USB_TOKEN_OUT: |
| 445 |
switch (p->devep & 0xf) {
|
|
| 445 |
switch (p->ep->nr) {
|
|
| 446 | 446 |
case USB_ACL_EP: |
| 447 | 447 |
usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send, |
| 448 | 448 |
usb_bt_hci_acl_complete, p); |
| b/hw/usb-ccid.c | ||
|---|---|---|
| 995 | 995 |
break; |
| 996 | 996 |
|
| 997 | 997 |
case USB_TOKEN_IN: |
| 998 |
switch (p->devep & 0xf) {
|
|
| 998 |
switch (p->ep->nr) {
|
|
| 999 | 999 |
case CCID_BULK_IN_EP: |
| 1000 | 1000 |
if (!p->iov.size) {
|
| 1001 | 1001 |
ret = USB_RET_NAK; |
| b/hw/usb-ehci.c | ||
|---|---|---|
| 1357 | 1357 |
static int ehci_execute(EHCIQueue *q) |
| 1358 | 1358 |
{
|
| 1359 | 1359 |
USBDevice *dev; |
| 1360 |
USBEndpoint *ep; |
|
| 1360 | 1361 |
int ret; |
| 1361 | 1362 |
int endp; |
| 1362 | 1363 |
int devadr; |
| ... | ... | |
| 1387 | 1388 |
endp = get_field(q->qh.epchar, QH_EPCHAR_EP); |
| 1388 | 1389 |
devadr = get_field(q->qh.epchar, QH_EPCHAR_DEVADDR); |
| 1389 | 1390 |
|
| 1390 |
ret = USB_RET_NODEV; |
|
| 1391 |
/* TODO: associating device with ehci port */ |
|
| 1392 |
dev = ehci_find_device(q->ehci, devadr); |
|
| 1393 |
ep = usb_ep_get(dev, q->pid, endp); |
|
| 1391 | 1394 |
|
| 1392 |
usb_packet_setup(&q->packet, q->pid, devadr, endp);
|
|
| 1395 |
usb_packet_setup(&q->packet, q->pid, ep);
|
|
| 1393 | 1396 |
usb_packet_map(&q->packet, &q->sgl); |
| 1394 | 1397 |
|
| 1395 |
// TO-DO: associating device with ehci port |
|
| 1396 |
dev = ehci_find_device(q->ehci, q->packet.devaddr); |
|
| 1397 | 1398 |
ret = usb_handle_packet(dev, &q->packet); |
| 1398 | 1399 |
DPRINTF("submit: qh %x next %x qtd %x pid %x len %zd "
|
| 1399 | 1400 |
"(total %d) endp %x ret %d\n", |
| ... | ... | |
| 1415 | 1416 |
EHCIitd *itd) |
| 1416 | 1417 |
{
|
| 1417 | 1418 |
USBDevice *dev; |
| 1419 |
USBEndpoint *ep; |
|
| 1418 | 1420 |
int ret; |
| 1419 | 1421 |
uint32_t i, len, pid, dir, devaddr, endp; |
| 1420 | 1422 |
uint32_t pg, off, ptr1, ptr2, max, mult; |
| ... | ... | |
| 1454 | 1456 |
|
| 1455 | 1457 |
pid = dir ? USB_TOKEN_IN : USB_TOKEN_OUT; |
| 1456 | 1458 |
|
| 1457 |
usb_packet_setup(&ehci->ipacket, pid, devaddr, endp); |
|
| 1459 |
dev = ehci_find_device(ehci, devaddr); |
|
| 1460 |
ep = usb_ep_get(dev, pid, endp); |
|
| 1461 |
usb_packet_setup(&ehci->ipacket, pid, ep); |
|
| 1458 | 1462 |
usb_packet_map(&ehci->ipacket, &ehci->isgl); |
| 1459 | 1463 |
|
| 1460 |
dev = ehci_find_device(ehci, ehci->ipacket.devaddr); |
|
| 1461 | 1464 |
ret = usb_handle_packet(dev, &ehci->ipacket); |
| 1462 | 1465 |
|
| 1463 | 1466 |
usb_packet_unmap(&ehci->ipacket); |
| b/hw/usb-hid.c | ||
|---|---|---|
| 463 | 463 |
|
| 464 | 464 |
switch (p->pid) {
|
| 465 | 465 |
case USB_TOKEN_IN: |
| 466 |
if (p->devep == 1) {
|
|
| 466 |
if (p->ep->nr == 1) {
|
|
| 467 | 467 |
int64_t curtime = qemu_get_clock_ns(vm_clock); |
| 468 | 468 |
if (!hid_has_events(hs) && |
| 469 | 469 |
(!hs->idle || hs->next_idle_clock - curtime > 0)) {
|
| b/hw/usb-hub.c | ||
|---|---|---|
| 416 | 416 |
|
| 417 | 417 |
switch(p->pid) {
|
| 418 | 418 |
case USB_TOKEN_IN: |
| 419 |
if (p->devep == 1) {
|
|
| 419 |
if (p->ep->nr == 1) {
|
|
| 420 | 420 |
USBHubPort *port; |
| 421 | 421 |
unsigned int status; |
| 422 | 422 |
uint8_t buf[4]; |
| b/hw/usb-msd.c | ||
|---|---|---|
| 341 | 341 |
uint32_t tag; |
| 342 | 342 |
int ret = 0; |
| 343 | 343 |
struct usb_msd_cbw cbw; |
| 344 |
uint8_t devep = p->devep;
|
|
| 344 |
uint8_t devep = p->ep->nr;
|
|
| 345 | 345 |
|
| 346 | 346 |
switch (p->pid) {
|
| 347 | 347 |
case USB_TOKEN_OUT: |
| b/hw/usb-musb.c | ||
|---|---|---|
| 606 | 606 |
int epnum, int pid, int len, USBCallback cb, int dir) |
| 607 | 607 |
{
|
| 608 | 608 |
USBDevice *dev; |
| 609 |
USBEndpoint *uep; |
|
| 609 | 610 |
int ret; |
| 610 | 611 |
int idx = epnum && dir; |
| 611 | 612 |
int ttype; |
| ... | ... | |
| 623 | 624 |
ep->delayed_cb[dir] = cb; |
| 624 | 625 |
|
| 625 | 626 |
/* A wild guess on the FADDR semantics... */ |
| 626 |
usb_packet_setup(&ep->packey[dir].p, pid, ep->faddr[idx], |
|
| 627 |
ep->type[idx] & 0xf); |
|
| 627 |
dev = usb_find_device(&s->port, ep->faddr[idx]); |
|
| 628 |
uep = usb_ep_get(dev, pid, ep->type[idx] & 0xf); |
|
| 629 |
usb_packet_setup(&ep->packey[dir].p, pid, uep); |
|
| 628 | 630 |
usb_packet_addbuf(&ep->packey[dir].p, ep->buf[idx], len); |
| 629 | 631 |
ep->packey[dir].ep = ep; |
| 630 | 632 |
ep->packey[dir].dir = dir; |
| 631 | 633 |
|
| 632 |
dev = usb_find_device(&s->port, ep->packey[dir].p.devaddr); |
|
| 633 | 634 |
ret = usb_handle_packet(dev, &ep->packey[dir].p); |
| 634 | 635 |
|
| 635 | 636 |
if (ret == USB_RET_ASYNC) {
|
| b/hw/usb-net.c | ||
|---|---|---|
| 1210 | 1210 |
|
| 1211 | 1211 |
switch(p->pid) {
|
| 1212 | 1212 |
case USB_TOKEN_IN: |
| 1213 |
switch (p->devep) {
|
|
| 1213 |
switch (p->ep->nr) {
|
|
| 1214 | 1214 |
case 1: |
| 1215 | 1215 |
ret = usb_net_handle_statusin(s, p); |
| 1216 | 1216 |
break; |
| ... | ... | |
| 1225 | 1225 |
break; |
| 1226 | 1226 |
|
| 1227 | 1227 |
case USB_TOKEN_OUT: |
| 1228 |
switch (p->devep) {
|
|
| 1228 |
switch (p->ep->nr) {
|
|
| 1229 | 1229 |
case 2: |
| 1230 | 1230 |
ret = usb_net_handle_dataout(s, p); |
| 1231 | 1231 |
break; |
| ... | ... | |
| 1243 | 1243 |
if (ret == USB_RET_STALL) |
| 1244 | 1244 |
fprintf(stderr, "usbnet: failed data transaction: " |
| 1245 | 1245 |
"pid 0x%x ep 0x%x len 0x%zx\n", |
| 1246 |
p->pid, p->devep, p->iov.size);
|
|
| 1246 |
p->pid, p->ep->nr, p->iov.size);
|
|
| 1247 | 1247 |
return ret; |
| 1248 | 1248 |
} |
| 1249 | 1249 |
|
| b/hw/usb-ohci.c | ||
|---|---|---|
| 657 | 657 |
int ret; |
| 658 | 658 |
int i; |
| 659 | 659 |
USBDevice *dev; |
| 660 |
USBEndpoint *ep; |
|
| 660 | 661 |
struct ohci_iso_td iso_td; |
| 661 | 662 |
uint32_t addr; |
| 662 | 663 |
uint16_t starting_frame; |
| ... | ... | |
| 796 | 797 |
if (completion) {
|
| 797 | 798 |
ret = ohci->usb_packet.result; |
| 798 | 799 |
} else {
|
| 799 |
usb_packet_setup(&ohci->usb_packet, pid,
|
|
| 800 |
OHCI_BM(ed->flags, ED_FA),
|
|
| 801 |
OHCI_BM(ed->flags, ED_EN));
|
|
| 800 |
dev = ohci_find_device(ohci, OHCI_BM(ed->flags, ED_FA));
|
|
| 801 |
ep = usb_ep_get(dev, pid, OHCI_BM(ed->flags, ED_EN));
|
|
| 802 |
usb_packet_setup(&ohci->usb_packet, pid, ep);
|
|
| 802 | 803 |
usb_packet_addbuf(&ohci->usb_packet, ohci->usb_buf, len); |
| 803 |
dev = ohci_find_device(ohci, ohci->usb_packet.devaddr); |
|
| 804 | 804 |
ret = usb_handle_packet(dev, &ohci->usb_packet); |
| 805 | 805 |
if (ret == USB_RET_ASYNC) {
|
| 806 | 806 |
return 1; |
| ... | ... | |
| 889 | 889 |
int ret; |
| 890 | 890 |
int i; |
| 891 | 891 |
USBDevice *dev; |
| 892 |
USBEndpoint *ep; |
|
| 892 | 893 |
struct ohci_td td; |
| 893 | 894 |
uint32_t addr; |
| 894 | 895 |
int flag_r; |
| ... | ... | |
| 992 | 993 |
#endif |
| 993 | 994 |
return 1; |
| 994 | 995 |
} |
| 995 |
usb_packet_setup(&ohci->usb_packet, pid,
|
|
| 996 |
OHCI_BM(ed->flags, ED_FA),
|
|
| 997 |
OHCI_BM(ed->flags, ED_EN));
|
|
| 996 |
dev = ohci_find_device(ohci, OHCI_BM(ed->flags, ED_FA));
|
|
| 997 |
ep = usb_ep_get(dev, pid, OHCI_BM(ed->flags, ED_EN));
|
|
| 998 |
usb_packet_setup(&ohci->usb_packet, pid, ep);
|
|
| 998 | 999 |
usb_packet_addbuf(&ohci->usb_packet, ohci->usb_buf, pktlen); |
| 999 |
dev = ohci_find_device(ohci, ohci->usb_packet.devaddr); |
|
| 1000 | 1000 |
ret = usb_handle_packet(dev, &ohci->usb_packet); |
| 1001 | 1001 |
#ifdef DEBUG_PACKET |
| 1002 | 1002 |
DPRINTF("ret=%d\n", ret);
|
| b/hw/usb-serial.c | ||
|---|---|---|
| 353 | 353 |
{
|
| 354 | 354 |
USBSerialState *s = (USBSerialState *)dev; |
| 355 | 355 |
int i, ret = 0; |
| 356 |
uint8_t devep = p->devep;
|
|
| 356 |
uint8_t devep = p->ep->nr;
|
|
| 357 | 357 |
struct iovec *iov; |
| 358 | 358 |
uint8_t header[2]; |
| 359 | 359 |
int first_len, len; |
| b/hw/usb-uhci.c | ||
|---|---|---|
| 761 | 761 |
int len = 0, max_len; |
| 762 | 762 |
uint8_t pid, isoc; |
| 763 | 763 |
uint32_t token; |
| 764 |
USBDevice *dev; |
|
| 765 |
USBEndpoint *ep; |
|
| 764 | 766 |
|
| 765 | 767 |
/* Is active ? */ |
| 766 | 768 |
if (!(td->ctrl & TD_CTRL_ACTIVE)) |
| ... | ... | |
| 805 | 807 |
max_len = ((td->token >> 21) + 1) & 0x7ff; |
| 806 | 808 |
pid = td->token & 0xff; |
| 807 | 809 |
|
| 808 |
usb_packet_setup(&async->packet, pid, (td->token >> 8) & 0x7f, |
|
| 809 |
(td->token >> 15) & 0xf); |
|
| 810 |
dev = uhci_find_device(s, (td->token >> 8) & 0x7f); |
|
| 811 |
ep = usb_ep_get(dev, pid, (td->token >> 15) & 0xf); |
|
| 812 |
usb_packet_setup(&async->packet, pid, ep); |
|
| 810 | 813 |
qemu_sglist_add(&async->sgl, td->buffer, max_len); |
| 811 | 814 |
usb_packet_map(&async->packet, &async->sgl); |
| 812 | 815 |
|
| 813 | 816 |
switch(pid) {
|
| 814 | 817 |
case USB_TOKEN_OUT: |
| 815 | 818 |
case USB_TOKEN_SETUP: |
| 816 |
len = usb_handle_packet(uhci_find_device(s, async->packet.devaddr), |
|
| 817 |
&async->packet); |
|
| 819 |
len = usb_handle_packet(dev, &async->packet); |
|
| 818 | 820 |
if (len >= 0) |
| 819 | 821 |
len = max_len; |
| 820 | 822 |
break; |
| 821 | 823 |
|
| 822 | 824 |
case USB_TOKEN_IN: |
| 823 |
len = usb_handle_packet(uhci_find_device(s, async->packet.devaddr), |
|
| 824 |
&async->packet); |
|
| 825 |
len = usb_handle_packet(dev, &async->packet); |
|
| 825 | 826 |
break; |
| 826 | 827 |
|
| 827 | 828 |
default: |
| b/hw/usb-wacom.c | ||
|---|---|---|
| 306 | 306 |
|
| 307 | 307 |
switch (p->pid) {
|
| 308 | 308 |
case USB_TOKEN_IN: |
| 309 |
if (p->devep == 1) {
|
|
| 309 |
if (p->ep->nr == 1) {
|
|
| 310 | 310 |
if (!(s->changed || s->idle)) |
| 311 | 311 |
return USB_RET_NAK; |
| 312 | 312 |
s->changed = 0; |
| b/hw/usb-xhci.c | ||
|---|---|---|
| 1336 | 1336 |
} |
| 1337 | 1337 |
#endif |
| 1338 | 1338 |
|
| 1339 |
static int xhci_setup_packet(XHCITransfer *xfer, XHCIPort *port, int ep)
|
|
| 1339 |
static int xhci_setup_packet(XHCITransfer *xfer, XHCIPort *port, USBDevice *dev)
|
|
| 1340 | 1340 |
{
|
| 1341 |
usb_packet_setup(&xfer->packet, |
|
| 1342 |
xfer->in_xfer ? USB_TOKEN_IN : USB_TOKEN_OUT, |
|
| 1343 |
xfer->xhci->slots[xfer->slotid-1].devaddr, |
|
| 1344 |
ep & 0x7f); |
|
| 1341 |
USBEndpoint *ep; |
|
| 1342 |
int dir; |
|
| 1343 |
|
|
| 1344 |
dir = xfer->in_xfer ? USB_TOKEN_IN : USB_TOKEN_OUT; |
|
| 1345 |
ep = usb_ep_get(dev, dir, xfer->epid >> 1); |
|
| 1346 |
usb_packet_setup(&xfer->packet, dir, ep); |
|
| 1345 | 1347 |
usb_packet_addbuf(&xfer->packet, xfer->data, xfer->data_length); |
| 1346 | 1348 |
DPRINTF("xhci: setup packet pid 0x%x addr %d ep %d\n",
|
| 1347 |
xfer->packet.pid, xfer->packet.devaddr, xfer->packet.devep);
|
|
| 1349 |
xfer->packet.pid, dev->addr, ep->nr);
|
|
| 1348 | 1350 |
return 0; |
| 1349 | 1351 |
} |
| 1350 | 1352 |
|
| ... | ... | |
| 1462 | 1464 |
xfer->in_xfer = bmRequestType & USB_DIR_IN; |
| 1463 | 1465 |
xfer->iso_xfer = false; |
| 1464 | 1466 |
|
| 1465 |
xhci_setup_packet(xfer, port, 0);
|
|
| 1467 |
xhci_setup_packet(xfer, port, dev);
|
|
| 1466 | 1468 |
if (!xfer->in_xfer) {
|
| 1467 | 1469 |
xhci_xfer_data(xfer, xfer->data, wLength, 0, 1, 0); |
| 1468 | 1470 |
} |
| ... | ... | |
| 1484 | 1486 |
int ret; |
| 1485 | 1487 |
|
| 1486 | 1488 |
DPRINTF("xhci_submit(slotid=%d,epid=%d)\n", xfer->slotid, xfer->epid);
|
| 1487 |
uint8_t ep = xfer->epid>>1; |
|
| 1488 | 1489 |
|
| 1489 | 1490 |
xfer->in_xfer = epctx->type>>2; |
| 1490 |
if (xfer->in_xfer) {
|
|
| 1491 |
ep |= 0x80; |
|
| 1492 |
} |
|
| 1493 | 1491 |
|
| 1494 | 1492 |
if (xfer->data && xfer->data_alloced < xfer->data_length) {
|
| 1495 | 1493 |
xfer->data_alloced = 0; |
| ... | ... | |
| 1517 | 1515 |
return -1; |
| 1518 | 1516 |
} |
| 1519 | 1517 |
|
| 1520 |
xhci_setup_packet(xfer, port, ep);
|
|
| 1518 |
xhci_setup_packet(xfer, port, dev);
|
|
| 1521 | 1519 |
|
| 1522 | 1520 |
switch(epctx->type) {
|
| 1523 | 1521 |
case ET_INTR_OUT: |
| ... | ... | |
| 1530 | 1528 |
FIXME(); |
| 1531 | 1529 |
break; |
| 1532 | 1530 |
default: |
| 1533 |
fprintf(stderr, "xhci: unknown or unhandled EP type %d (ep %02x)\n", |
|
| 1534 |
epctx->type, ep); |
|
| 1531 |
fprintf(stderr, "xhci: unknown or unhandled EP " |
|
| 1532 |
"(type %d, in %d, ep %02x)\n", |
|
| 1533 |
epctx->type, xfer->in_xfer, xfer->epid); |
|
| 1535 | 1534 |
return -1; |
| 1536 | 1535 |
} |
| 1537 | 1536 |
|
| b/hw/usb.c | ||
|---|---|---|
| 140 | 140 |
int request, value, index; |
| 141 | 141 |
int ret = 0; |
| 142 | 142 |
|
| 143 |
assert(p->devep == 0);
|
|
| 143 |
assert(p->ep->nr == 0);
|
|
| 144 | 144 |
|
| 145 | 145 |
request = (s->setup_buf[0] << 8) | s->setup_buf[1]; |
| 146 | 146 |
value = (s->setup_buf[3] << 8) | s->setup_buf[2]; |
| ... | ... | |
| 186 | 186 |
|
| 187 | 187 |
static int do_token_out(USBDevice *s, USBPacket *p) |
| 188 | 188 |
{
|
| 189 |
assert(p->devep == 0);
|
|
| 189 |
assert(p->ep->nr == 0);
|
|
| 190 | 190 |
|
| 191 | 191 |
switch(s->setup_state) {
|
| 192 | 192 |
case SETUP_STATE_ACK: |
| ... | ... | |
| 289 | 289 |
if (dev == NULL) {
|
| 290 | 290 |
return USB_RET_NODEV; |
| 291 | 291 |
} |
| 292 |
assert(dev->addr == p->devaddr);
|
|
| 292 |
assert(dev == p->ep->dev);
|
|
| 293 | 293 |
assert(dev->state == USB_STATE_DEFAULT); |
| 294 | 294 |
assert(p->state == USB_PACKET_SETUP); |
| 295 | 295 |
|
| 296 |
if (p->devep == 0) {
|
|
| 296 |
if (p->ep->nr == 0) {
|
|
| 297 | 297 |
/* control pipe */ |
| 298 | 298 |
switch (p->pid) {
|
| 299 | 299 |
case USB_TOKEN_SETUP: |
| ... | ... | |
| 315 | 315 |
} |
| 316 | 316 |
|
| 317 | 317 |
if (ret == USB_RET_ASYNC) {
|
| 318 |
p->ep = usb_ep_get(dev, p->pid, p->devep); |
|
| 319 | 318 |
p->state = USB_PACKET_ASYNC; |
| 320 | 319 |
} |
| 321 | 320 |
return ret; |
| ... | ... | |
| 347 | 346 |
qemu_iovec_init(&p->iov, 1); |
| 348 | 347 |
} |
| 349 | 348 |
|
| 350 |
void usb_packet_setup(USBPacket *p, int pid, uint8_t addr, uint8_t ep)
|
|
| 349 |
void usb_packet_setup(USBPacket *p, int pid, USBEndpoint *ep)
|
|
| 351 | 350 |
{
|
| 352 | 351 |
assert(!usb_packet_is_inflight(p)); |
| 353 | 352 |
p->state = USB_PACKET_SETUP; |
| 354 | 353 |
p->pid = pid; |
| 355 |
p->devaddr = addr; |
|
| 356 |
p->devep = ep; |
|
| 354 |
p->ep = ep; |
|
| 357 | 355 |
p->result = 0; |
| 358 | 356 |
qemu_iovec_reset(&p->iov); |
| 359 | 357 |
} |
| ... | ... | |
| 464 | 462 |
|
| 465 | 463 |
struct USBEndpoint *usb_ep_get(USBDevice *dev, int pid, int ep) |
| 466 | 464 |
{
|
| 467 |
struct USBEndpoint *eps = pid == USB_TOKEN_IN ? dev->ep_in : dev->ep_out; |
|
| 465 |
struct USBEndpoint *eps; |
|
| 466 |
|
|
| 467 |
if (dev == NULL) {
|
|
| 468 |
return NULL; |
|
| 469 |
} |
|
| 470 |
eps = (pid == USB_TOKEN_IN) ? dev->ep_in : dev->ep_out; |
|
| 468 | 471 |
if (ep == 0) {
|
| 469 | 472 |
return &dev->ep_ctl; |
| 470 | 473 |
} |
| b/hw/usb.h | ||
|---|---|---|
| 321 | 321 |
struct USBPacket {
|
| 322 | 322 |
/* Data fields for use by the driver. */ |
| 323 | 323 |
int pid; |
| 324 |
uint8_t devaddr; |
|
| 325 |
uint8_t devep; |
|
| 326 | 324 |
USBEndpoint *ep; |
| 327 | 325 |
QEMUIOVector iov; |
| 328 | 326 |
int result; /* transfer length or USB_RET_* status code */ |
| ... | ... | |
| 331 | 329 |
}; |
| 332 | 330 |
|
| 333 | 331 |
void usb_packet_init(USBPacket *p); |
| 334 |
void usb_packet_setup(USBPacket *p, int pid, uint8_t addr, uint8_t ep);
|
|
| 332 |
void usb_packet_setup(USBPacket *p, int pid, USBEndpoint *ep);
|
|
| 335 | 333 |
void usb_packet_addbuf(USBPacket *p, void *ptr, size_t len); |
| 336 | 334 |
int usb_packet_map(USBPacket *p, QEMUSGList *sgl); |
| 337 | 335 |
void usb_packet_unmap(USBPacket *p); |
| b/usb-bsd.c | ||
|---|---|---|
| 214 | 214 |
int ret, fd, mode; |
| 215 | 215 |
int one = 1, shortpacket = 0, timeout = 50; |
| 216 | 216 |
sigset_t new_mask, old_mask; |
| 217 |
uint8_t devep = p->devep;
|
|
| 217 |
uint8_t devep = p->ep->nr;
|
|
| 218 | 218 |
|
| 219 | 219 |
/* protect data transfers from SIGALRM signal */ |
| 220 | 220 |
sigemptyset(&new_mask); |
| b/usb-linux.c | ||
|---|---|---|
| 137 | 137 |
[USB_ENDPOINT_XFER_BULK] = USBDEVFS_URB_TYPE_BULK, |
| 138 | 138 |
[USB_ENDPOINT_XFER_INT] = USBDEVFS_URB_TYPE_INTERRUPT, |
| 139 | 139 |
}; |
| 140 |
uint8_t type = usb_ep_get_type(&s->dev, p->pid, p->devep);
|
|
| 140 |
uint8_t type = p->ep->type;
|
|
| 141 | 141 |
assert(type < ARRAY_SIZE(usbfs)); |
| 142 | 142 |
return usbfs[type]; |
| 143 | 143 |
} |
| ... | ... | |
| 360 | 360 |
break; |
| 361 | 361 |
|
| 362 | 362 |
case -EPIPE: |
| 363 |
set_halt(s, p->pid, p->devep);
|
|
| 363 |
set_halt(s, p->pid, p->ep->nr);
|
|
| 364 | 364 |
p->result = USB_RET_STALL; |
| 365 | 365 |
break; |
| 366 | 366 |
|
| ... | ... | |
| 733 | 733 |
int i, j, ret, max_packet_size, offset, len = 0; |
| 734 | 734 |
uint8_t *buf; |
| 735 | 735 |
|
| 736 |
max_packet_size = usb_ep_get_max_packet_size(&s->dev, p->pid, p->devep);
|
|
| 736 |
max_packet_size = p->ep->max_packet_size;
|
|
| 737 | 737 |
if (max_packet_size == 0) |
| 738 | 738 |
return USB_RET_NAK; |
| 739 | 739 |
|
| 740 |
aurb = get_iso_urb(s, p->pid, p->devep);
|
|
| 740 |
aurb = get_iso_urb(s, p->pid, p->ep->nr);
|
|
| 741 | 741 |
if (!aurb) {
|
| 742 |
aurb = usb_host_alloc_iso(s, p->pid, p->devep);
|
|
| 742 |
aurb = usb_host_alloc_iso(s, p->pid, p->ep->nr);
|
|
| 743 | 743 |
} |
| 744 | 744 |
|
| 745 |
i = get_iso_urb_idx(s, p->pid, p->devep);
|
|
| 745 |
i = get_iso_urb_idx(s, p->pid, p->ep->nr);
|
|
| 746 | 746 |
j = aurb[i].iso_frame_idx; |
| 747 | 747 |
if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
|
| 748 | 748 |
if (in) {
|
| ... | ... | |
| 769 | 769 |
} |
| 770 | 770 |
} else {
|
| 771 | 771 |
len = p->iov.size; |
| 772 |
offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep);
|
|
| 772 |
offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->ep->nr);
|
|
| 773 | 773 |
|
| 774 | 774 |
/* Check the frame fits */ |
| 775 | 775 |
if (len > max_packet_size) {
|
| ... | ... | |
| 781 | 781 |
usb_packet_copy(p, aurb[i].urb.buffer + offset, len); |
| 782 | 782 |
aurb[i].urb.iso_frame_desc[j].length = len; |
| 783 | 783 |
offset += len; |
| 784 |
set_iso_buffer_used(s, p->pid, p->devep, offset);
|
|
| 784 |
set_iso_buffer_used(s, p->pid, p->ep->nr, offset);
|
|
| 785 | 785 |
|
| 786 | 786 |
/* Start the stream once we have buffered enough data */ |
| 787 |
if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) {
|
|
| 788 |
set_iso_started(s, p->pid, p->devep);
|
|
| 787 |
if (!is_iso_started(s, p->pid, p->ep->nr) && i == 1 && j == 8) {
|
|
| 788 |
set_iso_started(s, p->pid, p->ep->nr);
|
|
| 789 | 789 |
} |
| 790 | 790 |
} |
| 791 | 791 |
aurb[i].iso_frame_idx++; |
| 792 | 792 |
if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
|
| 793 | 793 |
i = (i + 1) % s->iso_urb_count; |
| 794 |
set_iso_urb_idx(s, p->pid, p->devep, i);
|
|
| 794 |
set_iso_urb_idx(s, p->pid, p->ep->nr, i);
|
|
| 795 | 795 |
} |
| 796 | 796 |
} else {
|
| 797 | 797 |
if (in) {
|
| 798 |
set_iso_started(s, p->pid, p->devep);
|
|
| 798 |
set_iso_started(s, p->pid, p->ep->nr);
|
|
| 799 | 799 |
} else {
|
| 800 | 800 |
DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
|
| 801 | 801 |
} |
| 802 | 802 |
} |
| 803 | 803 |
|
| 804 |
if (is_iso_started(s, p->pid, p->devep)) {
|
|
| 804 |
if (is_iso_started(s, p->pid, p->ep->nr)) {
|
|
| 805 | 805 |
/* (Re)-submit all fully consumed / filled urbs */ |
| 806 | 806 |
for (i = 0; i < s->iso_urb_count; i++) {
|
| 807 | 807 |
if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
|
| ... | ... | |
| 821 | 821 |
break; |
| 822 | 822 |
} |
| 823 | 823 |
aurb[i].iso_frame_idx = -1; |
| 824 |
change_iso_inflight(s, p->pid, p->devep, 1);
|
|
| 824 |
change_iso_inflight(s, p->pid, p->ep->nr, 1);
|
|
| 825 | 825 |
} |
| 826 | 826 |
} |
| 827 | 827 |
} |
| ... | ... | |
| 840 | 840 |
|
| 841 | 841 |
trace_usb_host_req_data(s->bus_num, s->addr, |
| 842 | 842 |
p->pid == USB_TOKEN_IN, |
| 843 |
p->devep, p->iov.size);
|
|
| 843 |
p->ep->nr, p->iov.size);
|
|
| 844 | 844 |
|
| 845 |
if (!is_valid(s, p->pid, p->devep)) {
|
|
| 845 |
if (!is_valid(s, p->pid, p->ep->nr)) {
|
|
| 846 | 846 |
trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK); |
| 847 | 847 |
return USB_RET_NAK; |
| 848 | 848 |
} |
| 849 | 849 |
|
| 850 | 850 |
if (p->pid == USB_TOKEN_IN) {
|
| 851 |
ep = p->devep | 0x80;
|
|
| 851 |
ep = p->ep->nr | 0x80;
|
|
| 852 | 852 |
} else {
|
| 853 |
ep = p->devep;
|
|
| 853 |
ep = p->ep->nr;
|
|
| 854 | 854 |
} |
| 855 | 855 |
|
| 856 |
if (is_halted(s, p->pid, p->devep)) {
|
|
| 856 |
if (is_halted(s, p->pid, p->ep->nr)) {
|
|
| 857 | 857 |
unsigned int arg = ep; |
| 858 | 858 |
ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg); |
| 859 | 859 |
if (ret < 0) {
|
| ... | ... | |
| 861 | 861 |
trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK); |
| 862 | 862 |
return USB_RET_NAK; |
| 863 | 863 |
} |
| 864 |
clear_halt(s, p->pid, p->devep);
|
|
| 864 |
clear_halt(s, p->pid, p->ep->nr);
|
|
| 865 | 865 |
} |
| 866 | 866 |
|
| 867 |
if (is_isoc(s, p->pid, p->devep)) {
|
|
| 867 |
if (is_isoc(s, p->pid, p->ep->nr)) {
|
|
| 868 | 868 |
return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN); |
| 869 | 869 |
} |
| 870 | 870 |
|
| ... | ... | |
| 1057 | 1057 |
urb = &aurb->urb; |
| 1058 | 1058 |
|
| 1059 | 1059 |
urb->type = USBDEVFS_URB_TYPE_CONTROL; |
| 1060 |
urb->endpoint = p->devep;
|
|
| 1060 |
urb->endpoint = p->ep->nr;
|
|
| 1061 | 1061 |
|
| 1062 | 1062 |
urb->buffer = &dev->setup_buf; |
| 1063 | 1063 |
urb->buffer_length = length + 8; |
| b/usb-redir.c | ||
|---|---|---|
| 610 | 610 |
USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev); |
| 611 | 611 |
uint8_t ep; |
| 612 | 612 |
|
| 613 |
ep = p->devep;
|
|
| 613 |
ep = p->ep->nr;
|
|
| 614 | 614 |
if (p->pid == USB_TOKEN_IN) {
|
| 615 | 615 |
ep |= USB_DIR_IN; |
| 616 | 616 |
} |
Also available in: Unified diff