xhci-mem.c revision 30f89ca021c3e584b61bc5a14eede89f74b2e826
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) 44326b4810cc995209e31136af4202ed0414814ed5Randy Dunlap return NULL; 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); 50326b4810cc995209e31136af4202ed0414814ed5Randy Dunlap return NULL; 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) { 9228ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans prev->trbs[TRBS_PER_SEGMENT-1].link. 9328ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans segment_ptr = cpu_to_le64(next->dma); 940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the last TRB in the segment to have a TRB type ID of Link TRB */ 9628ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans val = le32_to_cpu(prev->trbs[TRBS_PER_SEGMENT-1].link.control); 970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ~TRB_TYPE_BITMASK; 980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= TRB_TYPE(TRB_LINK); 99b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp /* Always set the chain bit with 0.95 hardware */ 100b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp if (xhci_link_trb_quirk(xhci)) 101b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp val |= TRB_CHAIN; 10228ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans prev->trbs[TRBS_PER_SEGMENT-1].link.control = cpu_to_le32(val); 1030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 104700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n", 105700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)prev->dma, 106700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)next->dma); 1070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1080ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1090ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* XXX: Do we need the hcd structure in all these functions? */ 110f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring) 1110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1120ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 1130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *first_seg; 1140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring || !ring->first_seg) 1160ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 1170ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp first_seg = ring->first_seg; 1180ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = first_seg->next; 119700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Freeing ring at %p\n", ring); 1200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (seg != first_seg) { 1210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next = seg->next; 1220ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, seg); 1230ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = next; 1240ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1250ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, first_seg); 1260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = NULL; 1270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(ring); 1280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 13074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharpstatic void xhci_initialize_ring_info(struct xhci_ring *ring) 13174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp{ 13274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* The ring is empty, so the enqueue pointer == dequeue pointer */ 13374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->enqueue = ring->first_seg->trbs; 13474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->enq_seg = ring->first_seg; 13574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->dequeue = ring->enqueue; 13674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->deq_seg = ring->first_seg; 13774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* The ring is initialized to 0. The producer must write 1 to the cycle 13874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * bit to handover ownership of the TRB, so PCS = 1. The consumer must 13974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * compare CCS to the cycle bit to check ownership, so CCS = 1. 14074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp */ 14174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->cycle_state = 1; 14274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* Not necessary for new rings, but needed for re-initialized rings */ 14374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->enq_updates = 0; 14474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp ring->deq_updates = 0; 14574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp} 14674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 1470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/** 1480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Create a new ring with zero or more segments. 1490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 1500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Link each segment together into a ring. 1510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Set the end flag and the cycle toggle bit on the last segment. 1520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 4.9.1 and figures 15 and 16. 1530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 1540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci, 1550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp unsigned int num_segs, bool link_trbs, gfp_t flags) 1560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_ring *ring; 1580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *prev; 1590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring = kzalloc(sizeof *(ring), flags); 161700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocating ring at %p\n", ring); 1620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring) 163326b4810cc995209e31136af4202ed0414814ed5Randy Dunlap return NULL; 1640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 165d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp INIT_LIST_HEAD(&ring->td_list); 1660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (num_segs == 0) 1670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = xhci_segment_alloc(xhci, flags); 1700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring->first_seg) 1710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = ring->first_seg; 1750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (num_segs > 0) { 1760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next; 1770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp next = xhci_segment_alloc(xhci, flags); 1790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!next) 1800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, next, link_trbs); 1820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = next; 1840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, ring->first_seg, link_trbs); 1870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (link_trbs) { 1890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* See section 4.9.2.1 and 6.4.4.1 */ 19028ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans prev->trbs[TRBS_PER_SEGMENT-1].link. 19128ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans control |= cpu_to_le32(LINK_TOGGLE); 1920ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote link toggle flag to" 193700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman " segment %p (virtual), 0x%llx (DMA)\n", 194700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman prev, (unsigned long long)prev->dma); 1950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 19674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_initialize_ring_info(ring); 1970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1990ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpfail: 2000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, ring); 201326b4810cc995209e31136af4202ed0414814ed5Randy Dunlap return NULL; 2020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 2030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 204412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharpvoid xhci_free_or_cache_endpoint_ring(struct xhci_hcd *xhci, 205412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp struct xhci_virt_device *virt_dev, 206412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp unsigned int ep_index) 207412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp{ 208412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp int rings_cached; 209412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp 210412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp rings_cached = virt_dev->num_rings_cached; 211412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp if (rings_cached < XHCI_MAX_RINGS_CACHED) { 212412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->ring_cache[rings_cached] = 213412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->eps[ep_index].ring; 21430f89ca021c3e584b61bc5a14eede89f74b2e826Sarah Sharp virt_dev->num_rings_cached++; 215412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp xhci_dbg(xhci, "Cached old ring, " 216412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp "%d ring%s cached\n", 21730f89ca021c3e584b61bc5a14eede89f74b2e826Sarah Sharp virt_dev->num_rings_cached, 21830f89ca021c3e584b61bc5a14eede89f74b2e826Sarah Sharp (virt_dev->num_rings_cached > 1) ? "s" : ""); 219412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp } else { 220412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp xhci_ring_free(xhci, virt_dev->eps[ep_index].ring); 221412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp xhci_dbg(xhci, "Ring cache full (%d rings), " 222412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp "freeing ring\n", 223412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->num_rings_cached); 224412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp } 225412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp virt_dev->eps[ep_index].ring = NULL; 226412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp} 227412566bd716397e28e81fc9b20804bc6a6daf14dSarah Sharp 22874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp/* Zero an endpoint ring (except for link TRBs) and move the enqueue and dequeue 22974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * pointers to the beginning of the ring. 23074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp */ 23174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharpstatic void xhci_reinit_cached_ring(struct xhci_hcd *xhci, 23274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp struct xhci_ring *ring) 23374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp{ 23474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp struct xhci_segment *seg = ring->first_seg; 23574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp do { 23674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp memset(seg->trbs, 0, 23774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp sizeof(union xhci_trb)*TRBS_PER_SEGMENT); 23874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* All endpoint rings have link TRBs */ 23974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_link_segments(xhci, seg, seg->next, 1); 24074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp seg = seg->next; 24174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp } while (seg != ring->first_seg); 24274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_initialize_ring_info(ring); 24374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* td list should be empty since all URBs have been cancelled, 24474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp * but just in case... 24574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp */ 24674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp INIT_LIST_HEAD(&ring->td_list); 24774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp} 24874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 249d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn#define CTX_SIZE(_hcc) (HCC_64BYTE_CONTEXT(_hcc) ? 64 : 32) 250d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 251326b4810cc995209e31136af4202ed0414814ed5Randy Dunlapstatic struct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci, 252d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn int type, gfp_t flags) 253d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 254d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx = kzalloc(sizeof(*ctx), flags); 255d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (!ctx) 256d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return NULL; 257d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 258d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn BUG_ON((type != XHCI_CTX_TYPE_DEVICE) && (type != XHCI_CTX_TYPE_INPUT)); 259d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->type = type; 260d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->size = HCC_64BYTE_CONTEXT(xhci->hcc_params) ? 2048 : 1024; 261d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (type == XHCI_CTX_TYPE_INPUT) 262d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->size += CTX_SIZE(xhci->hcc_params); 263d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 264d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->bytes = dma_pool_alloc(xhci->device_pool, flags, &ctx->dma); 265d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn memset(ctx->bytes, 0, ctx->size); 266d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return ctx; 267d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 268d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 269326b4810cc995209e31136af4202ed0414814ed5Randy Dunlapstatic void xhci_free_container_ctx(struct xhci_hcd *xhci, 270d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 271d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 272a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp if (!ctx) 273a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp return; 274d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dma_pool_free(xhci->device_pool, ctx->bytes, ctx->dma); 275d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn kfree(ctx); 276d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 277d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 278d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci, 279d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 280d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 281d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn BUG_ON(ctx->type != XHCI_CTX_TYPE_INPUT); 282d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_input_control_ctx *)ctx->bytes; 283d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 284d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 285d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, 286d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 287d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 288d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (ctx->type == XHCI_CTX_TYPE_DEVICE) 289d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_slot_ctx *)ctx->bytes; 290d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 291d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_slot_ctx *) 292d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (ctx->bytes + CTX_SIZE(xhci->hcc_params)); 293d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 294d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 295d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci, 296d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx, 297d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn unsigned int ep_index) 298d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 299d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn /* increment ep index by offset of start of ep ctx array */ 300d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_index++; 301d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (ctx->type == XHCI_CTX_TYPE_INPUT) 302d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_index++; 303d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 304d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_ep_ctx *) 305d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (ctx->bytes + (ep_index * CTX_SIZE(xhci->hcc_params))); 306d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 307d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 3088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/***************** Streams structures manipulation *************************/ 3108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3118212a49d1c1e53ad2bc3176b983a2483b48fd989Dmitry Torokhovstatic void xhci_free_stream_ctx(struct xhci_hcd *xhci, 3128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_stream_ctxs, 3138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_ctx *stream_ctx, dma_addr_t dma) 3148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 3158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 3168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE) 3188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp pci_free_consistent(pdev, 3198df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_stream_ctx)*num_stream_ctxs, 3208df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_ctx, dma); 3218df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE) 3228df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_free(xhci->small_streams_pool, 3238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_ctx, dma); 3248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else 3258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_free(xhci->medium_streams_pool, 3268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_ctx, dma); 3278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 3288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 3308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The stream context array for each endpoint with bulk streams enabled can 3318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * vary in size, based on: 3328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * - how many streams the endpoint supports, 3338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * - the maximum primary stream array size the host controller supports, 3348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * - and how many streams the device driver asks for. 3358df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 3368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The stream context array must be a power of 2, and can be as small as 3378df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 64 bytes or as large as 1MB. 3388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 3398212a49d1c1e53ad2bc3176b983a2483b48fd989Dmitry Torokhovstatic struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci, 3408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_stream_ctxs, dma_addr_t *dma, 3418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp gfp_t mem_flags) 3428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 3438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 3448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 3458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE) 3468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return pci_alloc_consistent(pdev, 3478df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_stream_ctx)*num_stream_ctxs, 3488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma); 3498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE) 3508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_alloc(xhci->small_streams_pool, 3518df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags, dma); 3528df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp else 3538df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return dma_pool_alloc(xhci->medium_streams_pool, 3548df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags, dma); 3558df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 3568df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 357e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharpstruct xhci_ring *xhci_dma_to_transfer_ring( 358e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp struct xhci_virt_ep *ep, 359e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp u64 address) 360e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp{ 361e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp if (ep->ep_state & EP_HAS_STREAMS) 362e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp return radix_tree_lookup(&ep->stream_info->trb_address_map, 363e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp address >> SEGMENT_SHIFT); 364e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp return ep->ring; 365e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp} 366e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp 367e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp/* Only use this when you know stream_info is valid */ 3688df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING 369e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharpstatic struct xhci_ring *dma_to_stream_ring( 3708df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info, 3718df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u64 address) 3728df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 3738df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return radix_tree_lookup(&stream_info->trb_address_map, 3748df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp address >> SEGMENT_SHIFT); 3758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 3768df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#endif /* CONFIG_USB_XHCI_HCD_DEBUGGING */ 3778df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 378e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharpstruct xhci_ring *xhci_stream_id_to_ring( 379e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp struct xhci_virt_device *dev, 380e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp unsigned int ep_index, 381e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp unsigned int stream_id) 382e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp{ 383e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp struct xhci_virt_ep *ep = &dev->eps[ep_index]; 384e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp 385e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp if (stream_id == 0) 386e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp return ep->ring; 387e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp if (!ep->stream_info) 388e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp return NULL; 389e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp 390e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp if (stream_id > ep->stream_info->num_streams) 391e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp return NULL; 392e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp return ep->stream_info->stream_rings[stream_id]; 393e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp} 394e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp 3958df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#ifdef CONFIG_USB_XHCI_HCD_DEBUGGING 3968df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpstatic int xhci_test_radix_tree(struct xhci_hcd *xhci, 3978df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_streams, 3988df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info) 3998df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 4008df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u32 cur_stream; 4018df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *cur_ring; 4028df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u64 addr; 4038df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4048df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 4058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *mapped_ring; 4068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp int trb_size = sizeof(union xhci_trb); 4078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 4098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (addr = cur_ring->first_seg->dma; 4108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr < cur_ring->first_seg->dma + SEGMENT_SIZE; 4118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr += trb_size) { 4128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring = dma_to_stream_ring(stream_info, addr); 4138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (cur_ring != mapped_ring) { 4148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_warn(xhci, "WARN: DMA address 0x%08llx " 4158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "didn't map to stream ID %u; " 4168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "mapped to ring %p\n", 4178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp (unsigned long long) addr, 4188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream, 4198df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring); 4208df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return -EINVAL; 4218df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4228df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* One TRB after the end of the ring segment shouldn't return a 4248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * pointer to the current ring (although it may be a part of a 4258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * different ring). 4268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 4278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring = dma_to_stream_ring(stream_info, addr); 4288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (mapped_ring != cur_ring) { 4298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* One TRB before should also fail */ 4308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma - trb_size; 4318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring = dma_to_stream_ring(stream_info, addr); 4328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (mapped_ring == cur_ring) { 4348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_warn(xhci, "WARN: Bad DMA address 0x%08llx " 4358df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "mapped to valid stream ID %u; " 4368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "mapped ring = %p\n", 4378df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp (unsigned long long) addr, 4388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream, 4398df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mapped_ring); 4408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return -EINVAL; 4418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 4438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return 0; 4448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 4458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#endif /* CONFIG_USB_XHCI_HCD_DEBUGGING */ 4468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4478df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 4488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Change an endpoint's internal structure so it supports stream IDs. The 4498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * number of requested streams includes stream 0, which cannot be used by device 4508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * drivers. 4518df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4528df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The number of stream contexts in the stream context array may be bigger than 4538df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * the number of streams the driver wants to use. This is because the number of 4548df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * stream context array entries must be a power of two. 4558df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4568df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * We need a radix tree for mapping physical addresses of TRBs to which stream 4578df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * ID they belong to. We need to do this because the host controller won't tell 4588df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * us which stream ring the TRB came from. We could store the stream ID in an 4598df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * event data TRB, but that doesn't help us for the cancellation case, since the 4608df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * endpoint may stop before it reaches that event data TRB. 4618df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4628df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The radix tree maps the upper portion of the TRB DMA address to a ring 4638df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * segment that has the same upper portion of DMA addresses. For example, say I 4648df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * have segments of size 1KB, that are always 64-byte aligned. A segment may 4658df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * start at 0x10c91000 and end at 0x10c913f0. If I use the upper 10 bits, the 4668df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * key to the stream ID is 0x43244. I can use the DMA address of the TRB to 4678df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * pass the radix tree a key to get the right stream ID: 4688df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4698df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 0x10c90fff >> 10 = 0x43243 4708df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 0x10c912c0 >> 10 = 0x43244 4718df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 0x10c91400 >> 10 = 0x43245 4728df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4738df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Obviously, only those TRBs with DMA addresses that are within the segment 4748df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * will make the radix tree return the stream ID for that ring. 4758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4768df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Caveats for the radix tree: 4778df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 4788df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * The radix tree uses an unsigned long as a key pair. On 32-bit systems, an 4798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * unsigned long will be 32-bits; on a 64-bit system an unsigned long will be 4808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 64-bits. Since we only request 32-bit DMA addresses, we can use that as the 4818df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * key on 32-bit or 64-bit systems (it would also be fine if we asked for 64-bit 4828df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * PCI DMA addresses on a 64-bit system). There might be a problem on 32-bit 4838df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * extended systems (where the DMA address can be bigger than 32-bits), 4848df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * if we allow the PCI dma mask to be bigger than 32-bits. So don't do that. 4858df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 4868df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpstruct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci, 4878df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_stream_ctxs, 4888df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned int num_streams, gfp_t mem_flags) 4898df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 4908df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info; 4918df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u32 cur_stream; 4928df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *cur_ring; 4938df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp unsigned long key; 4948df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u64 addr; 4958df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp int ret; 4968df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 4978df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Allocating %u streams and %u " 4988df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp "stream context array entries.\n", 4998df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp num_streams, num_stream_ctxs); 5008df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci->cmd_ring_reserved_trbs == MAX_RSVD_CMD_TRBS) { 5018df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Command ring has no reserved TRBs available\n"); 5028df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return NULL; 5038df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5048df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->cmd_ring_reserved_trbs++; 5058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info = kzalloc(sizeof(struct xhci_stream_info), mem_flags); 5078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info) 5088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_trbs; 5098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->num_streams = num_streams; 5118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->num_stream_ctxs = num_stream_ctxs; 5128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Initialize the array of virtual pointers to stream rings. */ 5148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings = kzalloc( 5158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_ring *)*num_streams, 5168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags); 5178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info->stream_rings) 5188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_info; 5198df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5208df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Initialize the array of DMA addresses for stream rings for the HW. */ 5218df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_ctx_array = xhci_alloc_stream_ctx(xhci, 5228df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp num_stream_ctxs, &stream_info->ctx_array_dma, 5238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp mem_flags); 5248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info->stream_ctx_array) 5258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_ctx; 5268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp memset(stream_info->stream_ctx_array, 0, 5278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp sizeof(struct xhci_stream_ctx)*num_stream_ctxs); 5288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Allocate everything needed to free the stream rings later */ 5308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->free_streams_command = 5318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_alloc_command(xhci, true, true, mem_flags); 5328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info->free_streams_command) 5338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_ctx; 5348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5358df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp INIT_RADIX_TREE(&stream_info->trb_address_map, GFP_ATOMIC); 5368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5378df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Allocate rings for all the streams that the driver will use, 5388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * and add their segment DMA addresses to the radix tree. 5398df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Stream 0 is reserved. 5408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 5428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = 5438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_alloc(xhci, 1, true, mem_flags); 5448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 5458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!cur_ring) 5468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_rings; 547e9df17eb1408cfafa3d1844bfc7f22c7237b31b8Sarah Sharp cur_ring->stream_id = cur_stream; 5488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Set deq ptr, cycle bit, and stream context type */ 5498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma | 5508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp SCT_FOR_CTX(SCT_PRI_TR) | 5518df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring->cycle_state; 55228ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans stream_info->stream_ctx_array[cur_stream]. 55328ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans stream_ring = cpu_to_le64(addr); 5548df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n", 5558df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream, (unsigned long long) addr); 5568df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5578df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp key = (unsigned long) 5588df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp (cur_ring->first_seg->dma >> SEGMENT_SHIFT); 5598df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp ret = radix_tree_insert(&stream_info->trb_address_map, 5608df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp key, cur_ring); 5618df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (ret) { 5628df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_free(xhci, cur_ring); 5638df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = NULL; 5648df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_rings; 5658df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5668df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5678df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Leave the other unused stream ring pointers in the stream context 5688df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * array initialized to zero. This will cause the xHC to give us an 5698df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * error if the device asks for a stream ID we don't have setup (if it 5708df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * was any other way, the host controller would assume the ring is 5718df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * "empty" and wait forever for data to be queued to that stream ID). 5728df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5738df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#if XHCI_DEBUG 5748df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Do a little test on the radix tree to make sure it returns the 5758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * correct values. 5768df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 5778df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci_test_radix_tree(xhci, num_streams, stream_info)) 5788df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto cleanup_rings; 5798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp#endif 5808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5818df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return stream_info; 5828df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 5838df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_rings: 5848df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 5858df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 5868df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (cur_ring) { 5878df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma; 5888df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp radix_tree_delete(&stream_info->trb_address_map, 5898df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr >> SEGMENT_SHIFT); 5908df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_free(xhci, cur_ring); 5918df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = NULL; 5928df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5938df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 5948df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_command(xhci, stream_info->free_streams_command); 5958df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_ctx: 5968df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info->stream_rings); 5978df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_info: 5988df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info); 5998df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpcleanup_trbs: 6008df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->cmd_ring_reserved_trbs--; 6018df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return NULL; 6028df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 6038df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 6048df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Sets the MaxPStreams field and the Linear Stream Array field. 6058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Sets the dequeue pointer to the stream context array. 6068df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 6078df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpvoid xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci, 6088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ep_ctx *ep_ctx, 6098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info) 6108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 6118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp u32 max_primary_streams; 6128df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* MaxPStreams is the number of stream context array entries, not the 6138df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * number we're actually using. Must be in 2^(MaxPstreams + 1) format. 6148df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * fls(0) = 0, fls(0x1) = 1, fls(0x10) = 2, fls(0x100) = 3, etc. 6158df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 6168df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp max_primary_streams = fls(stream_info->num_stream_ctxs) - 2; 6178df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Setting number of stream ctx array entries to %u\n", 6188df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 1 << (max_primary_streams + 1)); 61928ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info &= cpu_to_le32(~EP_MAXPSTREAMS_MASK); 62028ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info |= cpu_to_le32(EP_MAXPSTREAMS(max_primary_streams) 62128ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans | EP_HAS_LSA); 62228ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->deq = cpu_to_le64(stream_info->ctx_array_dma); 6238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 6248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* 6268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Sets the MaxPStreams field and the Linear Stream Array field to 0. 6278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Reinstalls the "normal" endpoint ring (at its previous dequeue mark, 6288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * not at the beginning of the ring). 6298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 6308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpvoid xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci, 6318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ep_ctx *ep_ctx, 6328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_virt_ep *ep) 6338df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 6348df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_addr_t addr; 63528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info &= cpu_to_le32(~(EP_MAXPSTREAMS_MASK | EP_HAS_LSA)); 6368df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = xhci_trb_virt_to_dma(ep->ring->deq_seg, ep->ring->dequeue); 63728ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->deq = cpu_to_le64(addr | ep->ring->cycle_state); 6388df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 6398df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* Frees all stream contexts associated with the endpoint, 6418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * 6428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Caller should fix the endpoint context streams fields. 6438df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 6448df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharpvoid xhci_free_stream_info(struct xhci_hcd *xhci, 6458df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_stream_info *stream_info) 6468df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp{ 6478df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp int cur_stream; 6488df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp struct xhci_ring *cur_ring; 6498df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_addr_t addr; 6508df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6518df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!stream_info) 6528df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp return; 6538df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6548df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (cur_stream = 1; cur_stream < stream_info->num_streams; 6558df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_stream++) { 6568df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp cur_ring = stream_info->stream_rings[cur_stream]; 6578df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (cur_ring) { 6588df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr = cur_ring->first_seg->dma; 6598df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp radix_tree_delete(&stream_info->trb_address_map, 6608df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp addr >> SEGMENT_SHIFT); 6618df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_ring_free(xhci, cur_ring); 6628df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_rings[cur_stream] = NULL; 6638df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 6648df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 6658df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_command(xhci, stream_info->free_streams_command); 6668df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->cmd_ring_reserved_trbs--; 6678df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (stream_info->stream_ctx_array) 6688df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_stream_ctx(xhci, 6698df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->num_stream_ctxs, 6708df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->stream_ctx_array, 6718df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp stream_info->ctx_array_dma); 6728df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6738df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (stream_info) 6748df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info->stream_rings); 6758df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp kfree(stream_info); 6768df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp} 6778df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6788df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/***************** Device context manipulation *************************/ 6808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 6816f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharpstatic void xhci_init_endpoint_timer(struct xhci_hcd *xhci, 6826f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp struct xhci_virt_ep *ep) 6836f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp{ 6846f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp init_timer(&ep->stop_cmd_timer); 6856f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp ep->stop_cmd_timer.data = (unsigned long) ep; 6866f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp ep->stop_cmd_timer.function = xhci_stop_endpoint_command_watchdog; 6876f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp ep->xhci = xhci; 6886f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp} 6896f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp 690d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp/* All the xhci_tds in the ring's TD list should be freed at this point */ 6913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpvoid xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id) 6923ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 6933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 6943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 6953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 6963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 6973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || !xhci->devs[slot_id]) 6983ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 6993ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 7018e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci->dcbaa->dev_context_ptrs[slot_id] = 0; 7023ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev) 7033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 7043ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7058df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp for (i = 0; i < 31; ++i) { 70663a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp if (dev->eps[i].ring) 70763a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp xhci_ring_free(xhci, dev->eps[i].ring); 7088df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (dev->eps[i].stream_info) 7098df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_free_stream_info(xhci, 7108df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dev->eps[i].stream_info); 7118df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp } 7123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 71374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (dev->ring_cache) { 71474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp for (i = 0; i < dev->num_rings_cached; i++) 71574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_ring_free(xhci, dev->ring_cache[i]); 71674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp kfree(dev->ring_cache); 71774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp } 71874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 7193ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->in_ctx) 720d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci_free_container_ctx(xhci, dev->in_ctx); 7213ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->out_ctx) 722d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci_free_container_ctx(xhci, dev->out_ctx); 723d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 7243ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp kfree(xhci->devs[slot_id]); 725326b4810cc995209e31136af4202ed0414814ed5Randy Dunlap xhci->devs[slot_id] = NULL; 7263ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 7273ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7283ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, 7293ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct usb_device *udev, gfp_t flags) 7303ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 7313ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 73263a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp int i; 7333ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7343ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 7353ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || xhci->devs[slot_id]) { 7363ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Bad Slot ID %d\n", slot_id); 7373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 7383ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 7393ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7403ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[slot_id] = kzalloc(sizeof(*xhci->devs[slot_id]), flags); 7413ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->devs[slot_id]) 7423ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 7433ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 7443ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 745d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn /* Allocate the (output) device context that will be used in the HC. */ 746d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dev->out_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_DEVICE, flags); 7473ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->out_ctx) 7483ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 749d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 750700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Slot %d output ctx = 0x%llx (dma)\n", slot_id, 751d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (unsigned long long)dev->out_ctx->dma); 7523ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7533ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate the (input) device context for address device command */ 754d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dev->in_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, flags); 7553ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->in_ctx) 7563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 757d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 758700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id, 759d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (unsigned long long)dev->in_ctx->dma); 7603ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7616f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp /* Initialize the cancellation list and watchdog timers for each ep */ 7626f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp for (i = 0; i < 31; i++) { 7636f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp xhci_init_endpoint_timer(xhci, &dev->eps[i]); 76463a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list); 7656f5165cf989387e84ef23122330b27cca1cbe831Sarah Sharp } 76663a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp 7673ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate endpoint 0 ring */ 76863a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags); 76963a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp if (!dev->eps[0].ring) 7703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 7713ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 77274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* Allocate pointers to the ring cache */ 77374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp dev->ring_cache = kzalloc( 77474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp sizeof(struct xhci_ring *)*XHCI_MAX_RINGS_CACHED, 77574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp flags); 77674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (!dev->ring_cache) 77774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp goto fail; 77874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp dev->num_rings_cached = 0; 77974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp 780f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp init_completion(&dev->cmd_completion); 781913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp INIT_LIST_HEAD(&dev->cmd_list); 78264927730c66333c9d5987aa72a0e6d44ed91cec7Andiry Xu dev->udev = udev; 783f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 78428c2d2efb48dec2f0b050affae6d5787d6449e47Sarah Sharp /* Point to output device context in dcbaa. */ 78528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans xhci->dcbaa->dev_context_ptrs[slot_id] = cpu_to_le64(dev->out_ctx->dma); 786700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n", 78728ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_id, 78828ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans &xhci->dcbaa->dev_context_ptrs[slot_id], 78928ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans (unsigned long long) le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id])); 7903ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 1; 7923ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpfail: 7933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, slot_id); 7943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 7953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 7963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7972d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharpvoid xhci_copy_ep0_dequeue_into_input_ctx(struct xhci_hcd *xhci, 7982d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp struct usb_device *udev) 7992d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp{ 8002d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp struct xhci_virt_device *virt_dev; 8012d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp struct xhci_ep_ctx *ep0_ctx; 8022d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp struct xhci_ring *ep_ring; 8032d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp 8042d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp virt_dev = xhci->devs[udev->slot_id]; 8052d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp ep0_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, 0); 8062d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp ep_ring = virt_dev->eps[0].ring; 8072d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp /* 8082d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp * FIXME we don't keep track of the dequeue pointer very well after a 8092d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp * Set TR dequeue pointer, so we're setting the dequeue pointer of the 8102d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp * host to our enqueue pointer. This should only be called after a 8112d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp * configured device has reset, so all control transfers should have 8122d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp * been completed or cancelled before the reset. 8132d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp */ 81428ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep0_ctx->deq = cpu_to_le64(xhci_trb_virt_to_dma(ep_ring->enq_seg, 81528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ring->enqueue) 81628ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans | ep_ring->cycle_state); 8172d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp} 8182d1ee5904bb51ea33c6a6f4bec6b6a243e2432a8Sarah Sharp 819f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp/* 820f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * The xHCI roothub may have ports of differing speeds in any order in the port 821f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * status registers. xhci->port_array provides an array of the port speed for 822f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * each offset into the port status registers. 823f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * 824f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * The xHCI hardware wants to know the roothub port number that the USB device 825f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * is attached to (or the roothub port its ancestor hub is attached to). All we 826f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * know is the index of that port under either the USB 2.0 or the USB 3.0 827f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * roothub, but that doesn't give us the real index into the HW port status 828f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * registers. Scan through the xHCI roothub port array, looking for the Nth 829f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * entry of the correct port speed. Return the port number of that entry. 830f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp */ 831f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharpstatic u32 xhci_find_real_port_number(struct xhci_hcd *xhci, 832f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp struct usb_device *udev) 833f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp{ 834f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp struct usb_device *top_dev; 835f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp unsigned int num_similar_speed_ports; 836f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp unsigned int faked_port_num; 837f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp int i; 838f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp 839f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp for (top_dev = udev; top_dev->parent && top_dev->parent->parent; 840f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp top_dev = top_dev->parent) 841f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp /* Found device below root hub */; 842f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp faked_port_num = top_dev->portnum; 843f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp for (i = 0, num_similar_speed_ports = 0; 844f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp i < HCS_MAX_PORTS(xhci->hcs_params1); i++) { 845f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp u8 port_speed = xhci->port_array[i]; 846f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp 847f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp /* 848f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * Skip ports that don't have known speeds, or have duplicate 849f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * Extended Capabilities port speed entries. 850f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp */ 85122e0487047567252d5677ff35766cd884375efc2Dan Carpenter if (port_speed == 0 || port_speed == DUPLICATE_ENTRY) 852f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp continue; 853f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp 854f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp /* 855f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * USB 3.0 ports are always under a USB 3.0 hub. USB 2.0 and 856f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * 1.1 ports are under the USB 2.0 hub. If the port speed 857f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp * matches the device speed, it's a similar speed port. 858f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp */ 859f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp if ((port_speed == 0x03) == (udev->speed == USB_SPEED_SUPER)) 860f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp num_similar_speed_ports++; 861f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp if (num_similar_speed_ports == faked_port_num) 862f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp /* Roothub ports are numbered from 1 to N */ 863f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp return i+1; 864f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp } 865f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp return 0; 866f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp} 867f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp 8683ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp/* Setup an xHCI virtual device for a Set Address command */ 8693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev) 8703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 8713ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 8723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_ep_ctx *ep0_ctx; 873d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_slot_ctx *slot_ctx; 874d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_input_control_ctx *ctrl_ctx; 875f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp u32 port_num; 876f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp struct usb_device *top_dev; 8773ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8783ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[udev->slot_id]; 8793ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 8803ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (udev->slot_id == 0 || !dev) { 8813ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Slot ID %d is not assigned to this device\n", 8823ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp udev->slot_id); 8833ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 8843ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 885d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep0_ctx = xhci_get_ep_ctx(xhci, dev->in_ctx, 0); 886d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctrl_ctx = xhci_get_input_control_ctx(xhci, dev->in_ctx); 887d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx); 8883ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8893ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 2) New slot context and endpoint 0 context are valid*/ 89028ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG); 8913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 8923ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 3) Only the control endpoint is valid - one endpoint context */ 89328ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | (u32) udev->route); 8943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp switch (udev->speed) { 8953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_SUPER: 89628ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_SS); 8973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 8983ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_HIGH: 89928ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_HS); 9003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 9013ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_FULL: 90228ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_FS); 9033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 9043ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_LOW: 90528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_LS); 9063ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 907551cdbbeb118bd5ed301f8749aef69219284399bGreg Kroah-Hartman case USB_SPEED_WIRELESS: 9083ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); 9093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 9103ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 9113ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp default: 9123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Speed was set earlier, this shouldn't happen. */ 9133ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp BUG(); 9143ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 9153ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Find the root hub port this device is under */ 916f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp port_num = xhci_find_real_port_number(xhci, udev); 917f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp if (!port_num) 918f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp return -EINVAL; 91928ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->dev_info2 |= cpu_to_le32((u32) ROOT_HUB_PORT(port_num)); 920f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp /* Set the port number in the virtual_device to the faked port number */ 9213ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (top_dev = udev; top_dev->parent && top_dev->parent->parent; 9223ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp top_dev = top_dev->parent) 9233ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Found device below root hub */; 924be88fe4f4dda93e3264a887745123b1e6c4a6845Andiry Xu dev->port = top_dev->portnum; 925f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp xhci_dbg(xhci, "Set root hub portnum to %d\n", port_num); 926f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp xhci_dbg(xhci, "Set fake root hub portnum to %d\n", dev->port); 9273ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 928aa1b13efb7cfa9f7bf4942c1e858463e335c9500Sarah Sharp /* Is this a LS/FS device under an external HS hub? */ 929aa1b13efb7cfa9f7bf4942c1e858463e335c9500Sarah Sharp if (udev->tt && udev->tt->hub->parent) { 93028ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->tt_info = cpu_to_le32(udev->tt->hub->slot_id | 93128ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans (udev->ttport << 8)); 93207b6de102843b717ecd962cf35ec4ad9b1fbed9dSarah Sharp if (udev->tt->multi) 93328ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans slot_ctx->dev_info |= cpu_to_le32(DEV_MTT); 9343ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 935700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "udev->tt = %p\n", udev->tt); 9363ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport); 9373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 9383ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 4 - ring already allocated */ 9393ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 5 */ 94028ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep0_ctx->ep_info2 = cpu_to_le32(EP_TYPE(CTRL_EP)); 9413ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 9423ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * XXX: Not sure about wireless USB devices. 9433ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp */ 94447aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp switch (udev->speed) { 94547aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_SUPER: 94628ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(512)); 94747aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 94847aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_HIGH: 94947aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp /* USB core guesses at a 64-byte max packet first for FS devices */ 95047aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_FULL: 95128ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(64)); 95247aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 95347aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_LOW: 95428ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep0_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(8)); 95547aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 956551cdbbeb118bd5ed301f8749aef69219284399bGreg Kroah-Hartman case USB_SPEED_WIRELESS: 95747aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); 95847aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp return -EINVAL; 95947aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 96047aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp default: 96147aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp /* New speed? */ 96247aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp BUG(); 96347aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp } 9643ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */ 96528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep0_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(0) | ERROR_COUNT(3)); 9663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 96728ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep0_ctx->deq = cpu_to_le64(dev->eps[0].ring->first_seg->dma | 96828ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans dev->eps[0].ring->cycle_state); 9693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 9703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Steps 7 and 8 were done in xhci_alloc_virt_device() */ 9713ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 9723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 9733ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 9743ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 975dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov/* 976dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov * Convert interval expressed as 2^(bInterval - 1) == interval into 977dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov * straight exponent value 2^n == interval. 978dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov * 979dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov */ 980dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhovstatic unsigned int xhci_parse_exponent_interval(struct usb_device *udev, 981dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov struct usb_host_endpoint *ep) 982dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov{ 983dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov unsigned int interval; 984dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 985dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov interval = clamp_val(ep->desc.bInterval, 1, 16) - 1; 986dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov if (interval != ep->desc.bInterval - 1) 987dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov dev_warn(&udev->dev, 988dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov "ep %#x - rounding interval to %d microframes\n", 989dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov ep->desc.bEndpointAddress, 990dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1 << interval); 991dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 992dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov return interval; 993dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov} 994dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 995dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov/* 996dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov * Convert bInterval expressed in frames (in 1-255 range) to exponent of 997dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov * microframes, rounded down to nearest power of 2. 998dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov */ 999dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhovstatic unsigned int xhci_parse_frame_interval(struct usb_device *udev, 1000dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov struct usb_host_endpoint *ep) 1001dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov{ 1002dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov unsigned int interval; 1003dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1004dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov interval = fls(8 * ep->desc.bInterval) - 1; 1005dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov interval = clamp_val(interval, 3, 10); 1006dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov if ((1 << interval) != 8 * ep->desc.bInterval) 1007dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov dev_warn(&udev->dev, 1008dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov "ep %#x - rounding interval to %d microframes, ep desc says %d microframes\n", 1009dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov ep->desc.bEndpointAddress, 1010dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1 << interval, 1011dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 8 * ep->desc.bInterval); 1012dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1013dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov return interval; 1014dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov} 1015dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1016f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp/* Return the polling or NAK interval. 1017f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 1018f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The polling interval is expressed in "microframes". If xHCI's Interval field 1019f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to N, it will service the endpoint every 2^(Interval)*125us. 1020f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 1021f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The NAK interval is one NAK per 1 to 255 microframes, or no NAKs if interval 1022f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to 0. 1023f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 1024575688e1e5f462c44ddd608ce3ec9f38b64c3c0dDmitry Torokhovstatic unsigned int xhci_get_endpoint_interval(struct usb_device *udev, 1025f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 1026f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 1027f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int interval = 0; 1028f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1029f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 1030f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 1031f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Max NAK rate */ 1032f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc) || 1033dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov usb_endpoint_xfer_bulk(&ep->desc)) { 1034f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = ep->desc.bInterval; 1035dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov break; 1036dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov } 1037f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through - SS and HS isoc/int have same decoding */ 1038dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1039f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 1040f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 1041dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov usb_endpoint_xfer_isoc(&ep->desc)) { 1042dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov interval = xhci_parse_exponent_interval(udev, ep); 1043f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 1044f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 1045dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1046f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 1047b513d44751bfb609a3c20463f764c8ce822d63e9Sarah Sharp if (usb_endpoint_xfer_isoc(&ep->desc)) { 1048dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov interval = xhci_parse_exponent_interval(udev, ep); 1049dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov break; 1050dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov } 1051dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov /* 1052b513d44751bfb609a3c20463f764c8ce822d63e9Sarah Sharp * Fall through for interrupt endpoint interval decoding 1053dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov * since it uses the same rules as low speed interrupt 1054dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov * endpoints. 1055dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov */ 1056dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1057f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 1058f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 1059dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov usb_endpoint_xfer_isoc(&ep->desc)) { 1060dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1061dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov interval = xhci_parse_frame_interval(udev, ep); 1062f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 1063f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 1064dfa49c4ad120a784ef1ff0717168aa79f55a483aDmitry Torokhov 1065f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 1066f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 1067f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 1068f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return EP_INTERVAL(interval); 1069f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 1070f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1071c30c791c946a14a03e87819eced562ed28711961Sarah Sharp/* The "Mult" field in the endpoint context is only set for SuperSpeed isoc eps. 10721cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp * High speed endpoint descriptors can define "the number of additional 10731cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp * transaction opportunities per microframe", but that goes in the Max Burst 10741cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp * endpoint context field. 10751cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp */ 1076575688e1e5f462c44ddd608ce3ec9f38b64c3c0dDmitry Torokhovstatic u32 xhci_get_endpoint_mult(struct usb_device *udev, 10771cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp struct usb_host_endpoint *ep) 10781cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp{ 1079c30c791c946a14a03e87819eced562ed28711961Sarah Sharp if (udev->speed != USB_SPEED_SUPER || 1080c30c791c946a14a03e87819eced562ed28711961Sarah Sharp !usb_endpoint_xfer_isoc(&ep->desc)) 10811cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp return 0; 1082842f16905dfc6743c1dd80c3d29b49ba3ab7f7c8Alan Stern return ep->ss_ep_comp.bmAttributes; 10831cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp} 10841cf62246c0e394021e494e0a8f1013e80db1a1a9Sarah Sharp 1085575688e1e5f462c44ddd608ce3ec9f38b64c3c0dDmitry Torokhovstatic u32 xhci_get_endpoint_type(struct usb_device *udev, 1086f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 1087f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 1088f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp int in; 1089f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp u32 type; 1090f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1091f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp in = usb_endpoint_dir_in(&ep->desc); 1092f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc)) { 1093f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(CTRL_EP); 1094f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_bulk(&ep->desc)) { 1095f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 1096f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_IN_EP); 1097f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 1098f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_OUT_EP); 1099f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_isoc(&ep->desc)) { 1100f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 1101f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_IN_EP); 1102f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 1103f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_OUT_EP); 1104f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_int(&ep->desc)) { 1105f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 1106f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_IN_EP); 1107f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 1108f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_OUT_EP); 1109f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else { 1110f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 1111f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 1112f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return type; 1113f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 1114f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 11159238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp/* Return the maximum endpoint service interval time (ESIT) payload. 11169238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * Basically, this is the maxpacket size, multiplied by the burst size 11179238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * and mult size. 11189238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp */ 1119575688e1e5f462c44ddd608ce3ec9f38b64c3c0dDmitry Torokhovstatic u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci, 11209238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp struct usb_device *udev, 11219238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp struct usb_host_endpoint *ep) 11229238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp{ 11239238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp int max_burst; 11249238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp int max_packet; 11259238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 11269238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp /* Only applies for interrupt or isochronous endpoints */ 11279238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc) || 11289238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp usb_endpoint_xfer_bulk(&ep->desc)) 11299238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp return 0; 11309238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 1131842f16905dfc6743c1dd80c3d29b49ba3ab7f7c8Alan Stern if (udev->speed == USB_SPEED_SUPER) 113264b3c304bed25388fed48dbdc098dfcad7063d9cSebastian Andrzej Siewior return le16_to_cpu(ep->ss_ep_comp.wBytesPerInterval); 11339238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 113428ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize)); 113528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize) & 0x1800) >> 11; 11369238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp /* A 0 in max burst means 1 transfer per ESIT */ 11379238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp return max_packet * (max_burst + 1); 11389238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp} 11399238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 11408df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp/* Set up an endpoint with one ring segment. Do not allocate stream rings. 11418df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * Drivers will have to call usb_alloc_streams() to do that. 11428df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 1143f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpint xhci_endpoint_init(struct xhci_hcd *xhci, 1144f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 1145f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_device *udev, 1146f88ba78d9ac0e1f583da4cada80b8816ca761a3fSarah Sharp struct usb_host_endpoint *ep, 1147f88ba78d9ac0e1f583da4cada80b8816ca761a3fSarah Sharp gfp_t mem_flags) 1148f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 1149f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 1150f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 1151f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ring *ep_ring; 1152f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_packet; 1153f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_burst; 11549238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp u32 max_esit_payload; 1155f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1156f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 1157d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); 1158f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1159f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set up the endpoint ring */ 1160a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu /* 1161a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu * Isochronous endpoint ring needs bigger size because one isoc URB 1162a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu * carries multiple packets and it will insert multiple tds to the 1163a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu * ring. 1164a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu * This should be replaced with dynamic ring resizing in the future. 1165a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu */ 1166a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu if (usb_endpoint_xfer_isoc(&ep->desc)) 1167a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu virt_dev->eps[ep_index].new_ring = 1168a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu xhci_ring_alloc(xhci, 8, true, mem_flags); 1169a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu else 1170a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu virt_dev->eps[ep_index].new_ring = 1171a061a5a0b816de3b4711a2e96764bb3cd8df861eAndiry Xu xhci_ring_alloc(xhci, 1, true, mem_flags); 117274f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (!virt_dev->eps[ep_index].new_ring) { 117374f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp /* Attempt to use the ring cache */ 117474f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp if (virt_dev->num_rings_cached == 0) 117574f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp return -ENOMEM; 117674f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->eps[ep_index].new_ring = 117774f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->ring_cache[virt_dev->num_rings_cached]; 117874f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->ring_cache[virt_dev->num_rings_cached] = NULL; 117974f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp virt_dev->num_rings_cached--; 118074f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp xhci_reinit_cached_ring(xhci, virt_dev->eps[ep_index].new_ring); 118174f9fe21e0440066eb337b9f644238cb3050b91cSarah Sharp } 1182d18240db797ed749b511b8dc910c5dcf08be46d6Andiry Xu virt_dev->eps[ep_index].skip = false; 118363a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp ep_ring = virt_dev->eps[ep_index].new_ring; 118428ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->deq = cpu_to_le64(ep_ring->first_seg->dma | ep_ring->cycle_state); 1185f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 118628ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info = cpu_to_le32(xhci_get_endpoint_interval(udev, ep) 118728ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans | EP_MULT(xhci_get_endpoint_mult(udev, ep))); 1188f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1189f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME dig Mult and streams info out of ep companion desc */ 1190f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 119147692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp /* Allow 3 retries for everything but isoc; 11927b1fc2ea8a5fbf9487d83865456cff77d0249ea9Andiry Xu * CErr shall be set to 0 for Isoch endpoints. 119347692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp */ 1194f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (!usb_endpoint_xfer_isoc(&ep->desc)) 119528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info2 = cpu_to_le32(ERROR_COUNT(3)); 1196f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 11977b1fc2ea8a5fbf9487d83865456cff77d0249ea9Andiry Xu ep_ctx->ep_info2 = cpu_to_le32(ERROR_COUNT(0)); 1198f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 119928ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info2 |= cpu_to_le32(xhci_get_endpoint_type(udev, ep)); 1200f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1201f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set the max packet size and max burst */ 1202f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 1203f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 120428ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans max_packet = le16_to_cpu(ep->desc.wMaxPacketSize); 120528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet)); 1206b10de142119a676552df3f0d2e3a9d647036c26aSarah Sharp /* dig out max burst from ep companion desc */ 1207842f16905dfc6743c1dd80c3d29b49ba3ab7f7c8Alan Stern max_packet = ep->ss_ep_comp.bMaxBurst; 1208842f16905dfc6743c1dd80c3d29b49ba3ab7f7c8Alan Stern if (!max_packet) 1209842f16905dfc6743c1dd80c3d29b49ba3ab7f7c8Alan Stern xhci_warn(xhci, "WARN no SS endpoint bMaxBurst\n"); 121028ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(max_packet)); 1211f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 1212f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 1213f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* bits 11:12 specify the number of additional transaction 1214f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * opportunities per microframe (USB 2.0, section 9.6.6) 1215f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 1216f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_isoc(&ep->desc) || 1217f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_int(&ep->desc)) { 121828ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans max_burst = (le16_to_cpu(ep->desc.wMaxPacketSize) 121928ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans & 0x1800) >> 11; 122028ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(max_burst)); 1221f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 1222f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through */ 1223f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 1224f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 122528ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans max_packet = GET_MAX_PACKET(le16_to_cpu(ep->desc.wMaxPacketSize)); 122628ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet)); 1227f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 1228f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 1229f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 1230f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 12319238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep); 123228ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans ep_ctx->tx_info = cpu_to_le32(MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload)); 12339238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 12349238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp /* 12359238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * XXX no idea how to calculate the average TRB buffer length for bulk 12369238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * endpoints, as the driver gives us no clue how big each scatter gather 12379238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * list entry (or buffer) is going to be. 12389238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * 12399238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * For isochronous and interrupt endpoints, we set it to the max 12409238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * available, until we have new API in the USB core to allow drivers to 12419238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * declare how much bandwidth they actually need. 12429238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * 12439238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * Normally, it would be calculated by taking the total of the buffer 12449238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * lengths in the TD and then dividing by the number of TRBs in a TD, 12459238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * including link TRBs, No-op TRBs, and Event data TRBs. Since we don't 12469238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * use Event Data TRBs, and we don't chain in a link TRB on short 12479238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp * transfers, we're basically dividing by 1. 124851eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu * 124951eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu * xHCI 1.0 specification indicates that the Average TRB Length should 125051eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu * be set to 8 for control endpoints. 12519238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp */ 125251eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu if (usb_endpoint_xfer_control(&ep->desc) && xhci->hci_version == 0x100) 125351eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu ep_ctx->tx_info |= cpu_to_le32(AVG_TRB_LENGTH_FOR_EP(8)); 125451eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu else 125551eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu ep_ctx->tx_info |= 125651eb01a746089f2c3d9b87f870353772d2fb4c37Andiry Xu cpu_to_le32(AVG_TRB_LENGTH_FOR_EP(max_esit_payload)); 12579238f25d5d32a435277eb234ec82bacdd5daed41Sarah Sharp 1258f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME Debug endpoint context */ 1259f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return 0; 1260f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 1261f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1262f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_endpoint_zero(struct xhci_hcd *xhci, 1263f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 1264f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 1265f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 1266f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 1267f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 1268f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1269f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 1270d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); 1271f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1272f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info = 0; 1273f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = 0; 12748e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp ep_ctx->deq = 0; 1275f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->tx_info = 0; 1276f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Don't free the endpoint ring until the set interface or configuration 1277f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * request succeeds. 1278f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 1279f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 1280f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 1281f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp/* Copy output xhci_ep_ctx to the input xhci_ep_ctx copy. 1282f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * Useful when you want to change one particular aspect of the endpoint and then 1283f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * issue a configure endpoint command. 1284f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp */ 1285f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharpvoid xhci_endpoint_copy(struct xhci_hcd *xhci, 1286913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *in_ctx, 1287913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *out_ctx, 1288913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp unsigned int ep_index) 1289f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp{ 1290f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_ep_ctx *out_ep_ctx; 1291f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_ep_ctx *in_ep_ctx; 1292f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1293913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp out_ep_ctx = xhci_get_ep_ctx(xhci, out_ctx, ep_index); 1294913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp in_ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index); 1295f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1296f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->ep_info = out_ep_ctx->ep_info; 1297f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->ep_info2 = out_ep_ctx->ep_info2; 1298f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->deq = out_ep_ctx->deq; 1299f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->tx_info = out_ep_ctx->tx_info; 1300f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp} 1301f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1302f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp/* Copy output xhci_slot_ctx to the input xhci_slot_ctx. 1303f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * Useful when you want to change one particular aspect of the endpoint and then 1304f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * issue a configure endpoint command. Only the context entries field matters, 1305f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * but we'll copy the whole thing anyway. 1306f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp */ 1307913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharpvoid xhci_slot_copy(struct xhci_hcd *xhci, 1308913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *in_ctx, 1309913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_container_ctx *out_ctx) 1310f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp{ 1311f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_slot_ctx *in_slot_ctx; 1312f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_slot_ctx *out_slot_ctx; 1313f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1314913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp in_slot_ctx = xhci_get_slot_ctx(xhci, in_ctx); 1315913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp out_slot_ctx = xhci_get_slot_ctx(xhci, out_ctx); 1316f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1317f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_info = out_slot_ctx->dev_info; 1318f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_info2 = out_slot_ctx->dev_info2; 1319f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->tt_info = out_slot_ctx->tt_info; 1320f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_state = out_slot_ctx->dev_state; 1321f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp} 1322f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 1323254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn/* Set up the scratchpad buffer array and scratchpad buffers, if needed. */ 1324254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Younstatic int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags) 1325254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn{ 1326254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int i; 1327254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn struct device *dev = xhci_to_hcd(xhci)->self.controller; 1328254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2); 1329254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1330254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci_dbg(xhci, "Allocating %d scratchpad buffers\n", num_sp); 1331254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1332254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!num_sp) 1333254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return 0; 1334254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1335254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = kzalloc(sizeof(*xhci->scratchpad), flags); 1336254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad) 1337254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp; 1338254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1339254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array = 1340254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_alloc_consistent(to_pci_dev(dev), 1341254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn num_sp * sizeof(u64), 1342254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn &xhci->scratchpad->sp_dma); 1343254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_array) 1344254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp2; 1345254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1346254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers = kzalloc(sizeof(void *) * num_sp, flags); 1347254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_buffers) 1348254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp3; 1349254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1350254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers = 1351254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kzalloc(sizeof(dma_addr_t) * num_sp, flags); 1352254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1353254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_dma_buffers) 1354254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp4; 1355254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 135628ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans xhci->dcbaa->dev_context_ptrs[0] = cpu_to_le64(xhci->scratchpad->sp_dma); 1357254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = 0; i < num_sp; i++) { 1358254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn dma_addr_t dma; 1359254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn void *buf = pci_alloc_consistent(to_pci_dev(dev), 1360254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->page_size, &dma); 1361254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!buf) 1362254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp5; 1363254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1364254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array[i] = dma; 1365254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i] = buf; 1366254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i] = dma; 1367254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 1368254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1369254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return 0; 1370254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1371254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp5: 1372254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = i - 1; i >= 0; i--) { 1373254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(to_pci_dev(dev), xhci->page_size, 1374254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i], 1375254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i]); 1376254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 1377254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_dma_buffers); 1378254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1379254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp4: 1380254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_buffers); 1381254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1382254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp3: 1383254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(to_pci_dev(dev), num_sp * sizeof(u64), 1384254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array, 1385254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma); 1386254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1387254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp2: 1388254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad); 1389254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = NULL; 1390254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1391254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp: 1392254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return -ENOMEM; 1393254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn} 1394254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1395254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Younstatic void scratchpad_free(struct xhci_hcd *xhci) 1396254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn{ 1397254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int num_sp; 1398254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int i; 1399254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 1400254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1401254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad) 1402254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return; 1403254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1404254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2); 1405254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1406254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = 0; i < num_sp; i++) { 1407254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(pdev, xhci->page_size, 1408254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i], 1409254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i]); 1410254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 1411254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_dma_buffers); 1412254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_buffers); 1413254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(pdev, num_sp * sizeof(u64), 1414254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array, 1415254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma); 1416254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad); 1417254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = NULL; 1418254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn} 1419254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 1420913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharpstruct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci, 1421a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp bool allocate_in_ctx, bool allocate_completion, 1422a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp gfp_t mem_flags) 1423913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp{ 1424913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_command *command; 1425913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1426913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command = kzalloc(sizeof(*command), mem_flags); 1427913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp if (!command) 1428913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp return NULL; 1429913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1430a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp if (allocate_in_ctx) { 1431a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp command->in_ctx = 1432a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, 1433a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp mem_flags); 1434a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp if (!command->in_ctx) { 1435a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp kfree(command); 1436a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp return NULL; 1437a1d78c16bd31a715785e21967ac6110b386a3c1fSarah Sharp } 143806e182911da95a304eaab71288a47bc5c799c4ebJulia Lawall } 1439913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1440913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp if (allocate_completion) { 1441913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command->completion = 1442913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp kzalloc(sizeof(struct completion), mem_flags); 1443913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp if (!command->completion) { 1444913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp xhci_free_container_ctx(xhci, command->in_ctx); 144506e182911da95a304eaab71288a47bc5c799c4ebJulia Lawall kfree(command); 1446913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp return NULL; 1447913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp } 1448913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp init_completion(command->completion); 1449913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp } 1450913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 1451913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command->status = 0; 1452913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp INIT_LIST_HEAD(&command->cmd_list); 1453913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp return command; 1454913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp} 1455913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 14568e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xuvoid xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv) 14578e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu{ 14588e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu int last; 14598e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu 14608e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu if (!urb_priv) 14618e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu return; 14628e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu 14638e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu last = urb_priv->length - 1; 14648e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu if (last >= 0) { 14658e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu int i; 14668e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu for (i = 0; i <= last; i++) 14678e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu kfree(urb_priv->td[i]); 14688e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu } 14698e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu kfree(urb_priv); 14708e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu} 14718e51adccd4c4b9ffcd509d7f2afce0a906139f75Andiry Xu 1472913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharpvoid xhci_free_command(struct xhci_hcd *xhci, 1473913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp struct xhci_command *command) 1474913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp{ 1475913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp xhci_free_container_ctx(xhci, 1476913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp command->in_ctx); 1477913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp kfree(command->completion); 1478913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp kfree(command); 1479913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp} 1480913a8a344ffcaf0b4a586d6662a2c66a7106557dSarah Sharp 148166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpvoid xhci_mem_cleanup(struct xhci_hcd *xhci) 148266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 14830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 14840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp int size; 14853ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 14860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 14870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Free the Event Ring Segment Table and the actual Event Ring */ 1488d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp if (xhci->ir_set) { 1489d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_size); 1490d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp xhci_write_64(xhci, 0, &xhci->ir_set->erst_base); 1491d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp xhci_write_64(xhci, 0, &xhci->ir_set->erst_dequeue); 1492d94c05e33d9212ee67b8d4998f984cc71df8168bSarah Sharp } 14930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries); 14940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->erst.entries) 14950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp pci_free_consistent(pdev, size, 14960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries, xhci->erst.erst_dma_addr); 14970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = NULL; 14980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed ERST\n"); 14990ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->event_ring) 15000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->event_ring); 15010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = NULL; 15020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed event ring\n"); 15030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 15048e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring); 15050ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->cmd_ring) 15060ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->cmd_ring); 15070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = NULL; 15080ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed command ring\n"); 15093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 15103ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 1; i < MAX_HC_SLOTS; ++i) 15113ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, i); 15123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 15130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->segment_pool) 15140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_pool_destroy(xhci->segment_pool); 15150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = NULL; 15160ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed segment pool\n"); 15173ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 15183ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (xhci->device_pool) 15193ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dma_pool_destroy(xhci->device_pool); 15203ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = NULL; 15213ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Freed device context pool\n"); 15223ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 15238df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci->small_streams_pool) 15248df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_destroy(xhci->small_streams_pool); 15258df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->small_streams_pool = NULL; 15268df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Freed small stream array pool\n"); 15278df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 15288df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (xhci->medium_streams_pool) 15298df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_destroy(xhci->medium_streams_pool); 15308df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->medium_streams_pool = NULL; 15318df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci_dbg(xhci, "Freed medium stream array pool\n"); 15328df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 15338e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr); 1534a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (xhci->dcbaa) 1535a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp pci_free_consistent(pdev, sizeof(*xhci->dcbaa), 1536a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa, xhci->dcbaa->dma); 1537a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = NULL; 15383ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 15395294bea40666db5c5d6c336b8e4e55d69fa576caSarah Sharp scratchpad_free(xhci); 1540da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1541da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb2_ports = 0; 1542da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb3_ports = 0; 1543da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp kfree(xhci->usb2_ports); 1544da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp kfree(xhci->usb3_ports); 1545da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp kfree(xhci->port_array); 1546da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 154766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 0; 154866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 0; 154920b67cf51fa606442bb343afad0ee1a393a6afb3Sarah Sharp xhci->bus_state[0].bus_suspended = 0; 1550f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp xhci->bus_state[1].bus_suspended = 0; 155166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 155266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 15536648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharpstatic int xhci_test_trb_in_td(struct xhci_hcd *xhci, 15546648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *input_seg, 15556648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *start_trb, 15566648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *end_trb, 15576648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp dma_addr_t input_dma, 15586648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *result_seg, 15596648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp char *test_name, int test_number) 15606648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp{ 15616648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp unsigned long long start_dma; 15626648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp unsigned long long end_dma; 15636648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *seg; 15646648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 15656648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp start_dma = xhci_trb_virt_to_dma(input_seg, start_trb); 15666648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp end_dma = xhci_trb_virt_to_dma(input_seg, end_trb); 15676648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 15686648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp seg = trb_in_td(input_seg, start_trb, end_trb, input_dma); 15696648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (seg != result_seg) { 15706648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "WARN: %s TRB math test %d failed!\n", 15716648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp test_name, test_number); 15726648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "Tested TRB math w/ seg %p and " 15736648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "input DMA 0x%llx\n", 15746648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp input_seg, 15756648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp (unsigned long long) input_dma); 15766648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "starting TRB %p (0x%llx DMA), " 15776648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "ending TRB %p (0x%llx DMA)\n", 15786648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp start_trb, start_dma, 15796648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp end_trb, end_dma); 15806648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_warn(xhci, "Expected seg %p, got seg %p\n", 15816648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp result_seg, seg); 15826648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return -1; 15836648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } 15846648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return 0; 15856648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp} 15866648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 15876648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp/* TRB math checks for xhci_trb_in_td(), using the command and event rings. */ 15886648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharpstatic int xhci_check_trb_in_td_math(struct xhci_hcd *xhci, gfp_t mem_flags) 15896648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp{ 15906648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct { 15916648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp dma_addr_t input_dma; 15926648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *result_seg; 15936648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } simple_test_vector [] = { 15946648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* A zeroed DMA field should fail */ 15956648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { 0, NULL }, 15966648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One TRB before the ring start should fail */ 15976648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma - 16, NULL }, 15986648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One byte before the ring start should fail */ 15996648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma - 1, NULL }, 16006648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Starting TRB should succeed */ 16016648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma, xhci->event_ring->first_seg }, 16026648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Ending TRB should succeed */ 16036648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16, 16046648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci->event_ring->first_seg }, 16056648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One byte after the ring end should fail */ 16066648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 1)*16 + 1, NULL }, 16076648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* One TRB after the ring end should fail */ 16086648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT)*16, NULL }, 16096648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* An address of all ones should fail */ 16106648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { (dma_addr_t) (~0), NULL }, 16116648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }; 16126648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct { 16136648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *input_seg; 16146648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *start_trb; 16156648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp union xhci_trb *end_trb; 16166648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp dma_addr_t input_dma; 16176648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp struct xhci_segment *result_seg; 16186648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } complex_test_vector [] = { 16196648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Test feeding a valid DMA address from a different ring */ 16206648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16216648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = xhci->event_ring->first_seg->trbs, 16226648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 16236648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma, 16246648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16256648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16266648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Test feeding a valid end TRB from a different ring */ 16276648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16286648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = xhci->event_ring->first_seg->trbs, 16296648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 16306648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma, 16316648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16326648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16336648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* Test feeding a valid start and end TRB from a different ring */ 16346648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16356648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = xhci->cmd_ring->first_seg->trbs, 16366648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->cmd_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 16376648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma, 16386648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16396648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16406648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but after this TD */ 16416648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16426648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[0], 16436648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[3], 16446648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + 4*16, 16456648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16466648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16476648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but before this TD */ 16486648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16496648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[3], 16506648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[6], 16516648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + 2*16, 16526648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16536648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16546648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but after this wrapped TD */ 16556648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16566648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3], 16576648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[1], 16586648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + 2*16, 16596648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16606648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16616648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB in this ring, but before this wrapped TD */ 16626648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16636648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3], 16646648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[1], 16656648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->event_ring->first_seg->dma + (TRBS_PER_SEGMENT - 4)*16, 16666648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16676648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16686648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp /* TRB not in this ring, and we have a wrapped TD */ 16696648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp { .input_seg = xhci->event_ring->first_seg, 16706648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .start_trb = &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 3], 16716648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .end_trb = &xhci->event_ring->first_seg->trbs[1], 16726648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .input_dma = xhci->cmd_ring->first_seg->dma + 2*16, 16736648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp .result_seg = NULL, 16746648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }, 16756648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp }; 16766648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 16776648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp unsigned int num_tests; 16786648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp int i, ret; 16796648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 1680e10fa4787f1fb9c8738dff955c272f30b7b63134Kulikov Vasiliy num_tests = ARRAY_SIZE(simple_test_vector); 16816648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp for (i = 0; i < num_tests; i++) { 16826648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp ret = xhci_test_trb_in_td(xhci, 16836648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci->event_ring->first_seg, 16846648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci->event_ring->first_seg->trbs, 16856648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp &xhci->event_ring->first_seg->trbs[TRBS_PER_SEGMENT - 1], 16866648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp simple_test_vector[i].input_dma, 16876648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp simple_test_vector[i].result_seg, 16886648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "Simple", i); 16896648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (ret < 0) 16906648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return ret; 16916648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } 16926648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 1693e10fa4787f1fb9c8738dff955c272f30b7b63134Kulikov Vasiliy num_tests = ARRAY_SIZE(complex_test_vector); 16946648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp for (i = 0; i < num_tests; i++) { 16956648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp ret = xhci_test_trb_in_td(xhci, 16966648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].input_seg, 16976648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].start_trb, 16986648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].end_trb, 16996648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].input_dma, 17006648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp complex_test_vector[i].result_seg, 17016648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp "Complex", i); 17026648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (ret < 0) 17036648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return ret; 17046648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp } 17056648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp xhci_dbg(xhci, "TRB math tests passed.\n"); 17066648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp return 0; 17076648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp} 17086648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 1709257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharpstatic void xhci_set_hc_event_deq(struct xhci_hcd *xhci) 1710257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp{ 1711257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp u64 temp; 1712257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp dma_addr_t deq; 1713257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp 1714257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp deq = xhci_trb_virt_to_dma(xhci->event_ring->deq_seg, 1715257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp xhci->event_ring->dequeue); 1716257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp if (deq == 0 && !in_interrupt()) 1717257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp xhci_warn(xhci, "WARN something wrong with SW event ring " 1718257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp "dequeue ptr.\n"); 1719257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp /* Update HC event ring dequeue pointer */ 1720257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp temp = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue); 1721257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp temp &= ERST_PTR_MASK; 1722257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp /* Don't clear the EHB bit (which is RW1C) because 1723257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp * there might be more events to service. 1724257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp */ 1725257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp temp &= ~ERST_EHB; 1726257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp xhci_dbg(xhci, "// Write event ring dequeue pointer, " 1727257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp "preserving EHB bit\n"); 1728257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp xhci_write_64(xhci, ((u64) deq & (u64) ~ERST_PTR_MASK) | temp, 1729257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp &xhci->ir_set->erst_dequeue); 1730257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp} 1731257d585aaec469ded6ec15d8a8e7ebada21d7277Sarah Sharp 1732da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharpstatic void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports, 173328ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans __le32 __iomem *addr, u8 major_revision) 1734da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp{ 1735da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp u32 temp, port_offset, port_count; 1736da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp int i; 1737da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1738da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (major_revision > 0x03) { 1739da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_warn(xhci, "Ignoring unknown port speed, " 1740da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp "Ext Cap %p, revision = 0x%x\n", 1741da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp addr, major_revision); 1742da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* Ignoring port protocol we can't understand. FIXME */ 1743da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return; 1744da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1745da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1746da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* Port offset and count in the third dword, see section 7.2 */ 1747da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp temp = xhci_readl(xhci, addr + 2); 1748da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp port_offset = XHCI_EXT_PORT_OFF(temp); 1749da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp port_count = XHCI_EXT_PORT_COUNT(temp); 1750da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_dbg(xhci, "Ext Cap %p, port offset = %u, " 1751da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp "count = %u, revision = 0x%x\n", 1752da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp addr, port_offset, port_count, major_revision); 1753da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* Port count includes the current port offset */ 1754da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (port_offset == 0 || (port_offset + port_count - 1) > num_ports) 1755da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* WTF? "Valid values are ‘1’ to MaxPorts" */ 1756da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return; 1757da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp port_offset--; 1758da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp for (i = port_offset; i < (port_offset + port_count); i++) { 1759da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* Duplicate entry. Ignore the port if the revisions differ. */ 1760da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci->port_array[i] != 0) { 1761da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_warn(xhci, "Duplicate port entry, Ext Cap %p," 1762da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp " port %u\n", addr, i); 1763da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_warn(xhci, "Port was marked as USB %u, " 1764da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp "duplicated as USB %u\n", 1765da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->port_array[i], major_revision); 1766da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* Only adjust the roothub port counts if we haven't 1767da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * found a similar duplicate. 1768da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp */ 1769da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci->port_array[i] != major_revision && 177022e0487047567252d5677ff35766cd884375efc2Dan Carpenter xhci->port_array[i] != DUPLICATE_ENTRY) { 1771da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci->port_array[i] == 0x03) 1772da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb3_ports--; 1773da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp else 1774da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb2_ports--; 177522e0487047567252d5677ff35766cd884375efc2Dan Carpenter xhci->port_array[i] = DUPLICATE_ENTRY; 1776da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1777da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* FIXME: Should we disable the port? */ 1778f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp continue; 1779da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1780da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->port_array[i] = major_revision; 1781da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (major_revision == 0x03) 1782da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb3_ports++; 1783da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp else 1784da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb2_ports++; 1785da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1786da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* FIXME: Should we disable ports not in the Extended Capabilities? */ 1787da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp} 1788da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1789da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp/* 1790da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * Scan the Extended Capabilities for the "Supported Protocol Capabilities" that 1791da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * specify what speeds each port is supposed to be. We can't count on the port 1792da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * speed bits in the PORTSC register being correct until a device is connected, 1793da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * but we need to set up the two fake roothubs with the correct number of USB 1794da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * 3.0 and USB 2.0 ports at host controller initialization time. 1795da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp */ 1796da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharpstatic int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags) 1797da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp{ 179828ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans __le32 __iomem *addr; 1799da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp u32 offset; 1800da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp unsigned int num_ports; 1801da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp int i, port_index; 1802da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1803da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp addr = &xhci->cap_regs->hcc_params; 1804da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp offset = XHCI_HCC_EXT_CAPS(xhci_readl(xhci, addr)); 1805da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (offset == 0) { 1806da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_err(xhci, "No Extended Capability registers, " 1807da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp "unable to set up roothub.\n"); 1808da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return -ENODEV; 1809da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1810da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1811da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp num_ports = HCS_MAX_PORTS(xhci->hcs_params1); 1812da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->port_array = kzalloc(sizeof(*xhci->port_array)*num_ports, flags); 1813da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (!xhci->port_array) 1814da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return -ENOMEM; 1815da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1816da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* 1817da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * For whatever reason, the first capability offset is from the 1818da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * capability register base, not from the HCCPARAMS register. 1819da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * See section 5.3.6 for offset calculation. 1820da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp */ 1821da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp addr = &xhci->cap_regs->hc_capbase + offset; 1822da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp while (1) { 1823da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp u32 cap_id; 1824da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1825da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp cap_id = xhci_readl(xhci, addr); 1826da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL) 1827da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_add_in_port(xhci, num_ports, addr, 1828da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp (u8) XHCI_EXT_PORT_MAJOR(cap_id)); 1829da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp offset = XHCI_EXT_CAPS_NEXT(cap_id); 1830da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (!offset || (xhci->num_usb2_ports + xhci->num_usb3_ports) 1831da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp == num_ports) 1832da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp break; 1833da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* 1834da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * Once you're into the Extended Capabilities, the offset is 1835da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * always relative to the register holding the offset. 1836da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp */ 1837da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp addr += offset; 1838da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1839da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1840da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci->num_usb2_ports == 0 && xhci->num_usb3_ports == 0) { 1841da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_warn(xhci, "No ports on the roothubs?\n"); 1842da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return -ENODEV; 1843da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1844da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_dbg(xhci, "Found %u USB 2.0 ports and %u USB 3.0 ports.\n", 1845da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb2_ports, xhci->num_usb3_ports); 1846d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp 1847d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp /* Place limits on the number of roothub ports so that the hub 1848d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp * descriptors aren't longer than the USB core will allocate. 1849d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp */ 1850d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp if (xhci->num_usb3_ports > 15) { 1851d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp xhci_dbg(xhci, "Limiting USB 3.0 roothub ports to 15.\n"); 1852d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp xhci->num_usb3_ports = 15; 1853d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp } 1854d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp if (xhci->num_usb2_ports > USB_MAXCHILDREN) { 1855d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp xhci_dbg(xhci, "Limiting USB 2.0 roothub ports to %u.\n", 1856d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp USB_MAXCHILDREN); 1857d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp xhci->num_usb2_ports = USB_MAXCHILDREN; 1858d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp } 1859d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp 1860da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp /* 1861da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * Note we could have all USB 3.0 ports, or all USB 2.0 ports. 1862da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp * Not sure how the USB core will handle a hub with no ports... 1863da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp */ 1864da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci->num_usb2_ports) { 1865da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->usb2_ports = kmalloc(sizeof(*xhci->usb2_ports)* 1866da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb2_ports, flags); 1867da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (!xhci->usb2_ports) 1868da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return -ENOMEM; 1869da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1870da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp port_index = 0; 1871f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp for (i = 0; i < num_ports; i++) { 1872f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp if (xhci->port_array[i] == 0x03 || 1873f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp xhci->port_array[i] == 0 || 187422e0487047567252d5677ff35766cd884375efc2Dan Carpenter xhci->port_array[i] == DUPLICATE_ENTRY) 1875f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp continue; 1876f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp 1877f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp xhci->usb2_ports[port_index] = 1878f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp &xhci->op_regs->port_status_base + 1879f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp NUM_PORT_REGS*i; 1880f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp xhci_dbg(xhci, "USB 2.0 port at index %u, " 1881f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp "addr = %p\n", i, 1882f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp xhci->usb2_ports[port_index]); 1883f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp port_index++; 1884d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp if (port_index == xhci->num_usb2_ports) 1885d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp break; 1886f8bbeabc34aa945ab4275abc9a4dfde0aea798caSarah Sharp } 1887da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1888da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci->num_usb3_ports) { 1889da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->usb3_ports = kmalloc(sizeof(*xhci->usb3_ports)* 1890da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->num_usb3_ports, flags); 1891da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (!xhci->usb3_ports) 1892da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return -ENOMEM; 1893da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp 1894da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp port_index = 0; 1895da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp for (i = 0; i < num_ports; i++) 1896da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci->port_array[i] == 0x03) { 1897da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->usb3_ports[port_index] = 1898da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp &xhci->op_regs->port_status_base + 1899da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp NUM_PORT_REGS*i; 1900da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci_dbg(xhci, "USB 3.0 port at index %u, " 1901da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp "addr = %p\n", i, 1902da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp xhci->usb3_ports[port_index]); 1903da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp port_index++; 1904d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp if (port_index == xhci->num_usb3_ports) 1905d30b2a208108a0b0fdeae7006b8824d9be16ca96Sarah Sharp break; 1906da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1907da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp } 1908da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp return 0; 1909da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp} 19106648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp 191166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpint xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 191266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 19130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_addr_t dma; 19140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct device *dev = xhci_to_hcd(xhci)->self.controller; 191566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp unsigned int val, val2; 19168e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp u64 val_64; 19170ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 191866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp u32 page_size; 191966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp int i; 192066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 192166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = xhci_readl(xhci, &xhci->op_regs->page_size); 192266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size register = 0x%x\n", page_size); 192366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp for (i = 0; i < 16; i++) { 192466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if ((0x1 & page_size) != 0) 192566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp break; 192666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = page_size >> 1; 192766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp } 192866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if (i < 16) 192966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size of %iK\n", (1 << (i+12)) / 1024); 193066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp else 193166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "WARN: no supported page size\n"); 193266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* Use 4K pages, since that's common and the minimum the HC supports */ 193366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 12; 193466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 1 << xhci->page_shift; 193566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "HCD page size set to %iK\n", xhci->page_size / 1024); 193666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 193766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* 193866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Program the Number of Device Slots Enabled field in the CONFIG 193966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * register with the max value of slots the HC can handle. 194066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp */ 194166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val = HCS_MAX_SLOTS(xhci_readl(xhci, &xhci->cap_regs->hcs_params1)); 194266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// xHC can handle at most %d device slots.\n", 194366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 194466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val2 = xhci_readl(xhci, &xhci->op_regs->config_reg); 194566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val |= (val2 & ~HCS_SLOTS_MASK); 194666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// Setting Max device slots reg = 0x%x.\n", 194766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 194866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_writel(xhci, val, &xhci->op_regs->config_reg); 194966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 19500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 1951a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * Section 5.4.8 - doorbell array must be 1952a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * "physically contiguous and 64-byte (cache line) aligned". 1953a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp */ 1954a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = pci_alloc_consistent(to_pci_dev(dev), 1955a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp sizeof(*xhci->dcbaa), &dma); 1956a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (!xhci->dcbaa) 1957a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp goto fail; 1958a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa)); 1959a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa->dma = dma; 1960700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Device context base array address = 0x%llx (DMA), %p (virt)\n", 1961700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->dcbaa->dma, xhci->dcbaa); 19628e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr); 1963a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp 1964a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp /* 19650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Initialize the ring segment pool. The ring must be a contiguous 19660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * structure comprised of TRBs. The TRBs must be 16 byte aligned, 19670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * however, the command ring segment needs 64-byte aligned segments, 19680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * so we pick the greater alignment need. 19690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 19700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = dma_pool_create("xHCI ring segments", dev, 19710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp SEGMENT_SIZE, 64, xhci->page_size); 1972d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 19733ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* See Table 46 and Note on Figure 55 */ 19743ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = dma_pool_create("xHCI input/output contexts", dev, 1975d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 2112, 64, xhci->page_size); 19763ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->segment_pool || !xhci->device_pool) 19770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 19780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 19798df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Linear stream context arrays don't have any boundary restrictions, 19808df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * and only need to be 16-byte aligned. 19818df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 19828df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->small_streams_pool = 19838df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_create("xHCI 256 byte stream ctx arrays", 19848df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dev, SMALL_STREAM_ARRAY_SIZE, 16, 0); 19858df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp xhci->medium_streams_pool = 19868df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dma_pool_create("xHCI 1KB stream ctx arrays", 19878df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp dev, MEDIUM_STREAM_ARRAY_SIZE, 16, 0); 19888df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp /* Any stream context array bigger than MEDIUM_STREAM_ARRAY_SIZE 19898df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp * will be allocated with pci_alloc_consistent() 19908df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp */ 19918df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 19928df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp if (!xhci->small_streams_pool || !xhci->medium_streams_pool) 19938df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp goto fail; 19948df75f42f8e67e2851cdcf6da91640fb881defd1Sarah Sharp 19950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set up the command ring to have one segments for now. */ 19960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags); 19970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->cmd_ring) 19980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1999700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring); 2000700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "First segment DMA is 0x%llx\n", 2001700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->cmd_ring->first_seg->dma); 20020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the address in the Command Ring Control register */ 20048e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring); 20058e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) | 20068e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp (xhci->cmd_ring->first_seg->dma & (u64) ~CMD_RING_RSVD_BITS) | 20070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring->cycle_state; 20088e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_dbg(xhci, "// Setting command ring address to 0x%x\n", val); 20098e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring); 20100ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_cmd_ptrs(xhci); 20110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20120ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->cap_regs->db_off); 20130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= DBOFF_MASK; 20140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x" 20150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp " from cap regs base addr\n", val); 2016c50a00f8feba42c5bccff47e052e4cb0c95dcd2bDmitry Torokhov xhci->dba = (void __iomem *) xhci->cap_regs + val; 20170ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_regs(xhci); 20180ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_print_run_regs(xhci); 20190ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set ir_set to interrupt register set 0 */ 2020c50a00f8feba42c5bccff47e052e4cb0c95dcd2bDmitry Torokhov xhci->ir_set = &xhci->run_regs->ir_set[0]; 20210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20220ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 20230ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Event ring setup: Allocate a normal ring, but also setup 20240ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * the event ring segment table (ERST). Section 4.9.3. 20250ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 20260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Allocating event ring\n"); 20270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags); 20280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->event_ring) 20290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 20306648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp if (xhci_check_trb_in_td_math(xhci, flags) < 0) 20316648f29d3be2972a74ef8e29aa5d425ab4f1fc48Sarah Sharp goto fail; 20320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = pci_alloc_consistent(to_pci_dev(dev), 20340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma); 20350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->erst.entries) 20360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 2037700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Allocated event ring segment table at 0x%llx\n", 2038700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)dma); 20390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp memset(xhci->erst.entries, 0, sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS); 20410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries = ERST_NUM_SEGS; 20420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.erst_dma_addr = dma; 2043700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Set ERST to 0; private num segs = %i, virt addr = %p, dma addr = 0x%llx\n", 20440ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries, 2045700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci->erst.entries, 2046700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->erst.erst_dma_addr); 20470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ring base address and size for each segment table entry */ 20490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) { 20500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_erst_entry *entry = &xhci->erst.entries[val]; 205128ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans entry->seg_addr = cpu_to_le64(seg->dma); 205228ccd2962c66556d7037b2d9f1c11cdcd3b805d5Matt Evans entry->seg_size = cpu_to_le32(TRBS_PER_SEGMENT); 20530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->rsvd = 0; 20540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = seg->next; 20550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 20560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ERST count with the number of entries in the segment table */ 20580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->ir_set->erst_size); 20590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ERST_SIZE_MASK; 20600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= ERST_NUM_SEGS; 20610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Write ERST size = %i to ir_set 0 (some bits preserved)\n", 20620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val); 20630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, val, &xhci->ir_set->erst_size); 20640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Set ERST entries to point to event ring.\n"); 20660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set the segment table base address */ 2067700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Set ERST base address for ir_set 0 = 0x%llx\n", 2068700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->erst.erst_dma_addr); 20698e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = xhci_read_64(xhci, &xhci->ir_set->erst_base); 20708e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 &= ERST_PTR_MASK; 20718e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 |= (xhci->erst.erst_dma_addr & (u64) ~ERST_PTR_MASK); 20728e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, val_64, &xhci->ir_set->erst_base); 20730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the event ring dequeue address */ 207523e3be113f42790736319c049c78e5f9a4394c02Sarah Sharp xhci_set_hc_event_deq(xhci); 20760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote ERST address to ir_set 0.\n"); 207709ece30e06b19994e6f3d260e5c4be18dce22714Dmitry Torokhov xhci_print_ir_set(xhci, 0); 20780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 20790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 20800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * XXX: Might need to set the Interrupter Moderation Register to 20810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * something other than the default (~1ms minimum between interrupts). 20820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 5.5.1.2. 20830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 20843ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp init_completion(&xhci->addr_dev); 20853ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 0; i < MAX_HC_SLOTS; ++i) 2086326b4810cc995209e31136af4202ed0414814ed5Randy Dunlap xhci->devs[i] = NULL; 2087f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp for (i = 0; i < USB_MAXCHILDREN; ++i) { 208820b67cf51fa606442bb343afad0ee1a393a6afb3Sarah Sharp xhci->bus_state[0].resume_done[i] = 0; 2089f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp xhci->bus_state[1].resume_done[i] = 0; 2090f6ff0ac878eb420011fa2448851dd48c3a7e7b31Sarah Sharp } 209166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 2092254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (scratchpad_alloc(xhci, flags)) 2093254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail; 2094da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp if (xhci_setup_port_arrays(xhci, flags)) 2095da6699ce4a889c3795624ccdcfe7181cc89f18e8Sarah Sharp goto fail; 2096254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 209766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return 0; 2098254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 209966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpfail: 210066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "Couldn't initialize memory\n"); 210166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_mem_cleanup(xhci); 210266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return -ENOMEM; 210366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 2104