xhci-mem.c revision 8df75f42f8e67e2851cdcf6da91640fb881defd1
166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp/* 266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * xHCI host controller driver 366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * 466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Copyright (C) 2008 Intel Corp. 566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * 666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Author: Sarah Sharp 766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Some code borrowed from the Linux EHCI driver. 866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * 966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * This program is free software; you can redistribute it and/or modify 1066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * it under the terms of the GNU General Public License version 2 as 1166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * published by the Free Software Foundation. 1266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * 1366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * This program is distributed in the hope that it will be useful, but 1466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 1566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * for more details. 1766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * 1866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * You should have received a copy of the GNU General Public License 1966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * along with this program; if not, write to the Free Software Foundation, 2066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 2166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp */ 2266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 2366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp#include <linux/usb.h> 240ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp#include <linux/pci.h> 255a0e3ad6af8660be21ca98a971cd00f331318c05Tejun Heo#include <linux/slab.h> 26527c6d7f188f116852141f50b4d008f966bb17f8Sarah Sharp#include <linux/dmapool.h> 2766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 2866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp#include "xhci.h" 2966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 300ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* 310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Allocates a generic ring segment from the ring pool, sets the dma address, 320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * initializes the segment to zero, and sets the private next pointer to NULL. 330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Section 4.11.1.1: 350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * "All components of all Command and Transfer TRBs shall be initialized to '0'" 360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flags) 380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_addr_t dma; 410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = kzalloc(sizeof *seg, flags); 430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!seg) 440ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 45700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocating priv segment structure at %p\n", seg); 460ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->trbs = dma_pool_alloc(xhci->segment_pool, flags, &dma); 480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!seg->trbs) { 490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(seg); 500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 52700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Allocating segment at %p (virtual) 0x%llx (DMA)\n", 53700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman seg->trbs, (unsigned long long)dma); 540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp memset(seg->trbs, 0, SEGMENT_SIZE); 560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->dma = dma; 570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->next = NULL; 580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return seg; 600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg) 630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!seg) 650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (seg->trbs) { 67700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Freeing DMA segment at %p (virtual) 0x%llx (DMA)\n", 68700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman seg->trbs, (unsigned long long)seg->dma); 690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma); 700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->trbs = NULL; 710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 72700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Freeing priv segment structure at %p\n", seg); 730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(seg); 740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* 770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Make the prev segment point to the next segment. 780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Change the last TRB in the prev segment to be a Link TRB which points to the 800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * DMA address of the next segment. The caller needs to set any Link TRB 810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * related flags, such as End TRB, Toggle Cycle, and no snoop. 820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev, 840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next, bool link_trbs) 850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp u32 val; 870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!prev || !next) 890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->next = next; 910ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (link_trbs) { 928e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr = next->dma; 930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the last TRB in the segment to have a TRB type ID of Link TRB */ 950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = prev->trbs[TRBS_PER_SEGMENT-1].link.control; 960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ~TRB_TYPE_BITMASK; 970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= TRB_TYPE(TRB_LINK); 98b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp /* Always set the chain bit with 0.95 hardware */ 99b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp if (xhci_link_trb_quirk(xhci)) 100b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp val |= TRB_CHAIN; 1010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.control = val; 1020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 103700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n", 104700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)prev->dma, 105700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)next->dma); 1060ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1080ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* XXX: Do we need the hcd structure in all these functions? */ 109f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring) 1100ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 1120ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *first_seg; 1130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring || !ring->first_seg) 1150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 1160ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp first_seg = ring->first_seg; 1170ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = first_seg->next; 118700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Freeing ring at %p\n", ring); 1190ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (seg != first_seg) { 1200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next = seg->next; 1210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, seg); 1220ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = next; 1230ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1240ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, first_seg); 1250ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = NULL; 1260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(ring); 1270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 12974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharpstatic void xhci_initialize_ring_info(struct xhci_ring *ring) 13074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp{ 13174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* The ring is empty, so the enqueue pointer == dequeue pointer */ 13274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->enqueue = ring->first_seg->trbs; 13374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->enq_seg = ring->first_seg; 13474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->dequeue = ring->enqueue; 13574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->deq_seg = ring->first_seg; 13674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* The ring is initialized to 0. The producer must write 1 to the cycle 13774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * bit to handover ownership of the TRB, so PCS = 1. The consumer must 13874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * compare CCS to the cycle bit to check ownership, so CCS = 1. 13974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp */ 14074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->cycle_state = 1; 14174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* Not necessary for new rings, but needed for re-initialized rings */ 14274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->enq_updates = 0; 14374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->deq_updates = 0; 14474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp} 14574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 1460ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/** 1470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Create a new ring with zero or more segments. 1480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 1490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Link each segment together into a ring. 1500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Set the end flag and the cycle toggle bit on the last segment. 1510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 4.9.1 and figures 15 and 16. 1520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 1530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci, 1540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp unsigned int num_segs, bool link_trbs, gfp_t flags) 1550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_ring *ring; 1570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *prev; 1580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring = kzalloc(sizeof *(ring), flags); 160700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocating ring at %p\n", ring); 1610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring) 1620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 1630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 164d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp INIT_LIST_HEAD(&ring->td_list); 1650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (num_segs == 0) 1660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = xhci_segment_alloc(xhci, flags); 1690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring->first_seg) 1700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = ring->first_seg; 1740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (num_segs > 0) { 1750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next; 1760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp next = xhci_segment_alloc(xhci, flags); 1780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!next) 1790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, next, link_trbs); 1810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = next; 1830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, ring->first_seg, link_trbs); 1860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (link_trbs) { 1880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* See section 4.9.2.1 and 6.4.4.1 */ 1890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.control |= (LINK_TOGGLE); 1900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote link toggle flag to" 191700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman " segment %p (virtual), 0x%llx (DMA)\n", 192700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman prev, (unsigned long long)prev->dma); 1930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 19474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_initialize_ring_info(ring); 1950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpfail: 1980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, ring); 1990ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 2000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 2010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 202412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharpvoid xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci, 203412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp struct xhci_virt_device *virt_dev, 204412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp unsigned int ep_index) 205412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp{ 206412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp int rings_cached; 207412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp 208412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp rings_cached = virt_dev->num_rings_cached; 209412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp if (rings_cached < XHCI_MAX_RINGS_CACHED) { 210412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->num_rings_cached++; 211412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp rings_cached = virt_dev->num_rings_cached; 212412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->ring_cache[rings_cached] = 213412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->eps[ep_index].ring; 214412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp xhci_dbg(xhci, "Cached old ring, " 215412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp "%d ring%s cached\n", 216412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp rings_cached, 217412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp (rings_cached > 1) ? "s" : ""); 218412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp } else { 219412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp xhci_ring_free(xhci, virt_dev->eps[ep_index].ring); 220412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp xhci_dbg(xhci, "Ring cache full (%d rings), " 221412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp "freeing ring\n", 222412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->num_rings_cached); 223412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp } 224412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->eps[ep_index].ring = NULL; 225412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp} 226412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp 22774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp/* Zero an endpoint ring (except for link TRBs) and move the enqueue and dequeue 22874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * pointers to the beginning of the ring. 22974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp */ 23074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharpstatic void xhci_reinit_cached_ring(struct xhci_hcd *xhci, 23174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp struct xhci_ring *ring) 23274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp{ 23374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp struct xhci_segment *seg = ring->first_seg; 23474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp do { 23574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp memset(seg->trbs, 0, 23674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp sizeof(union xhci_trb)*TRBS_PER_SEGMENT); 23774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* All endpoint rings have link TRBs */ 23874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_link_segments(xhci, seg, seg->next, 1); 23974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp seg = seg->next; 24074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp } while (seg != ring->first_seg); 24174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_initialize_ring_info(ring); 24274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* td list should be empty since all URBs have been cancelled, 24374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * but just in case... 24474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp */ 24574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp INIT_LIST_HEAD(&ring->td_list); 24674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp} 24774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 248d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn#define CTX_SIZE(_hcc) (HCC_64BYTE_CONTEXT(_hcc) ? 64 : 32) 249d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 250d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci, 251d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn int type, gfp_t flags) 252d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 253d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx = kzalloc(sizeof(*ctx), flags); 254d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (!ctx) 255d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return NULL; 256d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 257d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn BUG_ON((type != XHCI_CTX_TYPE_DEVICE) && (type != XHCI_CTX_TYPE_INPUT)); 258d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->type = type; 259d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->size = HCC_64BYTE_CONTEXT(xhci->hcc_params) ? 2048 : 1024; 260d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (type == XHCI_CTX_TYPE_INPUT) 261d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->size += CTX_SIZE(xhci->hcc_params); 262d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 263d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->bytes = dma_pool_alloc(xhci->device_pool, flags, &ctx->dma); 264d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn memset(ctx->bytes, 0, ctx->size); 265d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return ctx; 266d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 267d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 268d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younvoid xhci_free_container_ctx(struct xhci_hcd *xhci, 269d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 270d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 271a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp if (!ctx) 272a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp return; 273d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dma_pool_free(xhci->device_pool, ctx->bytes, ctx->dma); 274d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn kfree(ctx); 275d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 276d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 277d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci, 278d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 279d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 280d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn BUG_ON(ctx->type != XHCI_CTX_TYPE_INPUT); 281d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_input_control_ctx *)ctx->bytes; 282d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 283d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 284d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, 285d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 286d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 287d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (ctx->type == XHCI_CTX_TYPE_DEVICE) 288d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_slot_ctx *)ctx->bytes; 289d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 290d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_slot_ctx *) 291d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (ctx->bytes + CTX_SIZE(xhci->hcc_params)); 292d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 293d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 294d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci, 295d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx, 296d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn unsigned int ep_index) 297d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 298d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn /* increment ep index by offset of start of ep ctx array */ 299d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_index++; 300d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (ctx->type == XHCI_CTX_TYPE_INPUT) 301d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_index++; 302d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 303d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_ep_ctx *) 304d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (ctx->bytes + (ep_index * CTX_SIZE(xhci->hcc_params))); 305d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 306d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 3078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/***************** Streams structures manipulation *************************/ 3098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpvoid xhci_free_stream_ctx(struct xhci_hcd *xhci, 3118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_stream_ctxs, 3128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_ctx *stream_ctx, dma_addr_t dma) 3138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 3148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 3158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE) 3178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp pci_free_consistent(pdev, 3188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_stream_ctx)*num_stream_ctxs, 3198df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_ctx, dma); 3208df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE) 3218df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_free(xhci->small_streams_pool, 3228df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_ctx, dma); 3238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else 3248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_free(xhci->medium_streams_pool, 3258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_ctx, dma); 3268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 3278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 3298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The stream context array for each endpoint with bulk streams enabled can 3308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * vary in size, based on: 3318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * - how many streams the endpoint supports, 3328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * - the maximum primary stream array size the host controller supports, 3338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * - and how many streams the device driver asks for. 3348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 3358df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The stream context array must be a power of 2, and can be as small as 3368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 64 bytes or as large as 1MB. 3378df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 3388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpstruct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci, 3398df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_stream_ctxs, dma_addr_t *dma, 3408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp gfp_t mem_flags) 3418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 3428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 3438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE) 3458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return pci_alloc_consistent(pdev, 3468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_stream_ctx)*num_stream_ctxs, 3478df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma); 3488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE) 3498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_alloc(xhci->small_streams_pool, 3508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags, dma); 3518df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else 3528df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_alloc(xhci->medium_streams_pool, 3538df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags, dma); 3548df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 3558df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3568df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING 3578df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpstruct xhci_ring *dma_to_stream_ring( 3588df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info, 3598df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u64 address) 3608df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 3618df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return radix_tree_lookup(&stream_info->trb_address_map, 3628df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp address >> SEGMENT_SHIFT); 3638df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 3648df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#endif /* CONFIG_USB_XHCI_HCD_DEBUGGING */ 3658df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3668df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING 3678df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpstatic int xhci_test_radix_tree(struct xhci_hcd *xhci, 3688df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_streams, 3698df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info) 3708df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 3718df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u32 cur_stream; 3728df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *cur_ring; 3738df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u64 addr; 3748df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 3768df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *mapped_ring; 3778df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp int trb_size = sizeof(union xhci_trb); 3788df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 3808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (addr = cur_ring->first_seg->dma; 3818df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr < cur_ring->first_seg->dma + SEGMENT_SIZE; 3828df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr += trb_size) { 3838df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring = dma_to_stream_ring(stream_info, addr); 3848df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (cur_ring != mapped_ring) { 3858df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_warn(xhci, "WARN: DMA address 0x%08llx " 3868df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "didn't map to stream ID %u; " 3878df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "mapped to ring %p\n", 3888df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp (unsigned long long) addr, 3898df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream, 3908df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring); 3918df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return -EINVAL; 3928df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 3938df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 3948df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* One TRB after the end of the ring segment shouldn't return a 3958df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * pointer to the current ring (although it may be a part of a 3968df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * different ring). 3978df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 3988df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring = dma_to_stream_ring(stream_info, addr); 3998df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (mapped_ring != cur_ring) { 4008df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* One TRB before should also fail */ 4018df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma - trb_size; 4028df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring = dma_to_stream_ring(stream_info, addr); 4038df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4048df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (mapped_ring == cur_ring) { 4058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_warn(xhci, "WARN: Bad DMA address 0x%08llx " 4068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "mapped to valid stream ID %u; " 4078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "mapped ring = %p\n", 4088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp (unsigned long long) addr, 4098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream, 4108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring); 4118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return -EINVAL; 4128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return 0; 4158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 4168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#endif /* CONFIG_USB_XHCI_HCD_DEBUGGING */ 4178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 4198df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Change an endpoint's internal structure so it supports stream IDs. The 4208df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * number of requested streams includes stream 0, which cannot be used by device 4218df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * drivers. 4228df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The number of stream contexts in the stream context array may be bigger than 4248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * the number of streams the driver wants to use. This is because the number of 4258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * stream context array entries must be a power of two. 4268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * We need a radix tree for mapping physical addresses of TRBs to which stream 4288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * ID they belong to. We need to do this because the host controller won't tell 4298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * us which stream ring the TRB came from. We could store the stream ID in an 4308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * event data TRB, but that doesn't help us for the cancellation case, since the 4318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * endpoint may stop before it reaches that event data TRB. 4328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The radix tree maps the upper portion of the TRB DMA address to a ring 4348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * segment that has the same upper portion of DMA addresses. For example, say I 4358df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * have segments of size 1KB, that are always 64-byte aligned. A segment may 4368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * start at 0x10c91000 and end at 0x10c913f0. If I use the upper 10 bits, the 4378df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * key to the stream ID is 0x43244. I can use the DMA address of the TRB to 4388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * pass the radix tree a key to get the right stream ID: 4398df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 0x10c90fff >> 10 = 0x43243 4418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 0x10c912c0 >> 10 = 0x43244 4428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 0x10c91400 >> 10 = 0x43245 4438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Obviously, only those TRBs with DMA addresses that are within the segment 4458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * will make the radix tree return the stream ID for that ring. 4468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4478df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Caveats for the radix tree: 4488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The radix tree uses an unsigned long as a key pair. On 32-bit systems, an 4508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * unsigned long will be 32-bits; on a 64-bit system an unsigned long will be 4518df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 64-bits. Since we only request 32-bit DMA addresses, we can use that as the 4528df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * key on 32-bit or 64-bit systems (it would also be fine if we asked for 64-bit 4538df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * PCI DMA addresses on a 64-bit system). There might be a problem on 32-bit 4548df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * extended systems (where the DMA address can be bigger than 32-bits), 4558df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * if we allow the PCI dma mask to be bigger than 32-bits. So don't do that. 4568df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 4578df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpstruct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci, 4588df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_stream_ctxs, 4598df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_streams, gfp_t mem_flags) 4608df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 4618df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info; 4628df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u32 cur_stream; 4638df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *cur_ring; 4648df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned long key; 4658df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u64 addr; 4668df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp int ret; 4678df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4688df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Allocating %u streams and %u " 4698df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "stream context array entries.\n", 4708df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp num_streams, num_stream_ctxs); 4718df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci->cmd_ring_reserved_trbs == MAX_RSVD_CMD_TRBS) { 4728df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Command ring has no reserved TRBs available\n"); 4738df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return NULL; 4748df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->cmd_ring_reserved_trbs++; 4768df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4778df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info = kzalloc(sizeof(struct xhci_stream_info), mem_flags); 4788df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info) 4798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_trbs; 4808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4818df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->num_streams = num_streams; 4828df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->num_stream_ctxs = num_stream_ctxs; 4838df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4848df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Initialize the array of virtual pointers to stream rings. */ 4858df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings = kzalloc( 4868df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_ring *)*num_streams, 4878df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags); 4888df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info->stream_rings) 4898df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_info; 4908df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4918df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Initialize the array of DMA addresses for stream rings for the HW. */ 4928df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_ctx_array = xhci_alloc_stream_ctx(xhci, 4938df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp num_stream_ctxs, &stream_info->ctx_array_dma, 4948df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags); 4958df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info->stream_ctx_array) 4968df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_ctx; 4978df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp memset(stream_info->stream_ctx_array, 0, 4988df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_stream_ctx)*num_stream_ctxs); 4998df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5008df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Allocate everything needed to free the stream rings later */ 5018df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->free_streams_command = 5028df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_alloc_command(xhci, true, true, mem_flags); 5038df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info->free_streams_command) 5048df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_ctx; 5058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp INIT_RADIX_TREE(&stream_info->trb_address_map, GFP_ATOMIC); 5078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Allocate rings for all the streams that the driver will use, 5098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * and add their segment DMA addresses to the radix tree. 5108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Stream 0 is reserved. 5118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 5138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = 5148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_alloc(xhci, 1, true, mem_flags); 5158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 5168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!cur_ring) 5178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_rings; 5188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Set deq ptr, cycle bit, and stream context type */ 5198df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma | 5208df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp SCT_FOR_CTX(SCT_PRI_TR) | 5218df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring->cycle_state; 5228df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_ctx_array[cur_stream].stream_ring = addr; 5238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n", 5248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream, (unsigned long long) addr); 5258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp key = (unsigned long) 5278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp (cur_ring->first_seg->dma >> SEGMENT_SHIFT); 5288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ret = radix_tree_insert(&stream_info->trb_address_map, 5298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp key, cur_ring); 5308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (ret) { 5318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_free(xhci, cur_ring); 5328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = NULL; 5338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_rings; 5348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5358df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Leave the other unused stream ring pointers in the stream context 5378df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * array initialized to zero. This will cause the xHC to give us an 5388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * error if the device asks for a stream ID we don't have setup (if it 5398df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * was any other way, the host controller would assume the ring is 5408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * "empty" and wait forever for data to be queued to that stream ID). 5418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#if XHCI_DEBUG 5438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Do a little test on the radix tree to make sure it returns the 5448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * correct values. 5458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci_test_radix_tree(xhci, num_streams, stream_info)) 5478df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_rings; 5488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#endif 5498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return stream_info; 5518df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5528df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_rings: 5538df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 5548df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 5558df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (cur_ring) { 5568df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma; 5578df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp radix_tree_delete(&stream_info->trb_address_map, 5588df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr >> SEGMENT_SHIFT); 5598df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_free(xhci, cur_ring); 5608df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = NULL; 5618df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5628df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5638df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_command(xhci, stream_info->free_streams_command); 5648df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_ctx: 5658df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info->stream_rings); 5668df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_info: 5678df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info); 5688df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_trbs: 5698df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->cmd_ring_reserved_trbs--; 5708df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return NULL; 5718df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 5728df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 5738df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Sets the MaxPStreams field and the Linear Stream Array field. 5748df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Sets the dequeue pointer to the stream context array. 5758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5768df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpvoid xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci, 5778df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ep_ctx *ep_ctx, 5788df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info) 5798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 5808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u32 max_primary_streams; 5818df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* MaxPStreams is the number of stream context array entries, not the 5828df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * number we're actually using. Must be in 2^(MaxPstreams + 1) format. 5838df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * fls(0) = 0, fls(0x1) = 1, fls(0x10) = 2, fls(0x100) = 3, etc. 5848df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5858df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp max_primary_streams = fls(stream_info->num_stream_ctxs) - 2; 5868df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Setting number of stream ctx array entries to %u\n", 5878df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 1 << (max_primary_streams + 1)); 5888df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK; 5898df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ep_ctx->ep_info |= EP_MAXPSTREAMS(max_primary_streams); 5908df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ep_ctx->ep_info |= EP_HAS_LSA; 5918df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ep_ctx->deq = stream_info->ctx_array_dma; 5928df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 5938df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5948df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 5958df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Sets the MaxPStreams field and the Linear Stream Array field to 0. 5968df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Reinstalls the "normal" endpoint ring (at its previous dequeue mark, 5978df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * not at the beginning of the ring). 5988df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5998df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpvoid xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci, 6008df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ep_ctx *ep_ctx, 6018df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_virt_ep *ep) 6028df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 6038df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_addr_t addr; 6048df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ep_ctx->ep_info &= ~EP_MAXPSTREAMS_MASK; 6058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ep_ctx->ep_info &= ~EP_HAS_LSA; 6068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = xhci_trb_virt_to_dma(ep->ring->deq_seg, ep->ring->dequeue); 6078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ep_ctx->deq = addr | ep->ring->cycle_state; 6088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 6098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* Frees all stream contexts associated with the endpoint, 6118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 6128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Caller should fix the endpoint context streams fields. 6138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 6148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpvoid xhci_free_stream_info(struct xhci_hcd *xhci, 6158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info) 6168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 6178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp int cur_stream; 6188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *cur_ring; 6198df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_addr_t addr; 6208df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6218df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info) 6228df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return; 6238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < stream_info->num_streams; 6258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream++) { 6268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 6278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (cur_ring) { 6288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma; 6298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp radix_tree_delete(&stream_info->trb_address_map, 6308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr >> SEGMENT_SHIFT); 6318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_free(xhci, cur_ring); 6328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = NULL; 6338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 6348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 6358df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_command(xhci, stream_info->free_streams_command); 6368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->cmd_ring_reserved_trbs--; 6378df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (stream_info->stream_ctx_array) 6388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_stream_ctx(xhci, 6398df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->num_stream_ctxs, 6408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_ctx_array, 6418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->ctx_array_dma); 6428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (stream_info) 6448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info->stream_rings); 6458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info); 6468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 6478df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/***************** Device context manipulation *************************/ 6508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6516f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharpstatic void xhci_init_endpoint_timer(struct xhci_hcd *xhci, 6526f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp struct xhci_virt_ep *ep) 6536f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp{ 6546f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp init_timer(&ep->stop_cmd_timer); 6556f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp ep->stop_cmd_timer.data = (unsigned long) ep; 6566f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp ep->stop_cmd_timer.function = xhci_stop_endpoint_command_watchdog; 6576f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp ep->xhci = xhci; 6586f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp} 6596f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp 660d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp/* All the xhci_tds in the ring's TD list should be freed at this point */ 6613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpvoid xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id) 6623ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 6633ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 6643ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 6653ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 6663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 6673ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || !xhci->devs[slot_id]) 6683ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 6693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 6703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 6718e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci->dcbaa->dev_context_ptrs[slot_id] = 0; 6723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev) 6733ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 6743ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 6758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (i = 0; i < 31; ++i) { 67663a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp if (dev->eps[i].ring) 67763a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp xhci_ring_free(xhci, dev->eps[i].ring); 6788df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (dev->eps[i].stream_info) 6798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_stream_info(xhci, 6808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dev->eps[i].stream_info); 6818df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 6823ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 68374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (dev->ring_cache) { 68474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp for (i = 0; i < dev->num_rings_cached; i++) 68574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_ring_free(xhci, dev->ring_cache[i]); 68674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp kfree(dev->ring_cache); 68774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp } 68874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 6893ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->in_ctx) 690d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci_free_container_ctx(xhci, dev->in_ctx); 6913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->out_ctx) 692d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci_free_container_ctx(xhci, dev->out_ctx); 693d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 6943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp kfree(xhci->devs[slot_id]); 6953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[slot_id] = 0; 6963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 6973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 6983ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, 6993ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct usb_device *udev, gfp_t flags) 7003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 7013ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 70263a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp int i; 7033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7043ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 7053ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || xhci->devs[slot_id]) { 7063ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Bad Slot ID %d\n", slot_id); 7073ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 7083ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 7093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7103ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[slot_id] = kzalloc(sizeof(*xhci->devs[slot_id]), flags); 7113ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->devs[slot_id]) 7123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 7133ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 7143ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 715d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn /* Allocate the (output) device context that will be used in the HC. */ 716d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dev->out_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_DEVICE, flags); 7173ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->out_ctx) 7183ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 719d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 720700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Slot %d output ctx = 0x%llx (dma)\n", slot_id, 721d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (unsigned long long)dev->out_ctx->dma); 7223ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7233ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate the (input) device context for address device command */ 724d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dev->in_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, flags); 7253ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->in_ctx) 7263ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 727d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 728700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id, 729d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (unsigned long long)dev->in_ctx->dma); 7303ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7316f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp /* Initialize the cancellation list and watchdog timers for each ep */ 7326f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp for (i = 0; i < 31; i++) { 7336f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp xhci_init_endpoint_timer(xhci, &dev->eps[i]); 73463a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list); 7356f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp } 73663a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp 7373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate endpoint 0 ring */ 73863a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags); 73963a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp if (!dev->eps[0].ring) 7403ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 7413ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 74274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* Allocate pointers to the ring cache */ 74374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp dev->ring_cache = kzalloc( 74474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp sizeof(struct xhci_ring *)*XHCI_MAX_RINGS_CACHED, 74574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp flags); 74674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (!dev->ring_cache) 74774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp goto fail; 74874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp dev->num_rings_cached = 0; 74974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 750f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp init_completion(&dev->cmd_completion); 751913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp INIT_LIST_HEAD(&dev->cmd_list); 752f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 75328c2d2efb48dec2f0b050affae6d5787d6449e47Sarah Sharp /* Point to output device context in dcbaa. */ 754d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci->dcbaa->dev_context_ptrs[slot_id] = dev->out_ctx->dma; 755700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n", 7563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp slot_id, 7578e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp &xhci->dcbaa->dev_context_ptrs[slot_id], 75828c2d2efb48dec2f0b050affae6d5787d6449e47Sarah Sharp (unsigned long long) xhci->dcbaa->dev_context_ptrs[slot_id]); 7593ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7603ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 1; 7613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpfail: 7623ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, slot_id); 7633ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 7643ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 7653ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp/* Setup an xHCI virtual device for a Set Address command */ 7673ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev) 7683ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 7693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 7703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_ep_ctx *ep0_ctx; 7713ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct usb_device *top_dev; 772d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_slot_ctx *slot_ctx; 773d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_input_control_ctx *ctrl_ctx; 7743ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7753ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[udev->slot_id]; 7763ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 7773ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (udev->slot_id == 0 || !dev) { 7783ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Slot ID %d is not assigned to this device\n", 7793ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp udev->slot_id); 7803ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 7813ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 782d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep0_ctx = xhci_get_ep_ctx(xhci, dev->in_ctx, 0); 783d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctrl_ctx = xhci_get_input_control_ctx(xhci, dev->in_ctx); 784d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx); 7853ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7863ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 2) New slot context and endpoint 0 context are valid*/ 787d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctrl_ctx->add_flags = SLOT_FLAG | EP0_FLAG; 7883ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7893ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 3) Only the control endpoint is valid - one endpoint context */ 790d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= LAST_CTX(1); 7913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7924a0cd9670f22c308bc5936ee9734d8ee3f1baa52Sarah Sharp slot_ctx->dev_info |= (u32) udev->route; 7933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp switch (udev->speed) { 7943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_SUPER: 795d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_SS; 7963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 7973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_HIGH: 798d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_HS; 7993ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 8003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_FULL: 801d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_FS; 8023ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 8033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_LOW: 804d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_LS; 8053ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 806551cdbbeb118bd5ed301f8749aef69219284399bGreg Kroah-Hartman case USB_SPEED_WIRELESS: 8073ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); 8083ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 8093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 8103ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp default: 8113ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Speed was set earlier, this shouldn't happen. */ 8123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp BUG(); 8133ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 8143ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Find the root hub port this device is under */ 8153ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (top_dev = udev; top_dev->parent && top_dev->parent->parent; 8163ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp top_dev = top_dev->parent) 8173ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Found device below root hub */; 818d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info2 |= (u32) ROOT_HUB_PORT(top_dev->portnum); 8193ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Set root hub portnum to %d\n", top_dev->portnum); 8203ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8213ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Is this a LS/FS device under a HS hub? */ 8223ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if ((udev->speed == USB_SPEED_LOW || udev->speed == USB_SPEED_FULL) && 8233ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp udev->tt) { 824d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->tt_info = udev->tt->hub->slot_id; 825d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->tt_info |= udev->ttport << 8; 82607b6de102843b717ecd962cf35ec4ad9b1fbed9dSarah Sharp if (udev->tt->multi) 82707b6de102843b717ecd962cf35ec4ad9b1fbed9dSarah Sharp slot_ctx->dev_info |= DEV_MTT; 8283ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 829700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "udev->tt = %p\n", udev->tt); 8303ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport); 8313ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8323ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 4 - ring already allocated */ 8333ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 5 */ 8343ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 = EP_TYPE(CTRL_EP); 8353ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 8363ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * XXX: Not sure about wireless USB devices. 8373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp */ 83847aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp switch (udev->speed) { 83947aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_SUPER: 8403ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(512); 84147aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 84247aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_HIGH: 84347aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp /* USB core guesses at a 64-byte max packet first for FS devices */ 84447aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_FULL: 84547aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(64); 84647aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 84747aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_LOW: 8483ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(8); 84947aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 850551cdbbeb118bd5ed301f8749aef69219284399bGreg Kroah-Hartman case USB_SPEED_WIRELESS: 85147aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); 85247aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp return -EINVAL; 85347aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 85447aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp default: 85547aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp /* New speed? */ 85647aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp BUG(); 85747aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp } 8583ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */ 8593ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_BURST(0); 8603ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= ERROR_COUNT(3); 8613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8628e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp ep0_ctx->deq = 86363a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp dev->eps[0].ring->first_seg->dma; 86463a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp ep0_ctx->deq |= dev->eps[0].ring->cycle_state; 8653ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Steps 7 and 8 were done in xhci_alloc_virt_device() */ 8673ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8683ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 8693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 8703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 871f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp/* Return the polling or NAK interval. 872f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 873f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The polling interval is expressed in "microframes". If xHCI's Interval field 874f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to N, it will service the endpoint every 2^(Interval)*125us. 875f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 876f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The NAK interval is one NAK per 1 to 255 microframes, or no NAKs if interval 877f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to 0. 878f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 879f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpstatic inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev, 880f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 881f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 882f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int interval = 0; 883f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 884f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 885f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 886f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Max NAK rate */ 887f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc) || 888f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_bulk(&ep->desc)) 889f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = ep->desc.bInterval; 890f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through - SS and HS isoc/int have same decoding */ 891f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 892f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 893f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_isoc(&ep->desc)) { 894f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (ep->desc.bInterval == 0) 895f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 0; 896f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 897f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = ep->desc.bInterval - 1; 898f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval > 15) 899f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 15; 900f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval != ep->desc.bInterval + 1) 901f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n", 902f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep->desc.bEndpointAddress, 1 << interval); 903f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 904f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 905f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Convert bInterval (in 1-255 frames) to microframes and round down to 906f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * nearest power of 2. 907f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 908f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 909f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 910f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 911f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_isoc(&ep->desc)) { 912f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = fls(8*ep->desc.bInterval) - 1; 913f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval > 10) 914f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 10; 915f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval < 3) 916f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 3; 917f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if ((1 << interval) != 8*ep->desc.bInterval) 9189ce669a8924c61b7321d6e2f27ed67bcd46c1fbbSarah Sharp dev_warn(&udev->dev, 9199ce669a8924c61b7321d6e2f27ed67bcd46c1fbbSarah Sharp "ep %#x - rounding interval" 9209ce669a8924c61b7321d6e2f27ed67bcd46c1fbbSarah Sharp " to %d microframes, " 9219ce669a8924c61b7321d6e2f27ed67bcd46c1fbbSarah Sharp "ep desc says %d microframes\n", 9229ce669a8924c61b7321d6e2f27ed67bcd46c1fbbSarah Sharp ep->desc.bEndpointAddress, 9239ce669a8924c61b7321d6e2f27ed67bcd46c1fbbSarah Sharp 1 << interval, 9249ce669a8924c61b7321d6e2f27ed67bcd46c1fbbSarah Sharp 8*ep->desc.bInterval); 925f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 926f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 927f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 928f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 929f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 930f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return EP_INTERVAL(interval); 931f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 932f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 9331cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp/* The "Mult" field in the endpoint context is only set for SuperSpeed devices. 9341cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp * High speed endpoint descriptors can define "the number of additional 9351cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp * transaction opportunities per microframe", but that goes in the Max Burst 9361cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp * endpoint context field. 9371cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp */ 9381cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharpstatic inline u32 xhci_get_endpoint_mult(struct usb_device *udev, 9391cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp struct usb_host_endpoint *ep) 9401cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp{ 9411cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp if (udev->speed != USB_SPEED_SUPER || !ep->ss_ep_comp) 9421cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp return 0; 9431cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp return ep->ss_ep_comp->desc.bmAttributes; 9441cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp} 9451cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp 946f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpstatic inline u32 xhci_get_endpoint_type(struct usb_device *udev, 947f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 948f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 949f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp int in; 950f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp u32 type; 951f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 952f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp in = usb_endpoint_dir_in(&ep->desc); 953f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc)) { 954f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(CTRL_EP); 955f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_bulk(&ep->desc)) { 956f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 957f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_IN_EP); 958f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 959f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_OUT_EP); 960f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_isoc(&ep->desc)) { 961f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 962f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_IN_EP); 963f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 964f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_OUT_EP); 965f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_int(&ep->desc)) { 966f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 967f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_IN_EP); 968f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 969f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_OUT_EP); 970f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else { 971f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 972f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 973f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return type; 974f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 975f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 9769238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp/* Return the maximum endpoint service interval time (ESIT) payload. 9779238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * Basically, this is the maxpacket size, multiplied by the burst size 9789238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * and mult size. 9799238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp */ 9809238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharpstatic inline u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci, 9819238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp struct usb_device *udev, 9829238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp struct usb_host_endpoint *ep) 9839238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp{ 9849238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp int max_burst; 9859238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp int max_packet; 9869238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 9879238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp /* Only applies for interrupt or isochronous endpoints */ 9889238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc) || 9899238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp usb_endpoint_xfer_bulk(&ep->desc)) 9909238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp return 0; 9919238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 9929238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp if (udev->speed == USB_SPEED_SUPER) { 9939238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp if (ep->ss_ep_comp) 9949238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp return ep->ss_ep_comp->desc.wBytesPerInterval; 9959238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp xhci_warn(xhci, "WARN no SS endpoint companion descriptor.\n"); 9969238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp /* Assume no bursts, no multiple opportunities to send. */ 9979238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp return ep->desc.wMaxPacketSize; 9989238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp } 9999238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 10009238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp max_packet = ep->desc.wMaxPacketSize & 0x3ff; 10019238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11; 10029238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp /* A 0 in max burst means 1 transfer per ESIT */ 10039238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp return max_packet * (max_burst + 1); 10049238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp} 10059238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 10068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* Set up an endpoint with one ring segment. Do not allocate stream rings. 10078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Drivers will have to call usb_alloc_streams() to do that. 10088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 1009f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpint xhci_endpoint_init(struct xhci_hcd *xhci, 1010f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 1011f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_device *udev, 1012f88ba78d9ac0e1f583da4cada80b8816ca761a3fSarah Sharp struct usb_host_endpoint *ep, 1013f88ba78d9ac0e1f583da4cada80b8816ca761a3fSarah Sharp gfp_t mem_flags) 1014f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 1015f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 1016f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 1017f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ring *ep_ring; 1018f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_packet; 1019f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_burst; 10209238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp u32 max_esit_payload; 1021f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1022f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 1023d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); 1024f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1025f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set up the endpoint ring */ 102663a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp virt_dev->eps[ep_index].new_ring = 102763a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp xhci_ring_alloc(xhci, 1, true, mem_flags); 102874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (!virt_dev->eps[ep_index].new_ring) { 102974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* Attempt to use the ring cache */ 103074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (virt_dev->num_rings_cached == 0) 103174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp return -ENOMEM; 103274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->eps[ep_index].new_ring = 103374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->ring_cache[virt_dev->num_rings_cached]; 103474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL; 103574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->num_rings_cached--; 103674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring); 103774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp } 103863a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp ep_ring = virt_dev->eps[ep_index].new_ring; 10398e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp ep_ctx->deq = ep_ring->first_seg->dma | ep_ring->cycle_state; 1040f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1041f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep); 10421cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp ep_ctx->ep_info |= EP_MULT(xhci_get_endpoint_mult(udev, ep)); 1043f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1044f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME dig Mult and streams info out of ep companion desc */ 1045f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 104647692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp /* Allow 3 retries for everything but isoc; 104747692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp * error count = 0 means infinite retries. 104847692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp */ 1049f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (!usb_endpoint_xfer_isoc(&ep->desc)) 1050f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = ERROR_COUNT(3); 1051f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 105247692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp ep_ctx->ep_info2 = ERROR_COUNT(1); 1053f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1054f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= xhci_get_endpoint_type(udev, ep); 1055f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1056f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set the max packet size and max burst */ 1057f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 1058f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 1059f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_packet = ep->desc.wMaxPacketSize; 1060f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_PACKET(max_packet); 1061b10de142119a676552df3f0d2e3a9d647036c26aSarah Sharp /* dig out max burst from ep companion desc */ 1062b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp if (!ep->ss_ep_comp) { 1063b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp xhci_warn(xhci, "WARN no SS endpoint companion descriptor.\n"); 1064b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp max_packet = 0; 1065b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp } else { 1066b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp max_packet = ep->ss_ep_comp->desc.bMaxBurst; 1067b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp } 1068b10de142119a676552df3f0d2e3a9d647036c26aSarah Sharp ep_ctx->ep_info2 |= MAX_BURST(max_packet); 1069f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 1070f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 1071f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* bits 11:12 specify the number of additional transaction 1072f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * opportunities per microframe (USB 2.0, section 9.6.6) 1073f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 1074f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_isoc(&ep->desc) || 1075f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_int(&ep->desc)) { 1076f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11; 1077f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_BURST(max_burst); 1078f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 1079f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through */ 1080f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 1081f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 1082f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_packet = ep->desc.wMaxPacketSize & 0x3ff; 1083f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_PACKET(max_packet); 1084f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 1085f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 1086f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 1087f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 10889238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep); 10899238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp ep_ctx->tx_info = MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload); 10909238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 10919238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp /* 10929238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * XXX no idea how to calculate the average TRB buffer length for bulk 10939238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * endpoints, as the driver gives us no clue how big each scatter gather 10949238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * list entry (or buffer) is going to be. 10959238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * 10969238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * For isochronous and interrupt endpoints, we set it to the max 10979238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * available, until we have new API in the USB core to allow drivers to 10989238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * declare how much bandwidth they actually need. 10999238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * 11009238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * Normally, it would be calculated by taking the total of the buffer 11019238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * lengths in the TD and then dividing by the number of TRBs in a TD, 11029238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * including link TRBs, No-op TRBs, and Event data TRBs. Since we don't 11039238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * use Event Data TRBs, and we don't chain in a link TRB on short 11049238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * transfers, we're basically dividing by 1. 11059238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp */ 11069238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp ep_ctx->tx_info |= AVG_TRB_LENGTH_FOR_EP(max_esit_payload); 11079238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 1108f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME Debug endpoint context */ 1109f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return 0; 1110f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 1111f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1112f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_endpoint_zero(struct xhci_hcd *xhci, 1113f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 1114f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 1115f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 1116f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 1117f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 1118f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1119f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 1120d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); 1121f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1122f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info = 0; 1123f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = 0; 11248e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp ep_ctx->deq = 0; 1125f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->tx_info = 0; 1126f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Don't free the endpoint ring until the set interface or configuration 1127f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * request succeeds. 1128f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 1129f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 1130f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1131f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp/* Copy output xhci_ep_ctx to the input xhci_ep_ctx copy. 1132f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * Useful when you want to change one particular aspect of the endpoint and then 1133f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * issue a configure endpoint command. 1134f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp */ 1135f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharpvoid xhci_endpoint_copy(struct xhci_hcd *xhci, 1136913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *in_ctx, 1137913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *out_ctx, 1138913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp unsigned int ep_index) 1139f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp{ 1140f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_ep_ctx *out_ep_ctx; 1141f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_ep_ctx *in_ep_ctx; 1142f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1143913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp out_ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index); 1144913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp in_ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index); 1145f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1146f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->ep_info = out_ep_ctx->ep_info; 1147f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->ep_info2 = out_ep_ctx->ep_info2; 1148f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->deq = out_ep_ctx->deq; 1149f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->tx_info = out_ep_ctx->tx_info; 1150f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp} 1151f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1152f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp/* Copy output xhci_slot_ctx to the input xhci_slot_ctx. 1153f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * Useful when you want to change one particular aspect of the endpoint and then 1154f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * issue a configure endpoint command. Only the context entries field matters, 1155f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * but we'll copy the whole thing anyway. 1156f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp */ 1157913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharpvoid xhci_slot_copy(struct xhci_hcd *xhci, 1158913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *in_ctx, 1159913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *out_ctx) 1160f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp{ 1161f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_slot_ctx *in_slot_ctx; 1162f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_slot_ctx *out_slot_ctx; 1163f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1164913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp in_slot_ctx = xhci_get_slot_ctx(xhci, in_ctx); 1165913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp out_slot_ctx = xhci_get_slot_ctx(xhci, out_ctx); 1166f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1167f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_info = out_slot_ctx->dev_info; 1168f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_info2 = out_slot_ctx->dev_info2; 1169f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->tt_info = out_slot_ctx->tt_info; 1170f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_state = out_slot_ctx->dev_state; 1171f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp} 1172f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1173254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn/* Set up the scratchpad buffer array and scratchpad buffers, if needed. */ 1174254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Younstatic int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags) 1175254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn{ 1176254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int i; 1177254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn struct device *dev = xhci_to_hcd(xhci)->self.controller; 1178254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2); 1179254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1180254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci_dbg(xhci, "Allocating %d scratchpad buffers\n", num_sp); 1181254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1182254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!num_sp) 1183254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return 0; 1184254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1185254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = kzalloc(sizeof(*xhci->scratchpad), flags); 1186254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad) 1187254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp; 1188254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1189254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array = 1190254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_alloc_consistent(to_pci_dev(dev), 1191254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn num_sp * sizeof(u64), 1192254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn &xhci->scratchpad->sp_dma); 1193254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_array) 1194254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp2; 1195254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1196254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers = kzalloc(sizeof(void *) * num_sp, flags); 1197254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_buffers) 1198254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp3; 1199254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1200254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers = 1201254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kzalloc(sizeof(dma_addr_t) * num_sp, flags); 1202254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1203254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_dma_buffers) 1204254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp4; 1205254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1206254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->dcbaa->dev_context_ptrs[0] = xhci->scratchpad->sp_dma; 1207254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = 0; i < num_sp; i++) { 1208254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn dma_addr_t dma; 1209254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn void *buf = pci_alloc_consistent(to_pci_dev(dev), 1210254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->page_size, &dma); 1211254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!buf) 1212254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp5; 1213254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1214254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array[i] = dma; 1215254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i] = buf; 1216254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i] = dma; 1217254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 1218254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1219254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return 0; 1220254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1221254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp5: 1222254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = i - 1; i >= 0; i--) { 1223254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(to_pci_dev(dev), xhci->page_size, 1224254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i], 1225254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i]); 1226254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 1227254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_dma_buffers); 1228254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1229254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp4: 1230254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_buffers); 1231254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1232254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp3: 1233254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(to_pci_dev(dev), num_sp * sizeof(u64), 1234254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array, 1235254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma); 1236254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1237254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp2: 1238254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad); 1239254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = NULL; 1240254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1241254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp: 1242254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return -ENOMEM; 1243254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn} 1244254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1245254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Younstatic void scratchpad_free(struct xhci_hcd *xhci) 1246254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn{ 1247254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int num_sp; 1248254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int i; 1249254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 1250254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1251254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad) 1252254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return; 1253254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1254254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2); 1255254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1256254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = 0; i < num_sp; i++) { 1257254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(pdev, xhci->page_size, 1258254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i], 1259254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i]); 1260254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 1261254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_dma_buffers); 1262254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_buffers); 1263254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(pdev, num_sp * sizeof(u64), 1264254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array, 1265254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma); 1266254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad); 1267254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = NULL; 1268254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn} 1269254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1270913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharpstruct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci, 1271a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp bool allocate_in_ctx, bool allocate_completion, 1272a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp gfp_t mem_flags) 1273913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp{ 1274913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_command *command; 1275913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1276913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command = kzalloc(sizeof(*command), mem_flags); 1277913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp if (!command) 1278913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp return NULL; 1279913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1280a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp if (allocate_in_ctx) { 1281a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp command->in_ctx = 1282a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, 1283a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp mem_flags); 1284a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp if (!command->in_ctx) { 1285a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp kfree(command); 1286a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp return NULL; 1287a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp } 128806e182911da95a304eaab71288a47bc5c799c4ebJulia Lawall } 1289913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1290913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp if (allocate_completion) { 1291913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command->completion = 1292913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp kzalloc(sizeof(struct completion), mem_flags); 1293913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp if (!command->completion) { 1294913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp xhci_free_container_ctx(xhci, command->in_ctx); 129506e182911da95a304eaab71288a47bc5c799c4ebJulia Lawall kfree(command); 1296913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp return NULL; 1297913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp } 1298913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp init_completion(command->completion); 1299913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp } 1300913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1301913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command->status = 0; 1302913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp INIT_LIST_HEAD(&command->cmd_list); 1303913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp return command; 1304913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp} 1305913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1306913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharpvoid xhci_free_command(struct xhci_hcd *xhci, 1307913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_command *command) 1308913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp{ 1309913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp xhci_free_container_ctx(xhci, 1310913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command->in_ctx); 1311913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp kfree(command->completion); 1312913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp kfree(command); 1313913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp} 1314913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 131566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpvoid xhci_mem_cleanup(struct xhci_hcd *xhci) 131666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 13170ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 13180ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp int size; 13193ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 13200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 13210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Free the Event Ring Segment Table and the actual Event Ring */ 1322d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp if (xhci->ir_set) { 1323d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_size); 1324d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp xhci_write_64(xhci, 0, &xhci->ir_set->erst_base); 1325d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp xhci_write_64(xhci, 0, &xhci->ir_set->erst_dequeue); 1326d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp } 13270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries); 13280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->erst.entries) 13290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp pci_free_consistent(pdev, size, 13300ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries, xhci->erst.erst_dma_addr); 13310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = NULL; 13320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed ERST\n"); 13330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->event_ring) 13340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->event_ring); 13350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = NULL; 13360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed event ring\n"); 13370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 13388e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring); 13390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->cmd_ring) 13400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->cmd_ring); 13410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = NULL; 13420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed command ring\n"); 13433ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 13443ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 1; i < MAX_HC_SLOTS; ++i) 13453ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, i); 13463ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 13470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->segment_pool) 13480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_pool_destroy(xhci->segment_pool); 13490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = NULL; 13500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed segment pool\n"); 13513ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 13523ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (xhci->device_pool) 13533ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dma_pool_destroy(xhci->device_pool); 13543ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = NULL; 13553ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Freed device context pool\n"); 13563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 13578df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci->small_streams_pool) 13588df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_destroy(xhci->small_streams_pool); 13598df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->small_streams_pool = NULL; 13608df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Freed small stream array pool\n"); 13618df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 13628df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci->medium_streams_pool) 13638df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_destroy(xhci->medium_streams_pool); 13648df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->medium_streams_pool = NULL; 13658df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Freed medium stream array pool\n"); 13668df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 13678e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr); 1368a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (xhci->dcbaa) 1369a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp pci_free_consistent(pdev, sizeof(*xhci->dcbaa), 1370a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa, xhci->dcbaa->dma); 1371a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = NULL; 13723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 13735294bea40666db5c5d6c336b8e4e55d69fa576caSarah Sharp scratchpad_free(xhci); 137466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 0; 137566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 0; 137666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 137766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 13786648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharpstatic int xhci_test_trb_in_td(struct xhci_hcd *xhci, 13796648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *input_seg, 13806648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *start_trb, 13816648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *end_trb, 13826648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp dma_addr_t input_dma, 13836648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *result_seg, 13846648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp char *test_name, int test_number) 13856648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp{ 13866648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp unsigned long long start_dma; 13876648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp unsigned long long end_dma; 13886648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *seg; 13896648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 13906648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp start_dma = xhci_trb_virt_to_dma(input_seg, start_trb); 13916648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp end_dma = xhci_trb_virt_to_dma(input_seg, end_trb); 13926648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 13936648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp seg = trb_in_td(input_seg, start_trb, end_trb, input_dma); 13946648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (seg != result_seg) { 13956648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "WARN: %s TRB math test %d failed!\n", 13966648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp test_name, test_number); 13976648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "Tested TRB math w/ seg %p and " 13986648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "input DMA 0x%llx\n", 13996648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp input_seg, 14006648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp (unsigned long long) input_dma); 14016648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "starting TRB %p (0x%llx DMA), " 14026648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "ending TRB %p (0x%llx DMA)\n", 14036648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp start_trb, start_dma, 14046648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp end_trb, end_dma); 14056648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "Expected seg %p, got seg %p\n", 14066648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp result_seg, seg); 14076648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return -1; 14086648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } 14096648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return 0; 14106648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp} 14116648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 14126648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp/* TRB math checks for xhci_trb_in_td(), using the command and event rings. */ 14136648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharpstatic int xhci_check_trb_in_td_math(struct xhci_hcd *xhci, gfp_t mem_flags) 14146648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp{ 14156648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct { 14166648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp dma_addr_t input_dma; 14176648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *result_seg; 14186648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } simple_test_vector [] = { 14196648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* A zeroed DMA field should fail */ 14206648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { 0, NULL }, 14216648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One TRB before the ring start should fail */ 14226648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma - 16, NULL }, 14236648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One byte before the ring start should fail */ 14246648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma - 1, NULL }, 14256648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Starting TRB should succeed */ 14266648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma, xhci->event_ring->first_seg }, 14276648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Ending TRB should succeed */ 14286648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16, 14296648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci->event_ring->first_seg }, 14306648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One byte after the ring end should fail */ 14316648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16 + 1, NULL }, 14326648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One TRB after the ring end should fail */ 14336648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT)*16, NULL }, 14346648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* An address of all ones should fail */ 14356648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { (dma_addr_t) (~0), NULL }, 14366648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }; 14376648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct { 14386648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *input_seg; 14396648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *start_trb; 14406648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *end_trb; 14416648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp dma_addr_t input_dma; 14426648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *result_seg; 14436648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } complex_test_vector [] = { 14446648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Test feeding a valid DMA address from a different ring */ 14456648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14466648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = xhci->event_ring->first_seg->trbs, 14476648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 14486648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma, 14496648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14506648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 14516648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Test feeding a valid end TRB from a different ring */ 14526648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14536648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = xhci->event_ring->first_seg->trbs, 14546648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 14556648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma, 14566648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14576648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 14586648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Test feeding a valid start and end TRB from a different ring */ 14596648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14606648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = xhci->cmd_ring->first_seg->trbs, 14616648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 14626648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma, 14636648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14646648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 14656648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but after this TD */ 14666648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14676648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[0], 14686648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[3], 14696648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + 4*16, 14706648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14716648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 14726648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but before this TD */ 14736648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14746648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[3], 14756648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[6], 14766648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + 2*16, 14776648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14786648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 14796648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but after this wrapped TD */ 14806648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14816648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3], 14826648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[1], 14836648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + 2*16, 14846648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14856648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 14866648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but before this wrapped TD */ 14876648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14886648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3], 14896648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[1], 14906648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 4)*16, 14916648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14926648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 14936648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB not in this ring, and we have a wrapped TD */ 14946648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 14956648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3], 14966648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[1], 14976648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma + 2*16, 14986648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 14996648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 15006648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }; 15016648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 15026648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp unsigned int num_tests; 15036648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp int i, ret; 15046648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 15056648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp num_tests = sizeof(simple_test_vector) / sizeof(simple_test_vector[0]); 15066648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp for (i = 0; i < num_tests; i++) { 15076648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp ret = xhci_test_trb_in_td(xhci, 15086648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci->event_ring->first_seg, 15096648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci->event_ring->first_seg->trbs, 15106648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 15116648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp simple_test_vector[i].input_dma, 15126648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp simple_test_vector[i].result_seg, 15136648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "Simple", i); 15146648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (ret < 0) 15156648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return ret; 15166648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } 15176648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 15186648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp num_tests = sizeof(complex_test_vector) / sizeof(complex_test_vector[0]); 15196648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp for (i = 0; i < num_tests; i++) { 15206648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp ret = xhci_test_trb_in_td(xhci, 15216648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].input_seg, 15226648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].start_trb, 15236648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].end_trb, 15246648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].input_dma, 15256648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].result_seg, 15266648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "Complex", i); 15276648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (ret < 0) 15286648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return ret; 15296648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } 15306648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_dbg(xhci, "TRB math tests passed.\n"); 15316648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return 0; 15326648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp} 15336648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 15346648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 153566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpint xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 153666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 15370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_addr_t dma; 15380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct device *dev = xhci_to_hcd(xhci)->self.controller; 153966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp unsigned int val, val2; 15408e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp u64 val_64; 15410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 154266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp u32 page_size; 154366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp int i; 154466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 154566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = xhci_readl(xhci, &xhci->op_regs->page_size); 154666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size register = 0x%x\n", page_size); 154766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp for (i = 0; i < 16; i++) { 154866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if ((0x1 & page_size) != 0) 154966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp break; 155066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = page_size >> 1; 155166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp } 155266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if (i < 16) 155366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size of %iK\n", (1 << (i+12)) / 1024); 155466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp else 155566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "WARN: no supported page size\n"); 155666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* Use 4K pages, since that's common and the minimum the HC supports */ 155766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 12; 155866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 1 << xhci->page_shift; 155966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "HCD page size set to %iK\n", xhci->page_size / 1024); 156066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 156166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* 156266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Program the Number of Device Slots Enabled field in the CONFIG 156366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * register with the max value of slots the HC can handle. 156466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp */ 156566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val = HCS_MAX_SLOTS(xhci_readl(xhci, &xhci->cap_regs->hcs_params1)); 156666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// xHC can handle at most %d device slots.\n", 156766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 156866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val2 = xhci_readl(xhci, &xhci->op_regs->config_reg); 156966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val |= (val2 & ~HCS_SLOTS_MASK); 157066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// Setting Max device slots reg = 0x%x.\n", 157166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 157266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_writel(xhci, val, &xhci->op_regs->config_reg); 157366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 15740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 1575a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * Section 5.4.8 - doorbell array must be 1576a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * "physically contiguous and 64-byte (cache line) aligned". 1577a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp */ 1578a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = pci_alloc_consistent(to_pci_dev(dev), 1579a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp sizeof(*xhci->dcbaa), &dma); 1580a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (!xhci->dcbaa) 1581a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp goto fail; 1582a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa)); 1583a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa->dma = dma; 1584700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Device context base array address = 0x%llx (DMA), %p (virt)\n", 1585700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->dcbaa->dma, xhci->dcbaa); 15868e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr); 1587a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp 1588a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp /* 15890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Initialize the ring segment pool. The ring must be a contiguous 15900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * structure comprised of TRBs. The TRBs must be 16 byte aligned, 15910ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * however, the command ring segment needs 64-byte aligned segments, 15920ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * so we pick the greater alignment need. 15930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 15940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = dma_pool_create("xHCI ring segments", dev, 15950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp SEGMENT_SIZE, 64, xhci->page_size); 1596d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 15973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* See Table 46 and Note on Figure 55 */ 15983ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = dma_pool_create("xHCI input/output contexts", dev, 1599d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 2112, 64, xhci->page_size); 16003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->segment_pool || !xhci->device_pool) 16010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 16020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16038df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Linear stream context arrays don't have any boundary restrictions, 16048df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * and only need to be 16-byte aligned. 16058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 16068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->small_streams_pool = 16078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_create("xHCI 256 byte stream ctx arrays", 16088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dev, SMALL_STREAM_ARRAY_SIZE, 16, 0); 16098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->medium_streams_pool = 16108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_create("xHCI 1KB stream ctx arrays", 16118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dev, MEDIUM_STREAM_ARRAY_SIZE, 16, 0); 16128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Any stream context array bigger than MEDIUM_STREAM_ARRAY_SIZE 16138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * will be allocated with pci_alloc_consistent() 16148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 16158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 16168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!xhci->small_streams_pool || !xhci->medium_streams_pool) 16178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto fail; 16188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 16190ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set up the command ring to have one segments for now. */ 16200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags); 16210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->cmd_ring) 16220ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1623700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring); 1624700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "First segment DMA is 0x%llx\n", 1625700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->cmd_ring->first_seg->dma); 16260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the address in the Command Ring Control register */ 16288e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring); 16298e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) | 16308e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp (xhci->cmd_ring->first_seg->dma & (u64) ~CMD_RING_RSVD_BITS) | 16310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring->cycle_state; 16328e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_dbg(xhci, "// Setting command ring address to 0x%x\n", val); 16338e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring); 16340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_cmd_ptrs(xhci); 16350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->cap_regs->db_off); 16370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= DBOFF_MASK; 16380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x" 16390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp " from cap regs base addr\n", val); 16400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->dba = (void *) xhci->cap_regs + val; 16410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_regs(xhci); 16420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_print_run_regs(xhci); 16430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set ir_set to interrupt register set 0 */ 16440ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->ir_set = (void *) xhci->run_regs->ir_set; 16450ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16460ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 16470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Event ring setup: Allocate a normal ring, but also setup 16480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * the event ring segment table (ERST). Section 4.9.3. 16490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 16500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Allocating event ring\n"); 16510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags); 16520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->event_ring) 16530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 16546648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (xhci_check_trb_in_td_math(xhci, flags) < 0) 16556648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp goto fail; 16560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = pci_alloc_consistent(to_pci_dev(dev), 16580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma); 16590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->erst.entries) 16600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1661700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Allocated event ring segment table at 0x%llx\n", 1662700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)dma); 16630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp memset(xhci->erst.entries, 0, sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS); 16650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries = ERST_NUM_SEGS; 16660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.erst_dma_addr = dma; 1667700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Set ERST to 0; private num segs = %i, virt addr = %p, dma addr = 0x%llx\n", 16680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries, 1669700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci->erst.entries, 1670700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->erst.erst_dma_addr); 16710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ring base address and size for each segment table entry */ 16730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) { 16740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_erst_entry *entry = &xhci->erst.entries[val]; 16758e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp entry->seg_addr = seg->dma; 16760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->seg_size = TRBS_PER_SEGMENT; 16770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->rsvd = 0; 16780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = seg->next; 16790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 16800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ERST count with the number of entries in the segment table */ 16820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->ir_set->erst_size); 16830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ERST_SIZE_MASK; 16840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= ERST_NUM_SEGS; 16850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Write ERST size = %i to ir_set 0 (some bits preserved)\n", 16860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val); 16870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, val, &xhci->ir_set->erst_size); 16880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Set ERST entries to point to event ring.\n"); 16900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set the segment table base address */ 1691700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Set ERST base address for ir_set 0 = 0x%llx\n", 1692700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->erst.erst_dma_addr); 16938e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = xhci_read_64(xhci, &xhci->ir_set->erst_base); 16948e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 &= ERST_PTR_MASK; 16958e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 |= (xhci->erst.erst_dma_addr & (u64) ~ERST_PTR_MASK); 16968e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, val_64, &xhci->ir_set->erst_base); 16970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 16980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the event ring dequeue address */ 169923e3be113f42790736319c049c78e5f9a4394c02Sarah Sharp xhci_set_hc_event_deq(xhci); 17000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote ERST address to ir_set 0.\n"); 17010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_print_ir_set(xhci, xhci->ir_set, 0); 17020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 17030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 17040ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * XXX: Might need to set the Interrupter Moderation Register to 17050ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * something other than the default (~1ms minimum between interrupts). 17060ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 5.5.1.2. 17070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 17083ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp init_completion(&xhci->addr_dev); 17093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 0; i < MAX_HC_SLOTS; ++i) 17103ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[i] = 0; 171166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 1712254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (scratchpad_alloc(xhci, flags)) 1713254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail; 1714254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 171566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return 0; 1716254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 171766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpfail: 171866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "Couldn't initialize memory\n"); 171966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_mem_cleanup(xhci); 172066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return -ENOMEM; 172166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 1722