motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-15 22:21:57 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

usb/hcd-xhci: Make dma read/writes hooks pci free

Browse source 
This patch starts making the hcd-xhci.c pci free, as part of this
restructuring dma read/writes are handled without passing pci object.

Signed-off-by: Sai Pavan Boddu <sai.pavan.boddu@xilinx.com>
Reviewed-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com>
Message-id: 1600957256-6494-2-git-send-email-sai.pavan.boddu@xilinx.com
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
This commit is contained in:
Sai Pavan Boddu 2020-09-24 19:50:50 +05:30 • committed by Gerd Hoffmann
parent 8d16e72f2d
commit a5317074e1
2 changed files with 12 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

24
hw/usb/hcd-xhci.c
View file

@ -495,7 +495,7 @@ static inline void xhci_dma_read_u32s(XHCIState *xhci, dma_addr_t addr,
assert((len % sizeof(uint32_t)) == 0); assert((len % sizeof(uint32_t)) == 0);
pci_dma_read(PCI_DEVICE(xhci), addr, buf, len); dma_memory_read(xhci->as, addr, buf, len);
for (i = 0; i < (len / sizeof(uint32_t)); i++) { for (i = 0; i < (len / sizeof(uint32_t)); i++) {
buf[i] = le32_to_cpu(buf[i]); buf[i] = le32_to_cpu(buf[i]);
@ -515,7 +515,7 @@ static inline void xhci_dma_write_u32s(XHCIState *xhci, dma_addr_t addr,
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
tmp[i] = cpu_to_le32(buf[i]); tmp[i] = cpu_to_le32(buf[i]);
} }
pci_dma_write(PCI_DEVICE(xhci), addr, tmp, len); dma_memory_write(xhci->as, addr, tmp, len);
} }
static XHCIPort *xhci_lookup_port(XHCIState *xhci, struct USBPort *uport) static XHCIPort *xhci_lookup_port(XHCIState *xhci, struct USBPort *uport)
@ -644,7 +644,6 @@ static void xhci_die(XHCIState *xhci)
static void xhci_write_event(XHCIState *xhci, XHCIEvent *event, int v) static void xhci_write_event(XHCIState *xhci, XHCIEvent *event, int v)
{ {
PCIDevice *pci_dev = PCI_DEVICE(xhci);
XHCIInterrupter *intr = &xhci->intr[v]; XHCIInterrupter *intr = &xhci->intr[v];
XHCITRB ev_trb; XHCITRB ev_trb;
dma_addr_t addr; dma_addr_t addr;
@ -663,7 +662,7 @@ static void xhci_write_event(XHCIState *xhci, XHCIEvent *event, int v)
ev_trb.status, ev_trb.control); ev_trb.status, ev_trb.control);
addr = intr->er_start + TRB_SIZE*intr->er_ep_idx; addr = intr->er_start + TRB_SIZE*intr->er_ep_idx;
pci_dma_write(pci_dev, addr, &ev_trb, TRB_SIZE); dma_memory_write(xhci->as, addr, &ev_trb, TRB_SIZE);
intr->er_ep_idx++; intr->er_ep_idx++;
if (intr->er_ep_idx >= intr->er_size) { if (intr->er_ep_idx >= intr->er_size) {
@ -720,12 +719,11 @@ static void xhci_ring_init(XHCIState *xhci, XHCIRing *ring,
static TRBType xhci_ring_fetch(XHCIState *xhci, XHCIRing *ring, XHCITRB *trb, static TRBType xhci_ring_fetch(XHCIState *xhci, XHCIRing *ring, XHCITRB *trb,
dma_addr_t *addr) dma_addr_t *addr)
{ {
PCIDevice *pci_dev = PCI_DEVICE(xhci);
uint32_t link_cnt = 0; uint32_t link_cnt = 0;
while (1) { while (1) {
TRBType type; TRBType type;
pci_dma_read(pci_dev, ring->dequeue, trb, TRB_SIZE); dma_memory_read(xhci->as, ring->dequeue, trb, TRB_SIZE);
trb->addr = ring->dequeue; trb->addr = ring->dequeue;
trb->ccs = ring->ccs; trb->ccs = ring->ccs;
le64_to_cpus(&trb->parameter); le64_to_cpus(&trb->parameter);
@ -762,7 +760,6 @@ static TRBType xhci_ring_fetch(XHCIState *xhci, XHCIRing *ring, XHCITRB *trb,
static int xhci_ring_chain_length(XHCIState *xhci, const XHCIRing *ring) static int xhci_ring_chain_length(XHCIState *xhci, const XHCIRing *ring)
{ {
PCIDevice *pci_dev = PCI_DEVICE(xhci);
XHCITRB trb; XHCITRB trb;
int length = 0; int length = 0;
dma_addr_t dequeue = ring->dequeue; dma_addr_t dequeue = ring->dequeue;
@ -773,7 +770,7 @@ static int xhci_ring_chain_length(XHCIState *xhci, const XHCIRing *ring)
while (1) { while (1) {
TRBType type; TRBType type;
pci_dma_read(pci_dev, dequeue, &trb, TRB_SIZE); dma_memory_read(xhci->as, dequeue, &trb, TRB_SIZE);
le64_to_cpus(&trb.parameter); le64_to_cpus(&trb.parameter);
le32_to_cpus(&trb.status); le32_to_cpus(&trb.status);
le32_to_cpus(&trb.control); le32_to_cpus(&trb.control);
@ -828,7 +825,7 @@ static void xhci_er_reset(XHCIState *xhci, int v)
xhci_die(xhci); xhci_die(xhci);
return; return;
} }
pci_dma_read(PCI_DEVICE(xhci), erstba, &seg, sizeof(seg)); dma_memory_read(xhci->as, erstba, &seg, sizeof(seg));
le32_to_cpus(&seg.addr_low); le32_to_cpus(&seg.addr_low);
le32_to_cpus(&seg.addr_high); le32_to_cpus(&seg.addr_high);
le32_to_cpus(&seg.size); le32_to_cpus(&seg.size);
@ -1440,7 +1437,7 @@ static int xhci_xfer_create_sgl(XHCITransfer *xfer, int in_xfer)
int i; int i;
xfer->int_req = false; xfer->int_req = false;
pci_dma_sglist_init(&xfer->sgl, PCI_DEVICE(xhci), xfer->trb_count); qemu_sglist_init(&xfer->sgl, DEVICE(xhci), xfer->trb_count, xhci->as);
for (i = 0; i < xfer->trb_count; i++) { for (i = 0; i < xfer->trb_count; i++) {
XHCITRB *trb = &xfer->trbs[i]; XHCITRB *trb = &xfer->trbs[i];
dma_addr_t addr; dma_addr_t addr;
@ -2104,7 +2101,7 @@ static TRBCCode xhci_address_slot(XHCIState *xhci, unsigned int slotid,
assert(slotid >= 1 && slotid <= xhci->numslots); assert(slotid >= 1 && slotid <= xhci->numslots);
dcbaap = xhci_addr64(xhci->dcbaap_low, xhci->dcbaap_high); dcbaap = xhci_addr64(xhci->dcbaap_low, xhci->dcbaap_high);
poctx = ldq_le_pci_dma(PCI_DEVICE(xhci), dcbaap + 8 * slotid); poctx = ldq_le_dma(xhci->as, dcbaap + 8 * slotid);
ictx = xhci_mask64(pictx); ictx = xhci_mask64(pictx);
octx = xhci_mask64(poctx); octx = xhci_mask64(poctx);
@ -2442,7 +2439,7 @@ static TRBCCode xhci_get_port_bandwidth(XHCIState *xhci, uint64_t pctx)
/* TODO: actually implement real values here */ /* TODO: actually implement real values here */
bw_ctx[0] = 0; bw_ctx[0] = 0;
memset(&bw_ctx[1], 80, xhci->numports); /* 80% */ memset(&bw_ctx[1], 80, xhci->numports); /* 80% */
pci_dma_write(PCI_DEVICE(xhci), ctx, bw_ctx, sizeof(bw_ctx)); dma_memory_write(xhci->as, ctx, bw_ctx, sizeof(bw_ctx));
return CC_SUCCESS; return CC_SUCCESS;
} }
@ -3434,6 +3431,7 @@ static void usb_xhci_realize(struct PCIDevice *dev, Error **errp)
} }
usb_xhci_init(xhci); usb_xhci_init(xhci);
xhci->as = pci_get_address_space(dev);
xhci->mfwrap_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, xhci_mfwrap_timer, xhci); xhci->mfwrap_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, xhci_mfwrap_timer, xhci);
memory_region_init(&xhci->mem, OBJECT(xhci), "xhci", LEN_REGS); memory_region_init(&xhci->mem, OBJECT(xhci), "xhci", LEN_REGS);
@ -3534,7 +3532,7 @@ static int usb_xhci_post_load(void *opaque, int version_id)
continue; continue;
} }
slot->ctx = slot->ctx =
xhci_mask64(ldq_le_pci_dma(pci_dev, dcbaap + 8 * slotid)); xhci_mask64(ldq_le_dma(xhci->as, dcbaap + 8 * slotid));
xhci_dma_read_u32s(xhci, slot->ctx, slot_ctx, sizeof(slot_ctx)); xhci_dma_read_u32s(xhci, slot->ctx, slot_ctx, sizeof(slot_ctx));
slot->uport = xhci_lookup_uport(xhci, slot_ctx); slot->uport = xhci_lookup_uport(xhci, slot_ctx);
if (!slot->uport) { if (!slot->uport) {

1
hw/usb/hcd-xhci.h
View file

@ -188,6 +188,7 @@ struct XHCIState {
USBBus bus; USBBus bus;
MemoryRegion mem; MemoryRegion mem;
AddressSpace *as;
MemoryRegion mem_cap; MemoryRegion mem_cap;
MemoryRegion mem_oper; MemoryRegion mem_oper;
MemoryRegion mem_runtime; MemoryRegion mem_runtime;