xhci-mem.c revision 63a0d9abd18cdcf5a985029c266c6bfe0511768f
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> 25527c6d7f188f116852141f50b4d008f966bb17f8Sarah Sharp#include <linux/dmapool.h> 2666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 2766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp#include "xhci.h" 2866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* 300ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Allocates a generic ring segment from the ring pool, sets the dma address, 310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * initializes the segment to zero, and sets the private next pointer to NULL. 320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Section 4.11.1.1: 340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * "All components of all Command and Transfer TRBs shall be initialized to '0'" 350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci, gfp_t flags) 370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_addr_t dma; 400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = kzalloc(sizeof *seg, flags); 420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!seg) 430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 44700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocating priv segment structure at %p\n", 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 } 51700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Allocating segment at %p (virtual) 0x%llx (DMA)\n", 52700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman seg->trbs, (unsigned long long)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) { 66700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Freeing DMA segment at %p (virtual) 0x%llx (DMA)\n", 67700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman seg->trbs, (unsigned long long)seg->dma); 680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_pool_free(xhci->segment_pool, seg->trbs, seg->dma); 690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg->trbs = NULL; 700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 71700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Freeing priv segment structure at %p\n", seg); 720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(seg); 730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* 760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Make the prev segment point to the next segment. 770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Change the last TRB in the prev segment to be a Link TRB which points to the 790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * DMA address of the next segment. The caller needs to set any Link TRB 800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * related flags, such as End TRB, Toggle Cycle, and no snoop. 810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev, 830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next, bool link_trbs) 840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp u32 val; 860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!prev || !next) 880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->next = next; 900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (link_trbs) { 918e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr = next->dma; 920ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the last TRB in the segment to have a TRB type ID of Link TRB */ 940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = prev->trbs[TRBS_PER_SEGMENT-1].link.control; 950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ~TRB_TYPE_BITMASK; 960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= TRB_TYPE(TRB_LINK); 97b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp /* Always set the chain bit with 0.95 hardware */ 98b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp if (xhci_link_trb_quirk(xhci)) 99b0567b3f635db72c881a0d561cebb544ec085073Sarah Sharp val |= TRB_CHAIN; 1000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.control = val; 1010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 102700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Linking segment 0x%llx to segment 0x%llx (DMA)\n", 103700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)prev->dma, 104700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)next->dma); 1050ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1060ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/* XXX: Do we need the hcd structure in all these functions? */ 108f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_ring_free(struct xhci_hcd *xhci, struct xhci_ring *ring) 1090ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1100ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 1110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *first_seg; 1120ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring || !ring->first_seg) 1140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return; 1150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp first_seg = ring->first_seg; 1160ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = first_seg->next; 117700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Freeing ring at %p\n", ring); 1180ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (seg != first_seg) { 1190ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next = seg->next; 1200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, seg); 1210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = next; 1220ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1230ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_segment_free(xhci, first_seg); 1240ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = NULL; 1250ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp kfree(ring); 1260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp/** 1290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Create a new ring with zero or more segments. 1300ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * 1310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Link each segment together into a ring. 1320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Set the end flag and the cycle toggle bit on the last segment. 1330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 4.9.1 and figures 15 and 16. 1340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 1350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpstatic struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci, 1360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp unsigned int num_segs, bool link_trbs, gfp_t flags) 1370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp{ 1380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_ring *ring; 1390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *prev; 1400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring = kzalloc(sizeof *(ring), flags); 142700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocating ring at %p\n", ring); 1430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring) 1440ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 1450ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 146d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp INIT_LIST_HEAD(&ring->td_list); 1470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (num_segs == 0) 1480ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1490ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1500ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->first_seg = xhci_segment_alloc(xhci, flags); 1510ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!ring->first_seg) 1520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1540ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = ring->first_seg; 1560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp while (num_segs > 0) { 1570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *next; 1580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp next = xhci_segment_alloc(xhci, flags); 1600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!next) 1610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 1620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, next, link_trbs); 1630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev = next; 1650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp num_segs--; 1660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_link_segments(xhci, prev, ring->first_seg, link_trbs); 1680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (link_trbs) { 1700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* See section 4.9.2.1 and 6.4.4.1 */ 1710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp prev->trbs[TRBS_PER_SEGMENT-1].link.control |= (LINK_TOGGLE); 1720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote link toggle flag to" 173700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman " segment %p (virtual), 0x%llx (DMA)\n", 174700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman prev, (unsigned long long)prev->dma); 1750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 1760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* The ring is empty, so the enqueue pointer == dequeue pointer */ 1770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->enqueue = ring->first_seg->trbs; 1787f84eef0dafb1d318263d8b71c38700aaf2d530dSarah Sharp ring->enq_seg = ring->first_seg; 1790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->dequeue = ring->enqueue; 1807f84eef0dafb1d318263d8b71c38700aaf2d530dSarah Sharp ring->deq_seg = ring->first_seg; 1810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* The ring is initialized to 0. The producer must write 1 to the cycle 1820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * bit to handover ownership of the TRB, so PCS = 1. The consumer must 1830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * compare CCS to the cycle bit to check ownership, so CCS = 1. 1840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 1850ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp ring->cycle_state = 1; 1860ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return ring; 1880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 1890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharpfail: 1900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, ring); 1910ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp return 0; 1920ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp} 1930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 194d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn#define CTX_SIZE(_hcc) (HCC_64BYTE_CONTEXT(_hcc) ? 64 : 32) 195d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 196d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_container_ctx *xhci_alloc_container_ctx(struct xhci_hcd *xhci, 197d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn int type, gfp_t flags) 198d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 199d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx = kzalloc(sizeof(*ctx), flags); 200d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (!ctx) 201d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return NULL; 202d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 203d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn BUG_ON((type != XHCI_CTX_TYPE_DEVICE) && (type != XHCI_CTX_TYPE_INPUT)); 204d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->type = type; 205d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->size = HCC_64BYTE_CONTEXT(xhci->hcc_params) ? 2048 : 1024; 206d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (type == XHCI_CTX_TYPE_INPUT) 207d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->size += CTX_SIZE(xhci->hcc_params); 208d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 209d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctx->bytes = dma_pool_alloc(xhci->device_pool, flags, &ctx->dma); 210d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn memset(ctx->bytes, 0, ctx->size); 211d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return ctx; 212d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 213d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 214d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younvoid xhci_free_container_ctx(struct xhci_hcd *xhci, 215d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 216d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 217d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dma_pool_free(xhci->device_pool, ctx->bytes, ctx->dma); 218d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn kfree(ctx); 219d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 220d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 221d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci, 222d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 223d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 224d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn BUG_ON(ctx->type != XHCI_CTX_TYPE_INPUT); 225d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_input_control_ctx *)ctx->bytes; 226d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 227d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 228d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, 229d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx) 230d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 231d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (ctx->type == XHCI_CTX_TYPE_DEVICE) 232d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_slot_ctx *)ctx->bytes; 233d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 234d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_slot_ctx *) 235d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (ctx->bytes + CTX_SIZE(xhci->hcc_params)); 236d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 237d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 238d115b04818e57bdbc7ccde4d0660b15e33013dc8John Younstruct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci, 239d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_container_ctx *ctx, 240d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn unsigned int ep_index) 241d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn{ 242d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn /* increment ep index by offset of start of ep ctx array */ 243d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_index++; 244d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn if (ctx->type == XHCI_CTX_TYPE_INPUT) 245d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_index++; 246d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 247d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn return (struct xhci_ep_ctx *) 248d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (ctx->bytes + (ep_index * CTX_SIZE(xhci->hcc_params))); 249d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn} 250d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 251d0e96f5a71a032ced0c35f521c1cbd67e816922aSarah Sharp/* All the xhci_tds in the ring's TD list should be freed at this point */ 2523ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpvoid xhci_free_virt_device(struct xhci_hcd *xhci, int slot_id) 2533ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 2543ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 2553ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 2563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2573ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 2583ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || !xhci->devs[slot_id]) 2593ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 2603ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 2628e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci->dcbaa->dev_context_ptrs[slot_id] = 0; 2633ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev) 2643ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return; 2653ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 0; i < 31; ++i) 26763a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp if (dev->eps[i].ring) 26863a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp xhci_ring_free(xhci, dev->eps[i].ring); 2693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->in_ctx) 271d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci_free_container_ctx(xhci, dev->in_ctx); 2723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (dev->out_ctx) 273d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci_free_container_ctx(xhci, dev->out_ctx); 274d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 2753ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp kfree(xhci->devs[slot_id]); 2763ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[slot_id] = 0; 2773ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 2783ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2793ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, 2803ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct usb_device *udev, gfp_t flags) 2813ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 2823ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 28363a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp int i; 2843ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2853ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 2863ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (slot_id == 0 || xhci->devs[slot_id]) { 2873ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Bad Slot ID %d\n", slot_id); 2883ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 2893ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 2903ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 2913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[slot_id] = kzalloc(sizeof(*xhci->devs[slot_id]), flags); 2923ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->devs[slot_id]) 2933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 2943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[slot_id]; 2953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 296d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn /* Allocate the (output) device context that will be used in the HC. */ 297d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dev->out_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_DEVICE, flags); 2983ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->out_ctx) 2993ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 300d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 301700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Slot %d output ctx = 0x%llx (dma)\n", slot_id, 302d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (unsigned long long)dev->out_ctx->dma); 3033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3043ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate the (input) device context for address device command */ 305d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn dev->in_ctx = xhci_alloc_container_ctx(xhci, XHCI_CTX_TYPE_INPUT, flags); 3063ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!dev->in_ctx) 3073ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 308d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 309700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Slot %d input ctx = 0x%llx (dma)\n", slot_id, 310d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn (unsigned long long)dev->in_ctx->dma); 3113ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 31263a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp /* Initialize the cancellation list for each endpoint */ 31363a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp for (i = 0; i < 31; i++) 31463a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp INIT_LIST_HEAD(&dev->eps[i].cancelled_td_list); 31563a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp 3163ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Allocate endpoint 0 ring */ 31763a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp dev->eps[0].ring = xhci_ring_alloc(xhci, 1, true, flags); 31863a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp if (!dev->eps[0].ring) 3193ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp goto fail; 3203ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 321f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp init_completion(&dev->cmd_completion); 322f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 32328c2d2efb48dec2f0b050affae6d5787d6449e47Sarah Sharp /* Point to output device context in dcbaa. */ 324d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn xhci->dcbaa->dev_context_ptrs[slot_id] = dev->out_ctx->dma; 325700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n", 3263ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp slot_id, 3278e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp &xhci->dcbaa->dev_context_ptrs[slot_id], 32828c2d2efb48dec2f0b050affae6d5787d6449e47Sarah Sharp (unsigned long long) xhci->dcbaa->dev_context_ptrs[slot_id]); 3293ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3303ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 1; 3313ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpfail: 3323ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, slot_id); 3333ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 3343ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 3353ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3363ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp/* Setup an xHCI virtual device for a Set Address command */ 3373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharpint xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *udev) 3383ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp{ 3393ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_virt_device *dev; 3403ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct xhci_ep_ctx *ep0_ctx; 3413ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp struct usb_device *top_dev; 342d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_slot_ctx *slot_ctx; 343d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn struct xhci_input_control_ctx *ctrl_ctx; 3443ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3453ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dev = xhci->devs[udev->slot_id]; 3463ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Slot ID 0 is reserved */ 3473ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (udev->slot_id == 0 || !dev) { 3483ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_warn(xhci, "Slot ID %d is not assigned to this device\n", 3493ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp udev->slot_id); 3503ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 3513ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 352d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep0_ctx = xhci_get_ep_ctx(xhci, dev->in_ctx, 0); 353d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctrl_ctx = xhci_get_input_control_ctx(xhci, dev->in_ctx); 354d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx = xhci_get_slot_ctx(xhci, dev->in_ctx); 3553ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3563ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 2) New slot context and endpoint 0 context are valid*/ 357d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ctrl_ctx->add_flags = SLOT_FLAG | EP0_FLAG; 3583ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3593ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 3) Only the control endpoint is valid - one endpoint context */ 360d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= LAST_CTX(1); 3613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3623ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp switch (udev->speed) { 3633ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_SUPER: 364d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) udev->route; 365d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_SS; 3663ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3673ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_HIGH: 368d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_HS; 3693ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_FULL: 371d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_FS; 3723ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3733ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_LOW: 374d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info |= (u32) SLOT_SPEED_LS; 3753ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3763ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp case USB_SPEED_VARIABLE: 3773ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); 3783ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return -EINVAL; 3793ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp break; 3803ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp default: 3813ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Speed was set earlier, this shouldn't happen. */ 3823ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp BUG(); 3833ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 3843ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Find the root hub port this device is under */ 3853ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (top_dev = udev; top_dev->parent && top_dev->parent->parent; 3863ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp top_dev = top_dev->parent) 3873ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Found device below root hub */; 388d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->dev_info2 |= (u32) ROOT_HUB_PORT(top_dev->portnum); 3893ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Set root hub portnum to %d\n", top_dev->portnum); 3903ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 3913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Is this a LS/FS device under a HS hub? */ 3923ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 3933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * FIXME: I don't think this is right, where does the TT info for the 3943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * roothub or parent hub come from? 3953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp */ 3963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if ((udev->speed == USB_SPEED_LOW || udev->speed == USB_SPEED_FULL) && 3973ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp udev->tt) { 398d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->tt_info = udev->tt->hub->slot_id; 399d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn slot_ctx->tt_info |= udev->ttport << 8; 4003ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp } 401700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "udev->tt = %p\n", udev->tt); 4023ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "udev->ttport = 0x%x\n", udev->ttport); 4033ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 4043ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 4 - ring already allocated */ 4053ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Step 5 */ 4063ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 = EP_TYPE(CTRL_EP); 4073ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* 4083ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp * XXX: Not sure about wireless USB devices. 4093ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp */ 41047aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp switch (udev->speed) { 41147aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_SUPER: 4123ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(512); 41347aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 41447aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_HIGH: 41547aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp /* USB core guesses at a 64-byte max packet first for FS devices */ 41647aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_FULL: 41747aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(64); 41847aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 41947aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_LOW: 4203ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_PACKET(8); 42147aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 42247aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp case USB_SPEED_VARIABLE: 42347aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n"); 42447aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp return -EINVAL; 42547aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp break; 42647aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp default: 42747aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp /* New speed? */ 42847aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp BUG(); 42947aded8ade9fee6779b121b2b156235f261239d7Sarah Sharp } 4303ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* EP 0 can handle "burst" sizes of 1, so Max Burst Size field is 0 */ 4313ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= MAX_BURST(0); 4323ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp ep0_ctx->ep_info2 |= ERROR_COUNT(3); 4333ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 4348e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp ep0_ctx->deq = 43563a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp dev->eps[0].ring->first_seg->dma; 43663a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp ep0_ctx->deq |= dev->eps[0].ring->cycle_state; 4373ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 4383ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* Steps 7 and 8 were done in xhci_alloc_virt_device() */ 4393ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 4403ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp return 0; 4413ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp} 4423ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 443f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp/* Return the polling or NAK interval. 444f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 445f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The polling interval is expressed in "microframes". If xHCI's Interval field 446f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to N, it will service the endpoint every 2^(Interval)*125us. 447f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * 448f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * The NAK interval is one NAK per 1 to 255 microframes, or no NAKs if interval 449f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * is set to 0. 450f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 451f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpstatic inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev, 452f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 453f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 454f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int interval = 0; 455f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 456f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 457f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 458f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Max NAK rate */ 459f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc) || 460f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_bulk(&ep->desc)) 461f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = ep->desc.bInterval; 462f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through - SS and HS isoc/int have same decoding */ 463f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 464f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 465f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_isoc(&ep->desc)) { 466f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (ep->desc.bInterval == 0) 467f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 0; 468f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 469f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = ep->desc.bInterval - 1; 470f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval > 15) 471f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 15; 472f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval != ep->desc.bInterval + 1) 473f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n", 474f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep->desc.bEndpointAddress, 1 << interval); 475f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 476f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 477f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Convert bInterval (in 1-255 frames) to microframes and round down to 478f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * nearest power of 2. 479f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 480f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 481f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 482f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_int(&ep->desc) || 483f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_isoc(&ep->desc)) { 484f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = fls(8*ep->desc.bInterval) - 1; 485f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval > 10) 486f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 10; 487f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (interval < 3) 488f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp interval = 3; 489f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if ((1 << interval) != 8*ep->desc.bInterval) 490f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp dev_warn(&udev->dev, "ep %#x - rounding interval to %d microframes\n", 491f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep->desc.bEndpointAddress, 1 << interval); 492f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 493f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 494f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 495f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 496f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 497f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return EP_INTERVAL(interval); 498f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 499f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 500f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpstatic inline u32 xhci_get_endpoint_type(struct usb_device *udev, 501f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 502f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 503f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp int in; 504f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp u32 type; 505f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 506f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp in = usb_endpoint_dir_in(&ep->desc); 507f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_control(&ep->desc)) { 508f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(CTRL_EP); 509f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_bulk(&ep->desc)) { 510f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 511f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_IN_EP); 512f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 513f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(BULK_OUT_EP); 514f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_isoc(&ep->desc)) { 515f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 516f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_IN_EP); 517f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 518f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(ISOC_OUT_EP); 519f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else if (usb_endpoint_xfer_int(&ep->desc)) { 520f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (in) 521f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_IN_EP); 522f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 523f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp type = EP_TYPE(INT_OUT_EP); 524f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } else { 525f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 526f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 527f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return type; 528f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 529f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 530f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpint xhci_endpoint_init(struct xhci_hcd *xhci, 531f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 532f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_device *udev, 533f88ba78d9ac0e1f583da4cada80b8816ca761a3fSarah Sharp struct usb_host_endpoint *ep, 534f88ba78d9ac0e1f583da4cada80b8816ca761a3fSarah Sharp gfp_t mem_flags) 535f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 536f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 537f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 538f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ring *ep_ring; 539f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_packet; 540f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int max_burst; 541f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 542f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 543d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); 544f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 545f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set up the endpoint ring */ 54663a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp virt_dev->eps[ep_index].new_ring = 54763a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp xhci_ring_alloc(xhci, 1, true, mem_flags); 54863a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp if (!virt_dev->eps[ep_index].new_ring) 549f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return -ENOMEM; 55063a0d9abd18cdcf5a985029c266c6bfe0511768fSarah Sharp ep_ring = virt_dev->eps[ep_index].new_ring; 5518e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp ep_ctx->deq = ep_ring->first_seg->dma | ep_ring->cycle_state; 552f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 553f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info = xhci_get_endpoint_interval(udev, ep); 554f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 555f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME dig Mult and streams info out of ep companion desc */ 556f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 55747692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp /* Allow 3 retries for everything but isoc; 55847692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp * error count = 0 means infinite retries. 55947692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp */ 560f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (!usb_endpoint_xfer_isoc(&ep->desc)) 561f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = ERROR_COUNT(3); 562f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp else 56347692d179f7a88794bcd302e53ca7899d7592db9Sarah Sharp ep_ctx->ep_info2 = ERROR_COUNT(1); 564f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 565f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= xhci_get_endpoint_type(udev, ep); 566f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 567f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Set the max packet size and max burst */ 568f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp switch (udev->speed) { 569f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_SUPER: 570f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_packet = ep->desc.wMaxPacketSize; 571f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_PACKET(max_packet); 572b10de142119a676552df3f0d2e3a9d647036c26aSarah Sharp /* dig out max burst from ep companion desc */ 573b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp if (!ep->ss_ep_comp) { 574b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp xhci_warn(xhci, "WARN no SS endpoint companion descriptor.\n"); 575b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp max_packet = 0; 576b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp } else { 577b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp max_packet = ep->ss_ep_comp->desc.bMaxBurst; 578b7d6d99896a6cf38dc354d673afd3fbde10b86c2Sarah Sharp } 579b10de142119a676552df3f0d2e3a9d647036c26aSarah Sharp ep_ctx->ep_info2 |= MAX_BURST(max_packet); 580f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 581f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_HIGH: 582f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* bits 11:12 specify the number of additional transaction 583f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * opportunities per microframe (USB 2.0, section 9.6.6) 584f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 585f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp if (usb_endpoint_xfer_isoc(&ep->desc) || 586f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp usb_endpoint_xfer_int(&ep->desc)) { 587f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_burst = (ep->desc.wMaxPacketSize & 0x1800) >> 11; 588f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_BURST(max_burst); 589f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 590f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Fall through */ 591f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_FULL: 592f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp case USB_SPEED_LOW: 593f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp max_packet = ep->desc.wMaxPacketSize & 0x3ff; 594f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 |= MAX_PACKET(max_packet); 595f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp break; 596f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp default: 597f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp BUG(); 598f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp } 599f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* FIXME Debug endpoint context */ 600f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp return 0; 601f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 602f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 603f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharpvoid xhci_endpoint_zero(struct xhci_hcd *xhci, 604f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_virt_device *virt_dev, 605f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct usb_host_endpoint *ep) 606f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp{ 607f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp unsigned int ep_index; 608f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp struct xhci_ep_ctx *ep_ctx; 609f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 610f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_index = xhci_get_endpoint_index(&ep->desc); 611d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); 612f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 613f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info = 0; 614f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->ep_info2 = 0; 6158e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp ep_ctx->deq = 0; 616f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp ep_ctx->tx_info = 0; 617f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp /* Don't free the endpoint ring until the set interface or configuration 618f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp * request succeeds. 619f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp */ 620f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp} 621f94e0186312b0fc39f41eed4e21836ed74b7efe1Sarah Sharp 622f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp/* Copy output xhci_ep_ctx to the input xhci_ep_ctx copy. 623f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * Useful when you want to change one particular aspect of the endpoint and then 624f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * issue a configure endpoint command. 625f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp */ 626f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharpvoid xhci_endpoint_copy(struct xhci_hcd *xhci, 627f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_virt_device *vdev, unsigned int ep_index) 628f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp{ 629f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_ep_ctx *out_ep_ctx; 630f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_ep_ctx *in_ep_ctx; 631f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 632f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp out_ep_ctx = xhci_get_ep_ctx(xhci, vdev->out_ctx, ep_index); 633f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx = xhci_get_ep_ctx(xhci, vdev->in_ctx, ep_index); 634f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 635f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->ep_info = out_ep_ctx->ep_info; 636f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->ep_info2 = out_ep_ctx->ep_info2; 637f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->deq = out_ep_ctx->deq; 638f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_ep_ctx->tx_info = out_ep_ctx->tx_info; 639f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp} 640f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 641f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp/* Copy output xhci_slot_ctx to the input xhci_slot_ctx. 642f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * Useful when you want to change one particular aspect of the endpoint and then 643f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * issue a configure endpoint command. Only the context entries field matters, 644f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp * but we'll copy the whole thing anyway. 645f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp */ 646f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharpvoid xhci_slot_copy(struct xhci_hcd *xhci, struct xhci_virt_device *vdev) 647f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp{ 648f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_slot_ctx *in_slot_ctx; 649f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp struct xhci_slot_ctx *out_slot_ctx; 650f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 651f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx = xhci_get_slot_ctx(xhci, vdev->in_ctx); 652f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp out_slot_ctx = xhci_get_slot_ctx(xhci, vdev->out_ctx); 653f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 654f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_info = out_slot_ctx->dev_info; 655f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_info2 = out_slot_ctx->dev_info2; 656f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->tt_info = out_slot_ctx->tt_info; 657f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp in_slot_ctx->dev_state = out_slot_ctx->dev_state; 658f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp} 659f2217e8edd95b0428d8123d426e0097a5e955f9fSarah Sharp 660254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn/* Set up the scratchpad buffer array and scratchpad buffers, if needed. */ 661254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Younstatic int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags) 662254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn{ 663254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int i; 664254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn struct device *dev = xhci_to_hcd(xhci)->self.controller; 665254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2); 666254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 667254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci_dbg(xhci, "Allocating %d scratchpad buffers\n", num_sp); 668254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 669254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!num_sp) 670254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return 0; 671254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 672254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = kzalloc(sizeof(*xhci->scratchpad), flags); 673254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad) 674254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp; 675254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 676254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array = 677254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_alloc_consistent(to_pci_dev(dev), 678254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn num_sp * sizeof(u64), 679254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn &xhci->scratchpad->sp_dma); 680254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_array) 681254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp2; 682254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 683254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers = kzalloc(sizeof(void *) * num_sp, flags); 684254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_buffers) 685254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp3; 686254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 687254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers = 688254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kzalloc(sizeof(dma_addr_t) * num_sp, flags); 689254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 690254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad->sp_dma_buffers) 691254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp4; 692254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 693254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->dcbaa->dev_context_ptrs[0] = xhci->scratchpad->sp_dma; 694254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = 0; i < num_sp; i++) { 695254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn dma_addr_t dma; 696254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn void *buf = pci_alloc_consistent(to_pci_dev(dev), 697254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->page_size, &dma); 698254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!buf) 699254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail_sp5; 700254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 701254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array[i] = dma; 702254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i] = buf; 703254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i] = dma; 704254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 705254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 706254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return 0; 707254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 708254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp5: 709254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = i - 1; i >= 0; i--) { 710254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(to_pci_dev(dev), xhci->page_size, 711254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i], 712254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i]); 713254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 714254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_dma_buffers); 715254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 716254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp4: 717254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_buffers); 718254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 719254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp3: 720254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(to_pci_dev(dev), num_sp * sizeof(u64), 721254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array, 722254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma); 723254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 724254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp2: 725254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad); 726254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = NULL; 727254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 728254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn fail_sp: 729254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return -ENOMEM; 730254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn} 731254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 732254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Younstatic void scratchpad_free(struct xhci_hcd *xhci) 733254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn{ 734254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int num_sp; 735254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn int i; 736254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 737254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 738254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (!xhci->scratchpad) 739254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn return; 740254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 741254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2); 742254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 743254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn for (i = 0; i < num_sp; i++) { 744254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(pdev, xhci->page_size, 745254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_buffers[i], 746254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma_buffers[i]); 747254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn } 748254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_dma_buffers); 749254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad->sp_buffers); 750254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn pci_free_consistent(pdev, num_sp * sizeof(u64), 751254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_array, 752254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad->sp_dma); 753254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn kfree(xhci->scratchpad); 754254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn xhci->scratchpad = NULL; 755254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn} 756254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 75766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpvoid xhci_mem_cleanup(struct xhci_hcd *xhci) 75866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 7590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller); 7600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp int size; 7613ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp int i; 7620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Free the Event Ring Segment Table and the actual Event Ring */ 7640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, 0, &xhci->ir_set->erst_size); 7658e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->ir_set->erst_base); 7668e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->ir_set->erst_dequeue); 7670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries); 7680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->erst.entries) 7690ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp pci_free_consistent(pdev, size, 7700ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries, xhci->erst.erst_dma_addr); 7710ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = NULL; 7720ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed ERST\n"); 7730ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->event_ring) 7740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->event_ring); 7750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = NULL; 7760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed event ring\n"); 7770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 7788e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring); 7790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->cmd_ring) 7800ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_ring_free(xhci, xhci->cmd_ring); 7810ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = NULL; 7820ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed command ring\n"); 7833ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7843ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 1; i < MAX_HC_SLOTS; ++i) 7853ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_free_virt_device(xhci, i); 7863ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7870ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (xhci->segment_pool) 7880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_pool_destroy(xhci->segment_pool); 7890ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = NULL; 7900ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Freed segment pool\n"); 7913ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7923ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (xhci->device_pool) 7933ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp dma_pool_destroy(xhci->device_pool); 7943ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = NULL; 7953ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci_dbg(xhci, "Freed device context pool\n"); 7963ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 7978e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr); 798a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (xhci->dcbaa) 799a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp pci_free_consistent(pdev, sizeof(*xhci->dcbaa), 800a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa, xhci->dcbaa->dma); 801a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = NULL; 8023ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp 80366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 0; 80466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 0; 805254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn scratchpad_free(xhci); 80666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 80766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 80866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpint xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags) 80966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp{ 8100ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp dma_addr_t dma; 8110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct device *dev = xhci_to_hcd(xhci)->self.controller; 81266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp unsigned int val, val2; 8138e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp u64 val_64; 8140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_segment *seg; 81566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp u32 page_size; 81666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp int i; 81766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 81866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = xhci_readl(xhci, &xhci->op_regs->page_size); 81966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size register = 0x%x\n", page_size); 82066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp for (i = 0; i < 16; i++) { 82166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if ((0x1 & page_size) != 0) 82266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp break; 82366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp page_size = page_size >> 1; 82466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp } 82566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp if (i < 16) 82666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "Supported page size of %iK\n", (1 << (i+12)) / 1024); 82766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp else 82866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "WARN: no supported page size\n"); 82966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* Use 4K pages, since that's common and the minimum the HC supports */ 83066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_shift = 12; 83166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci->page_size = 1 << xhci->page_shift; 83266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "HCD page size set to %iK\n", xhci->page_size / 1024); 83366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 83466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp /* 83566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * Program the Number of Device Slots Enabled field in the CONFIG 83666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp * register with the max value of slots the HC can handle. 83766d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp */ 83866d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val = HCS_MAX_SLOTS(xhci_readl(xhci, &xhci->cap_regs->hcs_params1)); 83966d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// xHC can handle at most %d device slots.\n", 84066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 84166d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val2 = xhci_readl(xhci, &xhci->op_regs->config_reg); 84266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp val |= (val2 & ~HCS_SLOTS_MASK); 84366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_dbg(xhci, "// Setting Max device slots reg = 0x%x.\n", 84466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp (unsigned int) val); 84566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_writel(xhci, val, &xhci->op_regs->config_reg); 84666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 8470ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 848a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * Section 5.4.8 - doorbell array must be 849a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp * "physically contiguous and 64-byte (cache line) aligned". 850a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp */ 851a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa = pci_alloc_consistent(to_pci_dev(dev), 852a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp sizeof(*xhci->dcbaa), &dma); 853a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp if (!xhci->dcbaa) 854a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp goto fail; 855a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp memset(xhci->dcbaa, 0, sizeof *(xhci->dcbaa)); 856a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp xhci->dcbaa->dma = dma; 857700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Device context base array address = 0x%llx (DMA), %p (virt)\n", 858700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->dcbaa->dma, xhci->dcbaa); 8598e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr); 860a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp 861a74588f94655263b96dacbbf14aac0958d8b7409Sarah Sharp /* 8620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Initialize the ring segment pool. The ring must be a contiguous 8630ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * structure comprised of TRBs. The TRBs must be 16 byte aligned, 8640ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * however, the command ring segment needs 64-byte aligned segments, 8650ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * so we pick the greater alignment need. 8660ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 8670ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->segment_pool = dma_pool_create("xHCI ring segments", dev, 8680ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp SEGMENT_SIZE, 64, xhci->page_size); 869d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 8703ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp /* See Table 46 and Note on Figure 55 */ 8713ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->device_pool = dma_pool_create("xHCI input/output contexts", dev, 872d115b04818e57bdbc7ccde4d0660b15e33013dc8John Youn 2112, 64, xhci->page_size); 8733ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp if (!xhci->segment_pool || !xhci->device_pool) 8740ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 8750ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 8760ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set up the command ring to have one segments for now. */ 8770ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring = xhci_ring_alloc(xhci, 1, true, flags); 8780ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->cmd_ring) 8790ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 880700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring); 881700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "First segment DMA is 0x%llx\n", 882700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->cmd_ring->first_seg->dma); 8830ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 8840ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the address in the Command Ring Control register */ 8858e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring); 8868e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) | 8878e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp (xhci->cmd_ring->first_seg->dma & (u64) ~CMD_RING_RSVD_BITS) | 8880ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->cmd_ring->cycle_state; 8898e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_dbg(xhci, "// Setting command ring address to 0x%x\n", val); 8908e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring); 8910ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_cmd_ptrs(xhci); 8920ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 8930ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->cap_regs->db_off); 8940ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= DBOFF_MASK; 8950ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Doorbell array is located at offset 0x%x" 8960ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp " from cap regs base addr\n", val); 8970ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->dba = (void *) xhci->cap_regs + val; 8980ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg_regs(xhci); 8990ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_print_run_regs(xhci); 9000ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set ir_set to interrupt register set 0 */ 9010ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->ir_set = (void *) xhci->run_regs->ir_set; 9020ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9030ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 9040ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * Event ring setup: Allocate a normal ring, but also setup 9050ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * the event ring segment table (ERST). Section 4.9.3. 9060ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 9070ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Allocating event ring\n"); 9080ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->event_ring = xhci_ring_alloc(xhci, ERST_NUM_SEGS, false, flags); 9090ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->event_ring) 9100ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 9110ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9120ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.entries = pci_alloc_consistent(to_pci_dev(dev), 9130ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS, &dma); 9140ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp if (!xhci->erst.entries) 9150ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp goto fail; 916700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Allocated event ring segment table at 0x%llx\n", 917700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)dma); 9180ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9190ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp memset(xhci->erst.entries, 0, sizeof(struct xhci_erst_entry)*ERST_NUM_SEGS); 9200ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries = ERST_NUM_SEGS; 9210ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.erst_dma_addr = dma; 922700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "Set ERST to 0; private num segs = %i, virt addr = %p, dma addr = 0x%llx\n", 9230ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci->erst.num_entries, 924700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci->erst.entries, 925700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->erst.erst_dma_addr); 9260ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9270ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ring base address and size for each segment table entry */ 9280ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp for (val = 0, seg = xhci->event_ring->first_seg; val < ERST_NUM_SEGS; val++) { 9290ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp struct xhci_erst_entry *entry = &xhci->erst.entries[val]; 9308e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp entry->seg_addr = seg->dma; 9310ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->seg_size = TRBS_PER_SEGMENT; 9320ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp entry->rsvd = 0; 9330ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp seg = seg->next; 9340ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp } 9350ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9360ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set ERST count with the number of entries in the segment table */ 9370ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val = xhci_readl(xhci, &xhci->ir_set->erst_size); 9380ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val &= ERST_SIZE_MASK; 9390ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val |= ERST_NUM_SEGS; 9400ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Write ERST size = %i to ir_set 0 (some bits preserved)\n", 9410ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp val); 9420ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_writel(xhci, val, &xhci->ir_set->erst_size); 9430ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9440ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "// Set ERST entries to point to event ring.\n"); 9450ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* set the segment table base address */ 946700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman xhci_dbg(xhci, "// Set ERST base address for ir_set 0 = 0x%llx\n", 947700e2052c6814b1b1d2714225d568c5c64bc49aeGreg Kroah-Hartman (unsigned long long)xhci->erst.erst_dma_addr); 9488e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 = xhci_read_64(xhci, &xhci->ir_set->erst_base); 9498e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 &= ERST_PTR_MASK; 9508e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp val_64 |= (xhci->erst.erst_dma_addr & (u64) ~ERST_PTR_MASK); 9518e595a5d30a5ee4bb745d4da6439d73ed7d91054Sarah Sharp xhci_write_64(xhci, val_64, &xhci->ir_set->erst_base); 9520ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9530ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* Set the event ring dequeue address */ 95423e3be113f42790736319c049c78e5f9a4394c02Sarah Sharp xhci_set_hc_event_deq(xhci); 9550ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_dbg(xhci, "Wrote ERST address to ir_set 0.\n"); 9560ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp xhci_print_ir_set(xhci, xhci->ir_set, 0); 9570ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp 9580ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp /* 9590ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * XXX: Might need to set the Interrupter Moderation Register to 9600ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * something other than the default (~1ms minimum between interrupts). 9610ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp * See section 5.5.1.2. 9620ebbab37422315a5d0cb29792271085bafdf38c0Sarah Sharp */ 9633ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp init_completion(&xhci->addr_dev); 9643ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp for (i = 0; i < MAX_HC_SLOTS; ++i) 9653ffbba9511b4148cbe1f6b6238686adaeaca8febSarah Sharp xhci->devs[i] = 0; 96666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp 967254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn if (scratchpad_alloc(xhci, flags)) 968254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn goto fail; 969254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 97066d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return 0; 971254c80a3a0eb811489f7410c3291f01a60e8e42fJohn Youn 97266d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharpfail: 97366d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_warn(xhci, "Couldn't initialize memory\n"); 97466d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp xhci_mem_cleanup(xhci); 97566d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp return -ENOMEM; 97666d4eadd8d067269ea8fead1a50fe87c2979a80dSarah Sharp} 977