xhci-mem.c revision f94e0186312b0fc39f41eed4e21836ed74b7efe1
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> 2566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 2666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp#include "xhci.h" 2766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* 290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Allocates a generic ring segment from the ring pool, sets the dma address, 300ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * initializes the segment to zero, and sets the private next pointer to NULL. 310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Section 4.11.1.1: 330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * "All components of all Command and Transfer TRBs shall be initialized to '0'" 340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flags) 360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_addr_t dma; 390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = kzalloc(sizeof *seg, flags); 410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!seg) 420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Allocating priv segment structure at 0x%x\n", 440ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp (unsigned int) seg); 450ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 460ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->trbs = dma_pool_alloc(xhci->segment_pool, flags, &dma); 470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!seg->trbs) { 480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(seg); 490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Allocating segment at 0x%x (virtual) 0x%x (DMA)\n", 520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp (unsigned int) seg->trbs, (u32) dma); 530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp memset(seg->trbs, 0, SEGMENT_SIZE); 550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->dma = dma; 560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->next = NULL; 570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return seg; 590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic void xhci_segment_free(struct xhci_hcd *xhci, struct xhci_segment *seg) 620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!seg) 640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (seg->trbs) { 660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freeing DMA segment at 0x%x" 670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp " (virtual) 0x%x (DMA)\n", 680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp (unsigned int) seg->trbs, (u32) seg->dma); 690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma); 700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->trbs = NULL; 710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freeing priv segment structure at 0x%x\n", 730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp (unsigned int) seg); 740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(seg); 750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* 780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Make the prev segment point to the next segment. 790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Change the last TRB in the prev segment to be a Link TRB which points to the 810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * DMA address of the next segment. The caller needs to set any Link TRB 820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * related flags, such as End TRB, Toggle Cycle, and no snoop. 830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev, 850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next, bool link_trbs) 860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp u32 val; 880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!prev || !next) 900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 910ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->next = next; 920ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (link_trbs) { 930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr[0] = next->dma; 940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the last TRB in the segment to have a TRB type ID of Link TRB */ 960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = prev->trbs[TRBS_PER_SEGMENT-1].link.control; 970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ~TRB_TYPE_BITMASK; 980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= TRB_TYPE(TRB_LINK); 990ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.control = val; 1000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Linking segment 0x%x to segment 0x%x (DMA)\n", 1020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->dma, next->dma); 1030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1040ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1050ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* XXX: Do we need the hcd structure in all these functions? */ 106f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring) 1070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1080ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 1090ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *first_seg; 1100ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring || !ring->first_seg) 1120ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 1130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp first_seg = ring->first_seg; 1140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = first_seg->next; 1150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freeing ring at 0x%x\n", (unsigned int) ring); 1160ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (seg != first_seg) { 1170ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next = seg->next; 1180ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, seg); 1190ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = next; 1200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, first_seg); 1220ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = NULL; 1230ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(ring); 1240ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1250ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/** 1270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Create a new ring with zero or more segments. 1280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 1290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Link each segment together into a ring. 1300ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Set the end flag and the cycle toggle bit on the last segment. 1310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 4.9.1 and figures 15 and 16. 1320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 1330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci, 1340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp unsigned int num_segs, bool link_trbs, gfp_t flags) 1350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_ring *ring; 1370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *prev; 1380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring = kzalloc(sizeof *(ring), flags); 1400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Allocating ring at 0x%x\n", (unsigned int) ring); 1410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring) 1420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 1430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 144d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp INIT_LIST_HEAD(&ring->td_list); 1450ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (num_segs == 0) 1460ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = xhci_segment_alloc(xhci, flags); 1490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring->first_seg) 1500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = ring->first_seg; 1540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (num_segs > 0) { 1550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next; 1560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp next = xhci_segment_alloc(xhci, flags); 1580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!next) 1590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, next, link_trbs); 1610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = next; 1630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, ring->first_seg, link_trbs); 1660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (link_trbs) { 1680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* See section 4.9.2.1 and 6.4.4.1 */ 1690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.control |= (LINK_TOGGLE); 1700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote link toggle flag to" 1710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp " segment 0x%x (virtual), 0x%x (DMA)\n", 1720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp (unsigned int) prev, (u32) prev->dma); 1730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* The ring is empty, so the enqueue pointer == dequeue pointer */ 1750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->enqueue = ring->first_seg->trbs; 1767f84eef0dafb1d318263d8b71c38700aaf2d530dSarah Sharp ring->enq_seg = ring->first_seg; 1770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->dequeue = ring->enqueue; 1787f84eef0dafb1d318263d8b71c38700aaf2d530dSarah Sharp ring->deq_seg = ring->first_seg; 1790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* The ring is initialized to 0. The producer must write 1 to the cycle 1800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * bit to handover ownership of the TRB, so PCS = 1. The consumer must 1810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * compare CCS to the cycle bit to check ownership, so CCS = 1. 1820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 1830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->cycle_state = 1; 1840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpfail: 1880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, ring); 1890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 1900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1910ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 192d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp/* All the xhci_tds in the ring's TD list should be freed at this point */ 1933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpvoid xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id) 1943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 1953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 1963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 1973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 1983ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 1993ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || !xhci->devs[slot_id]) 2003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 2013ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2023ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 2033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->dcbaa->dev_context_ptrs[2*slot_id] = 0; 2043ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->dcbaa->dev_context_ptrs[2*slot_id + 1] = 0; 2053ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev) 2063ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 2073ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2083ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 0; i < 31; ++i) 2093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->ep_rings[i]) 2103ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_ring_free(xhci, dev->ep_rings[i]); 2113ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->in_ctx) 2133ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dma_pool_free(xhci->device_pool, 2143ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx, dev->in_ctx_dma); 2153ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->out_ctx) 2163ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dma_pool_free(xhci->device_pool, 2173ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->out_ctx, dev->out_ctx_dma); 2183ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp kfree(xhci->devs[slot_id]); 2193ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[slot_id] = 0; 2203ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 2213ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2223ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, 2233ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct usb_device *udev, gfp_t flags) 2243ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 2253ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dma_addr_t dma; 2263ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 2273ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2283ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 2293ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || xhci->devs[slot_id]) { 2303ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Bad Slot ID %d\n", slot_id); 2313ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 2323ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 2333ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2343ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[slot_id] = kzalloc(sizeof(*xhci->devs[slot_id]), flags); 2353ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->devs[slot_id]) 2363ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 2373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 2383ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2393ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate the (output) device context that will be used in the HC */ 2403ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->out_ctx = dma_pool_alloc(xhci->device_pool, flags, &dma); 2413ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->out_ctx) 2423ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 2433ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->out_ctx_dma = dma; 2443ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Slot %d output ctx = 0x%x (dma)\n", slot_id, dma); 2453ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp memset(dev->out_ctx, 0, sizeof(*dev->out_ctx)); 2463ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2473ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate the (input) device context for address device command */ 2483ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx = dma_pool_alloc(xhci->device_pool, flags, &dma); 2493ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->in_ctx) 2503ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 2513ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx_dma = dma; 2523ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Slot %d input ctx = 0x%x (dma)\n", slot_id, dma); 2533ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp memset(dev->in_ctx, 0, sizeof(*dev->in_ctx)); 2543ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2553ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate endpoint 0 ring */ 2563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->ep_rings[0] = xhci_ring_alloc(xhci, 1, true, flags); 2573ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->ep_rings[0]) 2583ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 2593ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 260f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp init_completion(&dev->cmd_completion); 261f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 2623ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 2633ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * Point to output device context in dcbaa; skip the output control 2643ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * context, which is eight 32 bit fields (or 32 bytes long) 2653ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp */ 2663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->dcbaa->dev_context_ptrs[2*slot_id] = 2673ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp (u32) dev->out_ctx_dma + (32); 2683ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Set slot id %d dcbaa entry 0x%x to 0x%x\n", 2693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp slot_id, 2703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp (unsigned int) &xhci->dcbaa->dev_context_ptrs[2*slot_id], 2713ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->out_ctx_dma); 2723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->dcbaa->dev_context_ptrs[2*slot_id + 1] = 0; 2733ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2743ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 1; 2753ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpfail: 2763ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, slot_id); 2773ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 2783ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 2793ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2803ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp/* Setup an xHCI virtual device for a Set Address command */ 2813ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev) 2823ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 2833ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 2843ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_ep_ctx *ep0_ctx; 2853ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct usb_device *top_dev; 2863ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2873ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[udev->slot_id]; 2883ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 2893ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (udev->slot_id == 0 || !dev) { 2903ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Slot ID %d is not assigned to this device\n", 2913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp udev->slot_id); 2923ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 2933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 2943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx = &dev->in_ctx->ep[0]; 2953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 2) New slot context and endpoint 0 context are valid*/ 2973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->add_flags = SLOT_FLAG | EP0_FLAG; 2983ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2993ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 3) Only the control endpoint is valid - one endpoint context */ 3003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.dev_info |= LAST_CTX(1); 3013ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3023ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp switch (udev->speed) { 3033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_SUPER: 3043ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.dev_info |= (u32) udev->route; 3053ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_SS; 3063ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3073ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_HIGH: 3083ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_HS; 3093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3103ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_FULL: 3113ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_FS; 3123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3133ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_LOW: 3143ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.dev_info |= (u32) SLOT_SPEED_LS; 3153ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3163ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_VARIABLE: 3173ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); 3183ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 3193ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3203ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp default: 3213ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Speed was set earlier, this shouldn't happen. */ 3223ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp BUG(); 3233ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 3243ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Find the root hub port this device is under */ 3253ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (top_dev = udev; top_dev->parent && top_dev->parent->parent; 3263ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp top_dev = top_dev->parent) 3273ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Found device below root hub */; 3283ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.dev_info2 |= (u32) ROOT_HUB_PORT(top_dev->portnum); 3293ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Set root hub portnum to %d\n", top_dev->portnum); 3303ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3313ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Is this a LS/FS device under a HS hub? */ 3323ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 3333ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * FIXME: I don't think this is right, where does the TT info for the 3343ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * roothub or parent hub come from? 3353ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp */ 3363ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if ((udev->speed == USB_SPEED_LOW || udev->speed == USB_SPEED_FULL) && 3373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp udev->tt) { 3383ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.tt_info = udev->tt->hub->slot_id; 3393ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->in_ctx->slot.tt_info |= udev->ttport << 8; 3403ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 3413ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "udev->tt = 0x%x\n", (unsigned int) udev->tt); 3423ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport); 3433ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3443ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 4 - ring already allocated */ 3453ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 5 */ 3463ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 = EP_TYPE(CTRL_EP); 3473ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 3483ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * See section 4.3 bullet 6: 3493ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * The default Max Packet size for ep0 is "8 bytes for a USB2 3503ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * LS/FS/HS device or 512 bytes for a USB3 SS device" 3513ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * XXX: Not sure about wireless USB devices. 3523ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp */ 3533ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (udev->speed == USB_SPEED_SUPER) 3543ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(512); 3553ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp else 3563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(8); 3573ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */ 3583ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_BURST(0); 3593ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= ERROR_COUNT(3); 3603ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->deq[0] = 3623ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev->ep_rings[0]->first_seg->dma; 3633ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->deq[0] |= dev->ep_rings[0]->cycle_state; 3643ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->deq[1] = 0; 3653ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Steps 7 and 8 were done in xhci_alloc_virt_device() */ 3673ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3683ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 3693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 3703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 371f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp/* Return the polling or NAK interval. 372f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 373f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The polling interval is expressed in "microframes". If xHCI's Interval field 374f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to N, it will service the endpoint every 2^(Interval)*125us. 375f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 376f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The NAK interval is one NAK per 1 to 255 microframes, or no NAKs if interval 377f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to 0. 378f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 379f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpstatic inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev, 380f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 381f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 382f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int interval = 0; 383f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 384f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 385f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 386f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Max NAK rate */ 387f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc) || 388f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_bulk(&ep->desc)) 389f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = ep->desc.bInterval; 390f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through - SS and HS isoc/int have same decoding */ 391f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 392f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 393f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_isoc(&ep->desc)) { 394f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (ep->desc.bInterval == 0) 395f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 0; 396f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 397f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = ep->desc.bInterval - 1; 398f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval > 15) 399f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 15; 400f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval != ep->desc.bInterval + 1) 401f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n", 402f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep->desc.bEndpointAddress, 1 << interval); 403f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 404f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 405f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Convert bInterval (in 1-255 frames) to microframes and round down to 406f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * nearest power of 2. 407f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 408f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 409f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 410f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 411f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_isoc(&ep->desc)) { 412f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = fls(8*ep->desc.bInterval) - 1; 413f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval > 10) 414f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 10; 415f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval < 3) 416f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 3; 417f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if ((1 << interval) != 8*ep->desc.bInterval) 418f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n", 419f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep->desc.bEndpointAddress, 1 << interval); 420f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 421f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 422f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 423f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 424f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 425f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return EP_INTERVAL(interval); 426f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 427f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 428f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpstatic inline u32 xhci_get_endpoint_type(struct usb_device *udev, 429f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 430f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 431f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp int in; 432f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp u32 type; 433f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 434f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp in = usb_endpoint_dir_in(&ep->desc); 435f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc)) { 436f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(CTRL_EP); 437f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_bulk(&ep->desc)) { 438f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 439f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_IN_EP); 440f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 441f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_OUT_EP); 442f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_isoc(&ep->desc)) { 443f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 444f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_IN_EP); 445f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 446f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_OUT_EP); 447f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_int(&ep->desc)) { 448f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 449f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_IN_EP); 450f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 451f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_OUT_EP); 452f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else { 453f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 454f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 455f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return type; 456f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 457f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 458f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpint xhci_endpoint_init(struct xhci_hcd *xhci, 459f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 460f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_device *udev, 461f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 462f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 463f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 464f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 465f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ring *ep_ring; 466f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_packet; 467f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_burst; 468f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 469f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 470f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx = &virt_dev->in_ctx->ep[ep_index]; 471f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 472f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set up the endpoint ring */ 473f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp virt_dev->new_ep_rings[ep_index] = xhci_ring_alloc(xhci, 1, true, GFP_KERNEL); 474f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (!virt_dev->new_ep_rings[ep_index]) 475f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return -ENOMEM; 476f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ring = virt_dev->new_ep_rings[ep_index]; 477f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->deq[1] = 0; 478f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->deq[0] = ep_ring->first_seg->dma | ep_ring->cycle_state; 479f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 480f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep); 481f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 482f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME dig Mult and streams info out of ep companion desc */ 483f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 484f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Allow 3 retries for everything but isoc */ 485f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (!usb_endpoint_xfer_isoc(&ep->desc)) 486f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = ERROR_COUNT(3); 487f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 488f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = ERROR_COUNT(0); 489f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 490f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= xhci_get_endpoint_type(udev, ep); 491f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 492f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set the max packet size and max burst */ 493f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 494f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 495f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_packet = ep->desc.wMaxPacketSize; 496f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_PACKET(max_packet); 497f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME dig out burst from ep companion desc */ 498f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 499f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 500f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* bits 11:12 specify the number of additional transaction 501f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * opportunities per microframe (USB 2.0, section 9.6.6) 502f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 503f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_isoc(&ep->desc) || 504f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_int(&ep->desc)) { 505f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11; 506f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_BURST(max_burst); 507f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 508f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through */ 509f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 510f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 511f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_packet = ep->desc.wMaxPacketSize & 0x3ff; 512f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_PACKET(max_packet); 513f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 514f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 515f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 516f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 517f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME Debug endpoint context */ 518f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return 0; 519f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 520f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 521f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_endpoint_zero(struct xhci_hcd *xhci, 522f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 523f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 524f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 525f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 526f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 527f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 528f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 529f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx = &virt_dev->in_ctx->ep[ep_index]; 530f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 531f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info = 0; 532f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = 0; 533f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->deq[1] = 0; 534f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->deq[0] = 0; 535f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->tx_info = 0; 536f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Don't free the endpoint ring until the set interface or configuration 537f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * request succeeds. 538f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 539f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 540f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 54166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpvoid xhci_mem_cleanup(struct xhci_hcd *xhci) 54266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 5430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 5440ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp int size; 5453ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 5460ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 5470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Free the Event Ring Segment Table and the actual Event Ring */ 5480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_size); 5490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_base[1]); 5500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_base[0]); 5510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_dequeue[1]); 5520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_dequeue[0]); 5530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries); 5540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->erst.entries) 5550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp pci_free_consistent(pdev, size, 5560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries, xhci->erst.erst_dma_addr); 5570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = NULL; 5580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed ERST\n"); 5590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->event_ring) 5600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->event_ring); 5610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = NULL; 5620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed event ring\n"); 5630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 5640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->op_regs->cmd_ring[1]); 5650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->op_regs->cmd_ring[0]); 5660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->cmd_ring) 5670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->cmd_ring); 5680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = NULL; 5690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed command ring\n"); 5703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 5713ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 1; i < MAX_HC_SLOTS; ++i) 5723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, i); 5733ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 5740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->segment_pool) 5750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_pool_destroy(xhci->segment_pool); 5760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = NULL; 5770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed segment pool\n"); 5783ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 5793ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (xhci->device_pool) 5803ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dma_pool_destroy(xhci->device_pool); 5813ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = NULL; 5823ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Freed device context pool\n"); 5833ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 584a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci_writel(xhci, 0, &xhci->op_regs->dcbaa_ptr[1]); 585a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci_writel(xhci, 0, &xhci->op_regs->dcbaa_ptr[0]); 586a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (xhci->dcbaa) 587a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp pci_free_consistent(pdev, sizeof(*xhci->dcbaa), 588a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa, xhci->dcbaa->dma); 589a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = NULL; 5903ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 59166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 0; 59266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 0; 59366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 59466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 59566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpint xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 59666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 5970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_addr_t dma; 5980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct device *dev = xhci_to_hcd(xhci)->self.controller; 59966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp unsigned int val, val2; 6000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 60166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp u32 page_size; 60266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp int i; 60366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 60466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = xhci_readl(xhci, &xhci->op_regs->page_size); 60566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size register = 0x%x\n", page_size); 60666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp for (i = 0; i < 16; i++) { 60766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if ((0x1 & page_size) != 0) 60866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp break; 60966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = page_size >> 1; 61066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp } 61166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if (i < 16) 61266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size of %iK\n", (1 << (i+12)) / 1024); 61366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp else 61466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "WARN: no supported page size\n"); 61566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* Use 4K pages, since that's common and the minimum the HC supports */ 61666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 12; 61766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 1 << xhci->page_shift; 61866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "HCD page size set to %iK\n", xhci->page_size / 1024); 61966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 62066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* 62166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Program the Number of Device Slots Enabled field in the CONFIG 62266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * register with the max value of slots the HC can handle. 62366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp */ 62466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val = HCS_MAX_SLOTS(xhci_readl(xhci, &xhci->cap_regs->hcs_params1)); 62566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// xHC can handle at most %d device slots.\n", 62666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 62766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val2 = xhci_readl(xhci, &xhci->op_regs->config_reg); 62866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val |= (val2 & ~HCS_SLOTS_MASK); 62966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// Setting Max device slots reg = 0x%x.\n", 63066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 63166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_writel(xhci, val, &xhci->op_regs->config_reg); 63266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 6330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 634a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * Section 5.4.8 - doorbell array must be 635a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * "physically contiguous and 64-byte (cache line) aligned". 636a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp */ 637a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = pci_alloc_consistent(to_pci_dev(dev), 638a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp sizeof(*xhci->dcbaa), &dma); 639a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (!xhci->dcbaa) 640a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp goto fail; 641a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa)); 642a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa->dma = dma; 6433ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "// Device context base array address = 0x%x (DMA), 0x%x (virt)\n", 6443ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->dcbaa->dma, (unsigned int) xhci->dcbaa); 645a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci_writel(xhci, (u32) 0, &xhci->op_regs->dcbaa_ptr[1]); 646a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci_writel(xhci, dma, &xhci->op_regs->dcbaa_ptr[0]); 647a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp 648a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp /* 6490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Initialize the ring segment pool. The ring must be a contiguous 6500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * structure comprised of TRBs. The TRBs must be 16 byte aligned, 6510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * however, the command ring segment needs 64-byte aligned segments, 6520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * so we pick the greater alignment need. 6530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 6540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = dma_pool_create("xHCI ring segments", dev, 6550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp SEGMENT_SIZE, 64, xhci->page_size); 6563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* See Table 46 and Note on Figure 55 */ 6573ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* FIXME support 64-byte contexts */ 6583ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = dma_pool_create("xHCI input/output contexts", dev, 6593ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp sizeof(struct xhci_device_control), 6603ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 64, xhci->page_size); 6613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->segment_pool || !xhci->device_pool) 6620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 6630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 6640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set up the command ring to have one segments for now. */ 6650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags); 6660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->cmd_ring) 6670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 6680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Allocated command ring at 0x%x\n", (unsigned int) xhci->cmd_ring); 6690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "First segment DMA is 0x%x\n", (unsigned int) xhci->cmd_ring->first_seg->dma); 6700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 6710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the address in the Command Ring Control register */ 6720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->op_regs->cmd_ring[0]); 6730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = (val & ~CMD_RING_ADDR_MASK) | 6740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp (xhci->cmd_ring->first_seg->dma & CMD_RING_ADDR_MASK) | 6750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring->cycle_state; 6760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Setting command ring address high bits to 0x0\n"); 6770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, (u32) 0, &xhci->op_regs->cmd_ring[1]); 6780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Setting command ring address low bits to 0x%x\n", val); 6790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, val, &xhci->op_regs->cmd_ring[0]); 6800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_cmd_ptrs(xhci); 6810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 6820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->cap_regs->db_off); 6830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= DBOFF_MASK; 6840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x" 6850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp " from cap regs base addr\n", val); 6860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->dba = (void *) xhci->cap_regs + val; 6870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_regs(xhci); 6880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_print_run_regs(xhci); 6890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set ir_set to interrupt register set 0 */ 6900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->ir_set = (void *) xhci->run_regs->ir_set; 6910ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 6920ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 6930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Event ring setup: Allocate a normal ring, but also setup 6940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * the event ring segment table (ERST). Section 4.9.3. 6950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 6960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Allocating event ring\n"); 6970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags); 6980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->event_ring) 6990ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 7000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = pci_alloc_consistent(to_pci_dev(dev), 7020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma); 7030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->erst.entries) 7040ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 7050ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Allocated event ring segment table at 0x%x\n", dma); 7060ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp memset(xhci->erst.entries, 0, sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS); 7080ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries = ERST_NUM_SEGS; 7090ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.erst_dma_addr = dma; 7100ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Set ERST to 0; private num segs = %i, virt addr = 0x%x, dma addr = 0x%x\n", 7110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries, 7120ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp (unsigned int) xhci->erst.entries, 7130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.erst_dma_addr); 7140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ring base address and size for each segment table entry */ 7160ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) { 7170ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_erst_entry *entry = &xhci->erst.entries[val]; 7180ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->seg_addr[1] = 0; 7190ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->seg_addr[0] = seg->dma; 7200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->seg_size = TRBS_PER_SEGMENT; 7210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->rsvd = 0; 7220ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = seg->next; 7230ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 7240ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7250ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ERST count with the number of entries in the segment table */ 7260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->ir_set->erst_size); 7270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ERST_SIZE_MASK; 7280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= ERST_NUM_SEGS; 7290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Write ERST size = %i to ir_set 0 (some bits preserved)\n", 7300ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val); 7310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, val, &xhci->ir_set->erst_size); 7320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Set ERST entries to point to event ring.\n"); 7340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set the segment table base address */ 7350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Set ERST base address for ir_set 0 = 0x%x\n", 7360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.erst_dma_addr); 7370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_base[1]); 7380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->ir_set->erst_base[0]); 7390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ERST_PTR_MASK; 7400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= (xhci->erst.erst_dma_addr & ~ERST_PTR_MASK); 7410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, val, &xhci->ir_set->erst_base[0]); 7420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the event ring dequeue address */ 7447f84eef0dafb1d318263d8b71c38700aaf2d530dSarah Sharp set_hc_event_deq(xhci); 7450ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote ERST address to ir_set 0.\n"); 7460ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_print_ir_set(xhci, xhci->ir_set, 0); 7470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 7490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * XXX: Might need to set the Interrupter Moderation Register to 7500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * something other than the default (~1ms minimum between interrupts). 7510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 5.5.1.2. 7520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 7533ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp init_completion(&xhci->addr_dev); 7543ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 0; i < MAX_HC_SLOTS; ++i) 7553ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[i] = 0; 75666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 75766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return 0; 75866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpfail: 75966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "Couldn't initialize memory\n"); 76066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_mem_cleanup(xhci); 76166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return -ENOMEM; 76266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 763