1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Cadence CDNSP DRD Driver. 4 * 5 * Copyright (C) 2020 Cadence. 6 * 7 * Author: Pawel Laszczak <pawell@cadence.com> 8 * 9 * Code based on Linux XHCI driver. 10 * Origin: Copyright (C) 2008 Intel Corp. 11 */ 12 13 #include <linux/dma-mapping.h> 14 #include <linux/dmapool.h> 15 #include <linux/slab.h> 16 #include <linux/usb.h> 17 18 #include "cdnsp-gadget.h" 19 #include "cdnsp-trace.h" 20 21 static void cdnsp_free_stream_info(struct cdnsp_device *pdev, 22 struct cdnsp_ep *pep); 23 /* 24 * Allocates a generic ring segment from the ring pool, sets the dma address, 25 * initializes the segment to zero, and sets the private next pointer to NULL. 26 * 27 * "All components of all Command and Transfer TRBs shall be initialized to '0'" 28 */ 29 static struct cdnsp_segment *cdnsp_segment_alloc(struct cdnsp_device *pdev, 30 unsigned int cycle_state, 31 unsigned int max_packet, 32 gfp_t flags) 33 { 34 struct cdnsp_segment *seg; 35 dma_addr_t dma; 36 int i; 37 38 seg = kzalloc_obj(*seg, flags); 39 if (!seg) 40 return NULL; 41 42 seg->trbs = dma_pool_zalloc(pdev->segment_pool, flags, &dma); 43 if (!seg->trbs) { 44 kfree(seg); 45 return NULL; 46 } 47 48 if (max_packet) { 49 seg->bounce_buf = kzalloc(max_packet, flags | GFP_DMA); 50 if (!seg->bounce_buf) 51 goto free_dma; 52 } 53 54 /* If the cycle state is 0, set the cycle bit to 1 for all the TRBs. */ 55 if (cycle_state == 0) { 56 for (i = 0; i < TRBS_PER_SEGMENT; i++) 57 seg->trbs[i].link.control |= cpu_to_le32(TRB_CYCLE); 58 } 59 seg->dma = dma; 60 seg->next = NULL; 61 62 return seg; 63 64 free_dma: 65 dma_pool_free(pdev->segment_pool, seg->trbs, dma); 66 kfree(seg); 67 68 return NULL; 69 } 70 71 static void cdnsp_segment_free(struct cdnsp_device *pdev, 72 struct cdnsp_segment *seg) 73 { 74 if (seg->trbs) 75 dma_pool_free(pdev->segment_pool, seg->trbs, seg->dma); 76 77 kfree(seg->bounce_buf); 78 kfree(seg); 79 } 80 81 static void cdnsp_free_segments_for_ring(struct cdnsp_device *pdev, 82 struct cdnsp_segment *first) 83 { 84 struct cdnsp_segment *seg; 85 86 seg = first->next; 87 88 while (seg != first) { 89 struct cdnsp_segment *next = seg->next; 90 91 cdnsp_segment_free(pdev, seg); 92 seg = next; 93 } 94 95 cdnsp_segment_free(pdev, first); 96 } 97 98 /* 99 * Make the prev segment point to the next segment. 100 * 101 * Change the last TRB in the prev segment to be a Link TRB which points to the 102 * DMA address of the next segment. The caller needs to set any Link TRB 103 * related flags, such as End TRB, Toggle Cycle, and no snoop. 104 */ 105 static void cdnsp_link_segments(struct cdnsp_device *pdev, 106 struct cdnsp_segment *prev, 107 struct cdnsp_segment *next, 108 enum cdnsp_ring_type type) 109 { 110 struct cdnsp_link_trb *link; 111 u32 val; 112 113 if (!prev || !next) 114 return; 115 116 prev->next = next; 117 if (type != TYPE_EVENT) { 118 link = &prev->trbs[TRBS_PER_SEGMENT - 1].link; 119 link->segment_ptr = cpu_to_le64(next->dma); 120 121 /* 122 * Set the last TRB in the segment to have a TRB type ID 123 * of Link TRB 124 */ 125 val = le32_to_cpu(link->control); 126 val &= ~TRB_TYPE_BITMASK; 127 val |= TRB_TYPE(TRB_LINK); 128 link->control = cpu_to_le32(val); 129 } 130 } 131 132 /* 133 * Link the ring to the new segments. 134 * Set Toggle Cycle for the new ring if needed. 135 */ 136 static void cdnsp_link_rings(struct cdnsp_device *pdev, 137 struct cdnsp_ring *ring, 138 struct cdnsp_segment *first, 139 struct cdnsp_segment *last, 140 unsigned int num_segs) 141 { 142 struct cdnsp_segment *next; 143 144 if (!ring || !first || !last) 145 return; 146 147 next = ring->enq_seg->next; 148 cdnsp_link_segments(pdev, ring->enq_seg, first, ring->type); 149 cdnsp_link_segments(pdev, last, next, ring->type); 150 ring->num_segs += num_segs; 151 ring->num_trbs_free += (TRBS_PER_SEGMENT - 1) * num_segs; 152 153 if (ring->type != TYPE_EVENT && ring->enq_seg == ring->last_seg) { 154 ring->last_seg->trbs[TRBS_PER_SEGMENT - 1].link.control &= 155 ~cpu_to_le32(LINK_TOGGLE); 156 last->trbs[TRBS_PER_SEGMENT - 1].link.control |= 157 cpu_to_le32(LINK_TOGGLE); 158 ring->last_seg = last; 159 } 160 } 161 162 /* 163 * We need a radix tree for mapping physical addresses of TRBs to which stream 164 * ID they belong to. We need to do this because the device controller won't 165 * tell us which stream ring the TRB came from. We could store the stream ID 166 * in an event data TRB, but that doesn't help us for the cancellation case, 167 * since the endpoint may stop before it reaches that event data TRB. 168 * 169 * The radix tree maps the upper portion of the TRB DMA address to a ring 170 * segment that has the same upper portion of DMA addresses. For example, 171 * say I have segments of size 1KB, that are always 1KB aligned. A segment may 172 * start at 0x10c91000 and end at 0x10c913f0. If I use the upper 10 bits, the 173 * key to the stream ID is 0x43244. I can use the DMA address of the TRB to 174 * pass the radix tree a key to get the right stream ID: 175 * 176 * 0x10c90fff >> 10 = 0x43243 177 * 0x10c912c0 >> 10 = 0x43244 178 * 0x10c91400 >> 10 = 0x43245 179 * 180 * Obviously, only those TRBs with DMA addresses that are within the segment 181 * will make the radix tree return the stream ID for that ring. 182 * 183 * Caveats for the radix tree: 184 * 185 * The radix tree uses an unsigned long as a key pair. On 32-bit systems, an 186 * unsigned long will be 32-bits; on a 64-bit system an unsigned long will be 187 * 64-bits. Since we only request 32-bit DMA addresses, we can use that as the 188 * key on 32-bit or 64-bit systems (it would also be fine if we asked for 64-bit 189 * PCI DMA addresses on a 64-bit system). There might be a problem on 32-bit 190 * extended systems (where the DMA address can be bigger than 32-bits), 191 * if we allow the PCI dma mask to be bigger than 32-bits. So don't do that. 192 */ 193 static int cdnsp_insert_segment_mapping(struct radix_tree_root *trb_address_map, 194 struct cdnsp_ring *ring, 195 struct cdnsp_segment *seg, 196 gfp_t mem_flags) 197 { 198 unsigned long key; 199 int ret; 200 201 key = (unsigned long)(seg->dma >> TRB_SEGMENT_SHIFT); 202 203 /* Skip any segments that were already added. */ 204 if (radix_tree_lookup(trb_address_map, key)) 205 return 0; 206 207 ret = radix_tree_maybe_preload(mem_flags); 208 if (ret) 209 return ret; 210 211 ret = radix_tree_insert(trb_address_map, key, ring); 212 radix_tree_preload_end(); 213 214 return ret; 215 } 216 217 static void cdnsp_remove_segment_mapping(struct radix_tree_root *trb_address_map, 218 struct cdnsp_segment *seg) 219 { 220 unsigned long key; 221 222 key = (unsigned long)(seg->dma >> TRB_SEGMENT_SHIFT); 223 if (radix_tree_lookup(trb_address_map, key)) 224 radix_tree_delete(trb_address_map, key); 225 } 226 227 static int cdnsp_update_stream_segment_mapping(struct radix_tree_root *trb_address_map, 228 struct cdnsp_ring *ring, 229 struct cdnsp_segment *first_seg, 230 struct cdnsp_segment *last_seg, 231 gfp_t mem_flags) 232 { 233 struct cdnsp_segment *failed_seg; 234 struct cdnsp_segment *seg; 235 int ret; 236 237 seg = first_seg; 238 do { 239 ret = cdnsp_insert_segment_mapping(trb_address_map, ring, seg, 240 mem_flags); 241 if (ret) 242 goto remove_streams; 243 if (seg == last_seg) 244 return 0; 245 seg = seg->next; 246 } while (seg != first_seg); 247 248 return 0; 249 250 remove_streams: 251 failed_seg = seg; 252 seg = first_seg; 253 do { 254 cdnsp_remove_segment_mapping(trb_address_map, seg); 255 if (seg == failed_seg) 256 return ret; 257 seg = seg->next; 258 } while (seg != first_seg); 259 260 return ret; 261 } 262 263 static void cdnsp_remove_stream_mapping(struct cdnsp_ring *ring) 264 { 265 struct cdnsp_segment *seg; 266 267 seg = ring->first_seg; 268 do { 269 cdnsp_remove_segment_mapping(ring->trb_address_map, seg); 270 seg = seg->next; 271 } while (seg != ring->first_seg); 272 } 273 274 static int cdnsp_update_stream_mapping(struct cdnsp_ring *ring) 275 { 276 return cdnsp_update_stream_segment_mapping(ring->trb_address_map, ring, 277 ring->first_seg, ring->last_seg, GFP_ATOMIC); 278 } 279 280 static void cdnsp_ring_free(struct cdnsp_device *pdev, struct cdnsp_ring *ring) 281 { 282 if (!ring) 283 return; 284 285 trace_cdnsp_ring_free(ring); 286 287 if (ring->first_seg) { 288 if (ring->type == TYPE_STREAM) 289 cdnsp_remove_stream_mapping(ring); 290 291 cdnsp_free_segments_for_ring(pdev, ring->first_seg); 292 } 293 294 kfree(ring); 295 } 296 297 void cdnsp_initialize_ring_info(struct cdnsp_ring *ring) 298 { 299 ring->enqueue = ring->first_seg->trbs; 300 ring->enq_seg = ring->first_seg; 301 ring->dequeue = ring->enqueue; 302 ring->deq_seg = ring->first_seg; 303 304 /* 305 * The ring is initialized to 0. The producer must write 1 to the cycle 306 * bit to handover ownership of the TRB, so PCS = 1. The consumer must 307 * compare CCS to the cycle bit to check ownership, so CCS = 1. 308 * 309 * New rings are initialized with cycle state equal to 1; if we are 310 * handling ring expansion, set the cycle state equal to the old ring. 311 */ 312 ring->cycle_state = 1; 313 314 /* 315 * Each segment has a link TRB, and leave an extra TRB for SW 316 * accounting purpose 317 */ 318 ring->num_trbs_free = ring->num_segs * (TRBS_PER_SEGMENT - 1) - 1; 319 } 320 321 /* Allocate segments and link them for a ring. */ 322 static int cdnsp_alloc_segments_for_ring(struct cdnsp_device *pdev, 323 struct cdnsp_segment **first, 324 struct cdnsp_segment **last, 325 unsigned int num_segs, 326 unsigned int cycle_state, 327 enum cdnsp_ring_type type, 328 unsigned int max_packet, 329 gfp_t flags) 330 { 331 struct cdnsp_segment *prev; 332 333 /* Allocate first segment. */ 334 prev = cdnsp_segment_alloc(pdev, cycle_state, max_packet, flags); 335 if (!prev) 336 return -ENOMEM; 337 338 num_segs--; 339 *first = prev; 340 341 /* Allocate all other segments. */ 342 while (num_segs > 0) { 343 struct cdnsp_segment *next; 344 345 next = cdnsp_segment_alloc(pdev, cycle_state, 346 max_packet, flags); 347 if (!next) { 348 cdnsp_free_segments_for_ring(pdev, *first); 349 return -ENOMEM; 350 } 351 352 cdnsp_link_segments(pdev, prev, next, type); 353 354 prev = next; 355 num_segs--; 356 } 357 358 cdnsp_link_segments(pdev, prev, *first, type); 359 *last = prev; 360 361 return 0; 362 } 363 364 /* 365 * Create a new ring with zero or more segments. 366 * 367 * Link each segment together into a ring. 368 * Set the end flag and the cycle toggle bit on the last segment. 369 */ 370 static struct cdnsp_ring *cdnsp_ring_alloc(struct cdnsp_device *pdev, 371 unsigned int num_segs, 372 enum cdnsp_ring_type type, 373 unsigned int max_packet, 374 gfp_t flags) 375 { 376 struct cdnsp_ring *ring; 377 int ret; 378 379 ring = kzalloc_obj(*(ring), flags); 380 if (!ring) 381 return NULL; 382 383 ring->num_segs = num_segs; 384 ring->bounce_buf_len = max_packet; 385 INIT_LIST_HEAD(&ring->td_list); 386 ring->type = type; 387 388 if (num_segs == 0) 389 return ring; 390 391 ret = cdnsp_alloc_segments_for_ring(pdev, &ring->first_seg, 392 &ring->last_seg, num_segs, 393 1, type, max_packet, flags); 394 if (ret) 395 goto fail; 396 397 /* Only event ring does not use link TRB. */ 398 if (type != TYPE_EVENT) 399 ring->last_seg->trbs[TRBS_PER_SEGMENT - 1].link.control |= 400 cpu_to_le32(LINK_TOGGLE); 401 402 cdnsp_initialize_ring_info(ring); 403 trace_cdnsp_ring_alloc(ring); 404 return ring; 405 fail: 406 kfree(ring); 407 return NULL; 408 } 409 410 void cdnsp_free_endpoint_rings(struct cdnsp_device *pdev, struct cdnsp_ep *pep) 411 { 412 cdnsp_ring_free(pdev, pep->ring); 413 pep->ring = NULL; 414 cdnsp_free_stream_info(pdev, pep); 415 } 416 417 /* 418 * Expand an existing ring. 419 * Allocate a new ring which has same segment numbers and link the two rings. 420 */ 421 int cdnsp_ring_expansion(struct cdnsp_device *pdev, 422 struct cdnsp_ring *ring, 423 unsigned int num_trbs, 424 gfp_t flags) 425 { 426 unsigned int num_segs_needed; 427 struct cdnsp_segment *first; 428 struct cdnsp_segment *last; 429 unsigned int num_segs; 430 int ret; 431 432 num_segs_needed = (num_trbs + (TRBS_PER_SEGMENT - 1) - 1) / 433 (TRBS_PER_SEGMENT - 1); 434 435 /* Allocate number of segments we needed, or double the ring size. */ 436 num_segs = max(ring->num_segs, num_segs_needed); 437 438 ret = cdnsp_alloc_segments_for_ring(pdev, &first, &last, num_segs, 439 ring->cycle_state, ring->type, 440 ring->bounce_buf_len, flags); 441 if (ret) 442 return -ENOMEM; 443 444 if (ring->type == TYPE_STREAM) 445 ret = cdnsp_update_stream_segment_mapping(ring->trb_address_map, 446 ring, first, 447 last, flags); 448 449 if (ret) { 450 cdnsp_free_segments_for_ring(pdev, first); 451 452 return ret; 453 } 454 455 cdnsp_link_rings(pdev, ring, first, last, num_segs); 456 trace_cdnsp_ring_expansion(ring); 457 458 return 0; 459 } 460 461 static int cdnsp_init_device_ctx(struct cdnsp_device *pdev) 462 { 463 int size = HCC_64BYTE_CONTEXT(pdev->hcc_params) ? 2048 : 1024; 464 465 pdev->out_ctx.type = CDNSP_CTX_TYPE_DEVICE; 466 pdev->out_ctx.size = size; 467 pdev->out_ctx.ctx_size = CTX_SIZE(pdev->hcc_params); 468 pdev->out_ctx.bytes = dma_pool_zalloc(pdev->device_pool, GFP_ATOMIC, 469 &pdev->out_ctx.dma); 470 471 if (!pdev->out_ctx.bytes) 472 return -ENOMEM; 473 474 pdev->in_ctx.type = CDNSP_CTX_TYPE_INPUT; 475 pdev->in_ctx.ctx_size = pdev->out_ctx.ctx_size; 476 pdev->in_ctx.size = size + pdev->out_ctx.ctx_size; 477 pdev->in_ctx.bytes = dma_pool_zalloc(pdev->device_pool, GFP_ATOMIC, 478 &pdev->in_ctx.dma); 479 480 if (!pdev->in_ctx.bytes) { 481 dma_pool_free(pdev->device_pool, pdev->out_ctx.bytes, 482 pdev->out_ctx.dma); 483 return -ENOMEM; 484 } 485 486 return 0; 487 } 488 489 struct cdnsp_input_control_ctx 490 *cdnsp_get_input_control_ctx(struct cdnsp_container_ctx *ctx) 491 { 492 if (ctx->type != CDNSP_CTX_TYPE_INPUT) 493 return NULL; 494 495 return (struct cdnsp_input_control_ctx *)ctx->bytes; 496 } 497 498 struct cdnsp_slot_ctx *cdnsp_get_slot_ctx(struct cdnsp_container_ctx *ctx) 499 { 500 if (ctx->type == CDNSP_CTX_TYPE_DEVICE) 501 return (struct cdnsp_slot_ctx *)ctx->bytes; 502 503 return (struct cdnsp_slot_ctx *)(ctx->bytes + ctx->ctx_size); 504 } 505 506 struct cdnsp_ep_ctx *cdnsp_get_ep_ctx(struct cdnsp_container_ctx *ctx, 507 unsigned int ep_index) 508 { 509 /* Increment ep index by offset of start of ep ctx array. */ 510 ep_index++; 511 if (ctx->type == CDNSP_CTX_TYPE_INPUT) 512 ep_index++; 513 514 return (struct cdnsp_ep_ctx *)(ctx->bytes + (ep_index * ctx->ctx_size)); 515 } 516 517 static void cdnsp_free_stream_ctx(struct cdnsp_device *pdev, 518 struct cdnsp_ep *pep) 519 { 520 dma_pool_free(pdev->device_pool, pep->stream_info.stream_ctx_array, 521 pep->stream_info.ctx_array_dma); 522 } 523 524 /* The stream context array must be a power of 2. */ 525 static struct cdnsp_stream_ctx 526 *cdnsp_alloc_stream_ctx(struct cdnsp_device *pdev, struct cdnsp_ep *pep) 527 { 528 size_t size = sizeof(struct cdnsp_stream_ctx) * 529 pep->stream_info.num_stream_ctxs; 530 531 if (size > CDNSP_CTX_SIZE) 532 return NULL; 533 534 /** 535 * Driver uses intentionally the device_pool to allocated stream 536 * context array. Device Pool has 2048 bytes of size what gives us 537 * 128 entries. 538 */ 539 return dma_pool_zalloc(pdev->device_pool, GFP_DMA32 | GFP_ATOMIC, 540 &pep->stream_info.ctx_array_dma); 541 } 542 543 struct cdnsp_ring *cdnsp_dma_to_transfer_ring(struct cdnsp_ep *pep, u64 address) 544 { 545 if (pep->ep_state & EP_HAS_STREAMS) 546 return radix_tree_lookup(&pep->stream_info.trb_address_map, 547 address >> TRB_SEGMENT_SHIFT); 548 549 return pep->ring; 550 } 551 552 /* 553 * Change an endpoint's internal structure so it supports stream IDs. 554 * The number of requested streams includes stream 0, which cannot be used by 555 * driver. 556 * 557 * The number of stream contexts in the stream context array may be bigger than 558 * the number of streams the driver wants to use. This is because the number of 559 * stream context array entries must be a power of two. 560 */ 561 int cdnsp_alloc_stream_info(struct cdnsp_device *pdev, 562 struct cdnsp_ep *pep, 563 unsigned int num_stream_ctxs, 564 unsigned int num_streams) 565 { 566 struct cdnsp_stream_info *stream_info; 567 struct cdnsp_ring *cur_ring; 568 u32 cur_stream; 569 u64 addr; 570 int ret; 571 int mps; 572 573 stream_info = &pep->stream_info; 574 stream_info->num_streams = num_streams; 575 stream_info->num_stream_ctxs = num_stream_ctxs; 576 577 /* Initialize the array of virtual pointers to stream rings. */ 578 stream_info->stream_rings = kzalloc_objs(struct cdnsp_ring *, 579 num_streams, GFP_ATOMIC); 580 if (!stream_info->stream_rings) 581 return -ENOMEM; 582 583 /* Initialize the array of DMA addresses for stream rings for the HW. */ 584 stream_info->stream_ctx_array = cdnsp_alloc_stream_ctx(pdev, pep); 585 if (!stream_info->stream_ctx_array) 586 goto cleanup_stream_rings; 587 588 memset(stream_info->stream_ctx_array, 0, 589 sizeof(struct cdnsp_stream_ctx) * num_stream_ctxs); 590 INIT_RADIX_TREE(&stream_info->trb_address_map, GFP_ATOMIC); 591 mps = usb_endpoint_maxp(pep->endpoint.desc); 592 593 /* 594 * Allocate rings for all the streams that the driver will use, 595 * and add their segment DMA addresses to the radix tree. 596 * Stream 0 is reserved. 597 */ 598 for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 599 cur_ring = cdnsp_ring_alloc(pdev, 2, TYPE_STREAM, mps, 600 GFP_ATOMIC); 601 stream_info->stream_rings[cur_stream] = cur_ring; 602 603 if (!cur_ring) 604 goto cleanup_rings; 605 606 cur_ring->stream_id = cur_stream; 607 cur_ring->trb_address_map = &stream_info->trb_address_map; 608 609 /* Set deq ptr, cycle bit, and stream context type. */ 610 addr = cur_ring->first_seg->dma | SCT_FOR_CTX(SCT_PRI_TR) | 611 cur_ring->cycle_state; 612 613 stream_info->stream_ctx_array[cur_stream].stream_ring = 614 cpu_to_le64(addr); 615 616 trace_cdnsp_set_stream_ring(cur_ring); 617 618 ret = cdnsp_update_stream_mapping(cur_ring); 619 if (ret) 620 goto cleanup_rings; 621 } 622 623 return 0; 624 625 cleanup_rings: 626 for (cur_stream = 1; cur_stream < num_streams; cur_stream++) { 627 cur_ring = stream_info->stream_rings[cur_stream]; 628 if (cur_ring) { 629 cdnsp_ring_free(pdev, cur_ring); 630 stream_info->stream_rings[cur_stream] = NULL; 631 } 632 } 633 634 cdnsp_free_stream_ctx(pdev, pep); 635 636 cleanup_stream_rings: 637 kfree(pep->stream_info.stream_rings); 638 639 return -ENOMEM; 640 } 641 642 /* Frees all stream contexts associated with the endpoint. */ 643 static void cdnsp_free_stream_info(struct cdnsp_device *pdev, 644 struct cdnsp_ep *pep) 645 { 646 struct cdnsp_stream_info *stream_info = &pep->stream_info; 647 struct cdnsp_ring *cur_ring; 648 int cur_stream; 649 650 if (!(pep->ep_state & EP_HAS_STREAMS)) 651 return; 652 653 for (cur_stream = 1; cur_stream < stream_info->num_streams; 654 cur_stream++) { 655 cur_ring = stream_info->stream_rings[cur_stream]; 656 if (cur_ring) { 657 cdnsp_ring_free(pdev, cur_ring); 658 stream_info->stream_rings[cur_stream] = NULL; 659 } 660 } 661 662 if (stream_info->stream_ctx_array) 663 cdnsp_free_stream_ctx(pdev, pep); 664 665 kfree(stream_info->stream_rings); 666 pep->ep_state &= ~EP_HAS_STREAMS; 667 } 668 669 /* All the cdnsp_tds in the ring's TD list should be freed at this point.*/ 670 static void cdnsp_free_priv_device(struct cdnsp_device *pdev) 671 { 672 pdev->dcbaa->dev_context_ptrs[1] = 0; 673 674 cdnsp_free_endpoint_rings(pdev, &pdev->eps[0]); 675 676 if (pdev->in_ctx.bytes) 677 dma_pool_free(pdev->device_pool, pdev->in_ctx.bytes, 678 pdev->in_ctx.dma); 679 680 if (pdev->out_ctx.bytes) 681 dma_pool_free(pdev->device_pool, pdev->out_ctx.bytes, 682 pdev->out_ctx.dma); 683 684 pdev->in_ctx.bytes = NULL; 685 pdev->out_ctx.bytes = NULL; 686 } 687 688 static int cdnsp_alloc_priv_device(struct cdnsp_device *pdev) 689 { 690 int ret; 691 692 ret = cdnsp_init_device_ctx(pdev); 693 if (ret) 694 return ret; 695 696 /* Allocate endpoint 0 ring. */ 697 pdev->eps[0].ring = cdnsp_ring_alloc(pdev, 2, TYPE_CTRL, 0, GFP_ATOMIC); 698 if (!pdev->eps[0].ring) 699 goto fail; 700 701 /* Point to output device context in dcbaa. */ 702 pdev->dcbaa->dev_context_ptrs[1] = cpu_to_le64(pdev->out_ctx.dma); 703 pdev->cmd.in_ctx = &pdev->in_ctx; 704 705 trace_cdnsp_alloc_priv_device(pdev); 706 return 0; 707 fail: 708 dma_pool_free(pdev->device_pool, pdev->out_ctx.bytes, 709 pdev->out_ctx.dma); 710 dma_pool_free(pdev->device_pool, pdev->in_ctx.bytes, 711 pdev->in_ctx.dma); 712 713 return ret; 714 } 715 716 void cdnsp_copy_ep0_dequeue_into_input_ctx(struct cdnsp_device *pdev) 717 { 718 struct cdnsp_ep_ctx *ep0_ctx = pdev->eps[0].in_ctx; 719 struct cdnsp_ring *ep_ring = pdev->eps[0].ring; 720 dma_addr_t dma; 721 722 dma = cdnsp_trb_virt_to_dma(ep_ring->enq_seg, ep_ring->enqueue); 723 ep0_ctx->deq = cpu_to_le64(dma | ep_ring->cycle_state); 724 } 725 726 /* Setup an controller private device for a Set Address command. */ 727 int cdnsp_setup_addressable_priv_dev(struct cdnsp_device *pdev) 728 { 729 struct cdnsp_slot_ctx *slot_ctx; 730 struct cdnsp_ep_ctx *ep0_ctx; 731 u32 max_packets, port; 732 733 ep0_ctx = cdnsp_get_ep_ctx(&pdev->in_ctx, 0); 734 slot_ctx = cdnsp_get_slot_ctx(&pdev->in_ctx); 735 736 /* Only the control endpoint is valid - one endpoint context. */ 737 slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1)); 738 739 switch (pdev->gadget.speed) { 740 case USB_SPEED_SUPER_PLUS: 741 slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_SSP); 742 max_packets = MAX_PACKET(512); 743 break; 744 case USB_SPEED_SUPER: 745 slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_SS); 746 max_packets = MAX_PACKET(512); 747 break; 748 case USB_SPEED_HIGH: 749 slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_HS); 750 max_packets = MAX_PACKET(64); 751 break; 752 case USB_SPEED_FULL: 753 slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_FS); 754 max_packets = MAX_PACKET(64); 755 break; 756 default: 757 /* Speed was not set , this shouldn't happen. */ 758 return -EINVAL; 759 } 760 761 port = DEV_PORT(pdev->active_port->port_num); 762 slot_ctx->dev_port |= cpu_to_le32(port); 763 slot_ctx->dev_state = cpu_to_le32((pdev->device_address & 764 DEV_ADDR_MASK)); 765 ep0_ctx->tx_info = cpu_to_le32(EP_AVG_TRB_LENGTH(0x8)); 766 ep0_ctx->ep_info2 = cpu_to_le32(EP_TYPE(CTRL_EP)); 767 ep0_ctx->ep_info2 |= cpu_to_le32(MAX_BURST(0) | ERROR_COUNT(3) | 768 max_packets); 769 770 ep0_ctx->deq = cpu_to_le64(pdev->eps[0].ring->first_seg->dma | 771 pdev->eps[0].ring->cycle_state); 772 773 trace_cdnsp_setup_addressable_priv_device(pdev); 774 775 return 0; 776 } 777 778 /* 779 * Convert interval expressed as 2^(bInterval - 1) == interval into 780 * straight exponent value 2^n == interval. 781 */ 782 static unsigned int cdnsp_parse_exponent_interval(struct usb_gadget *g, 783 struct cdnsp_ep *pep) 784 { 785 unsigned int interval; 786 787 interval = clamp_val(pep->endpoint.desc->bInterval, 1, 16) - 1; 788 if (interval != pep->endpoint.desc->bInterval - 1) 789 dev_warn(&g->dev, "ep %s - rounding interval to %d %sframes\n", 790 pep->name, 1 << interval, 791 g->speed == USB_SPEED_FULL ? "" : "micro"); 792 793 /* 794 * Full speed isoc endpoints specify interval in frames, 795 * not microframes. We are using microframes everywhere, 796 * so adjust accordingly. 797 */ 798 if (g->speed == USB_SPEED_FULL) 799 interval += 3; /* 1 frame = 2^3 uframes */ 800 801 /* Controller handles only up to 512ms (2^12). */ 802 if (interval > 12) 803 interval = 12; 804 805 return interval; 806 } 807 808 /* 809 * Convert bInterval expressed in microframes (in 1-255 range) to exponent of 810 * microframes, rounded down to nearest power of 2. 811 */ 812 static unsigned int cdnsp_microframes_to_exponent(struct usb_gadget *g, 813 struct cdnsp_ep *pep, 814 unsigned int desc_interval, 815 unsigned int min_exponent, 816 unsigned int max_exponent) 817 { 818 unsigned int interval; 819 820 interval = fls(desc_interval) - 1; 821 return clamp_val(interval, min_exponent, max_exponent); 822 } 823 824 /* 825 * Return the polling interval. 826 * 827 * The polling interval is expressed in "microframes". If controllers's Interval 828 * field is set to N, it will service the endpoint every 2^(Interval)*125us. 829 */ 830 static unsigned int cdnsp_get_endpoint_interval(struct usb_gadget *g, 831 struct cdnsp_ep *pep) 832 { 833 unsigned int interval = 0; 834 835 switch (g->speed) { 836 case USB_SPEED_HIGH: 837 case USB_SPEED_SUPER_PLUS: 838 case USB_SPEED_SUPER: 839 if (usb_endpoint_xfer_int(pep->endpoint.desc) || 840 usb_endpoint_xfer_isoc(pep->endpoint.desc)) 841 interval = cdnsp_parse_exponent_interval(g, pep); 842 break; 843 case USB_SPEED_FULL: 844 if (usb_endpoint_xfer_isoc(pep->endpoint.desc)) { 845 interval = cdnsp_parse_exponent_interval(g, pep); 846 } else if (usb_endpoint_xfer_int(pep->endpoint.desc)) { 847 interval = pep->endpoint.desc->bInterval << 3; 848 interval = cdnsp_microframes_to_exponent(g, pep, 849 interval, 850 3, 10); 851 } 852 853 break; 854 default: 855 WARN_ON(1); 856 } 857 858 return interval; 859 } 860 861 /* 862 * The "Mult" field in the endpoint context is only set for SuperSpeed isoc eps. 863 * High speed endpoint descriptors can define "the number of additional 864 * transaction opportunities per microframe", but that goes in the Max Burst 865 * endpoint context field. 866 */ 867 static u32 cdnsp_get_endpoint_mult(struct usb_gadget *g, struct cdnsp_ep *pep) 868 { 869 if (g->speed < USB_SPEED_SUPER || 870 !usb_endpoint_xfer_isoc(pep->endpoint.desc)) 871 return 0; 872 873 return pep->endpoint.comp_desc->bmAttributes; 874 } 875 876 static u32 cdnsp_get_endpoint_max_burst(struct usb_gadget *g, 877 struct cdnsp_ep *pep) 878 { 879 /* Super speed and Plus have max burst in ep companion desc */ 880 if (g->speed >= USB_SPEED_SUPER) 881 return pep->endpoint.comp_desc->bMaxBurst; 882 883 if (g->speed == USB_SPEED_HIGH && 884 (usb_endpoint_xfer_isoc(pep->endpoint.desc) || 885 usb_endpoint_xfer_int(pep->endpoint.desc))) 886 return usb_endpoint_maxp_mult(pep->endpoint.desc) - 1; 887 888 return 0; 889 } 890 891 static u32 cdnsp_get_endpoint_type(const struct usb_endpoint_descriptor *desc) 892 { 893 int in; 894 895 in = usb_endpoint_dir_in(desc); 896 897 switch (usb_endpoint_type(desc)) { 898 case USB_ENDPOINT_XFER_CONTROL: 899 return CTRL_EP; 900 case USB_ENDPOINT_XFER_BULK: 901 return in ? BULK_IN_EP : BULK_OUT_EP; 902 case USB_ENDPOINT_XFER_ISOC: 903 return in ? ISOC_IN_EP : ISOC_OUT_EP; 904 case USB_ENDPOINT_XFER_INT: 905 return in ? INT_IN_EP : INT_OUT_EP; 906 } 907 908 return 0; 909 } 910 911 /* 912 * Return the maximum endpoint service interval time (ESIT) payload. 913 * Basically, this is the maxpacket size, multiplied by the burst size 914 * and mult size. 915 */ 916 static u32 cdnsp_get_max_esit_payload(struct usb_gadget *g, 917 struct cdnsp_ep *pep) 918 { 919 int max_packet; 920 int max_burst; 921 922 /* Only applies for interrupt or isochronous endpoints*/ 923 if (usb_endpoint_xfer_control(pep->endpoint.desc) || 924 usb_endpoint_xfer_bulk(pep->endpoint.desc)) 925 return 0; 926 927 /* SuperSpeedPlus Isoc ep sending over 48k per EIST. */ 928 if (g->speed >= USB_SPEED_SUPER_PLUS && 929 USB_SS_SSP_ISOC_COMP(pep->endpoint.desc->bmAttributes)) 930 return le16_to_cpu(pep->endpoint.comp_desc->wBytesPerInterval); 931 /* SuperSpeed or SuperSpeedPlus Isoc ep with less than 48k per esit */ 932 else if (g->speed >= USB_SPEED_SUPER) 933 return le16_to_cpu(pep->endpoint.comp_desc->wBytesPerInterval); 934 935 max_packet = usb_endpoint_maxp(pep->endpoint.desc); 936 max_burst = usb_endpoint_maxp_mult(pep->endpoint.desc); 937 938 /* A 0 in max burst means 1 transfer per ESIT */ 939 return max_packet * max_burst; 940 } 941 942 int cdnsp_endpoint_init(struct cdnsp_device *pdev, 943 struct cdnsp_ep *pep, 944 gfp_t mem_flags) 945 { 946 enum cdnsp_ring_type ring_type; 947 struct cdnsp_ep_ctx *ep_ctx; 948 unsigned int err_count = 0; 949 unsigned int avg_trb_len; 950 unsigned int max_packet; 951 unsigned int max_burst; 952 unsigned int interval; 953 u32 max_esit_payload; 954 unsigned int mult; 955 u32 endpoint_type; 956 int ret; 957 958 ep_ctx = pep->in_ctx; 959 960 endpoint_type = cdnsp_get_endpoint_type(pep->endpoint.desc); 961 if (!endpoint_type) 962 return -EINVAL; 963 964 ring_type = usb_endpoint_type(pep->endpoint.desc); 965 966 /* 967 * Get values to fill the endpoint context, mostly from ep descriptor. 968 * The average TRB buffer length for bulk endpoints is unclear as we 969 * have no clue on scatter gather list entry size. For Isoc and Int, 970 * set it to max available. 971 */ 972 max_esit_payload = cdnsp_get_max_esit_payload(&pdev->gadget, pep); 973 interval = cdnsp_get_endpoint_interval(&pdev->gadget, pep); 974 mult = cdnsp_get_endpoint_mult(&pdev->gadget, pep); 975 max_packet = usb_endpoint_maxp(pep->endpoint.desc); 976 max_burst = cdnsp_get_endpoint_max_burst(&pdev->gadget, pep); 977 avg_trb_len = max_esit_payload; 978 979 /* Allow 3 retries for everything but isoc, set CErr = 3. */ 980 if (!usb_endpoint_xfer_isoc(pep->endpoint.desc)) 981 err_count = 3; 982 if (usb_endpoint_xfer_bulk(pep->endpoint.desc) && 983 pdev->gadget.speed == USB_SPEED_HIGH) 984 max_packet = 512; 985 /* Controller spec indicates that ctrl ep avg TRB Length should be 8. */ 986 if (usb_endpoint_xfer_control(pep->endpoint.desc)) 987 avg_trb_len = 8; 988 989 /* Set up the endpoint ring. */ 990 pep->ring = cdnsp_ring_alloc(pdev, 2, ring_type, max_packet, mem_flags); 991 if (!pep->ring) 992 return -ENOMEM; 993 994 pep->skip = false; 995 996 /* Fill the endpoint context */ 997 ep_ctx->ep_info = cpu_to_le32(EP_MAX_ESIT_PAYLOAD_HI(max_esit_payload) | 998 EP_INTERVAL(interval) | EP_MULT(mult)); 999 ep_ctx->ep_info2 = cpu_to_le32(EP_TYPE(endpoint_type) | 1000 MAX_PACKET(max_packet) | MAX_BURST(max_burst) | 1001 ERROR_COUNT(err_count)); 1002 ep_ctx->deq = cpu_to_le64(pep->ring->first_seg->dma | 1003 pep->ring->cycle_state); 1004 1005 ep_ctx->tx_info = cpu_to_le32(EP_MAX_ESIT_PAYLOAD_LO(max_esit_payload) | 1006 EP_AVG_TRB_LENGTH(avg_trb_len)); 1007 1008 if (usb_endpoint_xfer_bulk(pep->endpoint.desc) && 1009 pdev->gadget.speed > USB_SPEED_HIGH) { 1010 ret = cdnsp_alloc_streams(pdev, pep); 1011 if (ret < 0) 1012 return ret; 1013 } 1014 1015 return 0; 1016 } 1017 1018 void cdnsp_endpoint_zero(struct cdnsp_device *pdev, struct cdnsp_ep *pep) 1019 { 1020 pep->in_ctx->ep_info = 0; 1021 pep->in_ctx->ep_info2 = 0; 1022 pep->in_ctx->deq = 0; 1023 pep->in_ctx->tx_info = 0; 1024 } 1025 1026 static int cdnsp_alloc_erst(struct cdnsp_device *pdev, 1027 struct cdnsp_ring *evt_ring, 1028 struct cdnsp_erst *erst) 1029 { 1030 struct cdnsp_erst_entry *entry; 1031 struct cdnsp_segment *seg; 1032 unsigned int val; 1033 size_t size; 1034 1035 size = sizeof(struct cdnsp_erst_entry) * evt_ring->num_segs; 1036 erst->entries = dma_alloc_coherent(pdev->dev, size, 1037 &erst->erst_dma_addr, GFP_KERNEL); 1038 if (!erst->entries) 1039 return -ENOMEM; 1040 1041 erst->num_entries = evt_ring->num_segs; 1042 1043 seg = evt_ring->first_seg; 1044 for (val = 0; val < evt_ring->num_segs; val++) { 1045 entry = &erst->entries[val]; 1046 entry->seg_addr = cpu_to_le64(seg->dma); 1047 entry->seg_size = cpu_to_le32(TRBS_PER_SEGMENT); 1048 entry->rsvd = 0; 1049 seg = seg->next; 1050 } 1051 1052 return 0; 1053 } 1054 1055 static void cdnsp_free_erst(struct cdnsp_device *pdev, struct cdnsp_erst *erst) 1056 { 1057 size_t size = sizeof(struct cdnsp_erst_entry) * (erst->num_entries); 1058 struct device *dev = pdev->dev; 1059 1060 if (erst->entries) 1061 dma_free_coherent(dev, size, erst->entries, 1062 erst->erst_dma_addr); 1063 1064 erst->entries = NULL; 1065 } 1066 1067 void cdnsp_mem_cleanup(struct cdnsp_device *pdev) 1068 { 1069 struct device *dev = pdev->dev; 1070 1071 cdnsp_free_priv_device(pdev); 1072 cdnsp_free_erst(pdev, &pdev->erst); 1073 1074 if (pdev->event_ring) 1075 cdnsp_ring_free(pdev, pdev->event_ring); 1076 1077 pdev->event_ring = NULL; 1078 1079 if (pdev->cmd_ring) 1080 cdnsp_ring_free(pdev, pdev->cmd_ring); 1081 1082 pdev->cmd_ring = NULL; 1083 1084 dma_pool_destroy(pdev->segment_pool); 1085 pdev->segment_pool = NULL; 1086 dma_pool_destroy(pdev->device_pool); 1087 pdev->device_pool = NULL; 1088 1089 dma_free_coherent(dev, sizeof(*pdev->dcbaa), 1090 pdev->dcbaa, pdev->dcbaa->dma); 1091 1092 pdev->dcbaa = NULL; 1093 memset(&pdev->usb2_port, 0, sizeof(struct cdnsp_port)); 1094 memset(&pdev->eusb_port, 0, sizeof(struct cdnsp_port)); 1095 memset(&pdev->usb3_port, 0, sizeof(struct cdnsp_port)); 1096 pdev->active_port = NULL; 1097 } 1098 1099 static void cdnsp_set_event_deq(struct cdnsp_device *pdev) 1100 { 1101 dma_addr_t deq; 1102 u64 temp; 1103 1104 deq = cdnsp_trb_virt_to_dma(pdev->event_ring->deq_seg, 1105 pdev->event_ring->dequeue); 1106 1107 /* Update controller event ring dequeue pointer */ 1108 temp = cdnsp_read_64(&pdev->ir_set->erst_dequeue); 1109 temp &= ERST_PTR_MASK; 1110 1111 /* 1112 * Don't clear the EHB bit (which is RW1C) because 1113 * there might be more events to service. 1114 */ 1115 temp &= ~ERST_EHB; 1116 1117 cdnsp_write_64(((u64)deq & (u64)~ERST_PTR_MASK) | temp, 1118 &pdev->ir_set->erst_dequeue); 1119 } 1120 1121 static void cdnsp_add_in_port(struct cdnsp_device *pdev, 1122 struct cdnsp_port *port, 1123 __le32 __iomem *addr) 1124 { 1125 u32 temp, port_offset, port_count; 1126 1127 temp = readl(addr); 1128 port->maj_rev = CDNSP_EXT_PORT_MAJOR(temp); 1129 port->min_rev = CDNSP_EXT_PORT_MINOR(temp); 1130 1131 /* Port offset and count in the third dword.*/ 1132 temp = readl(addr + 2); 1133 port_offset = CDNSP_EXT_PORT_OFF(temp); 1134 port_count = CDNSP_EXT_PORT_COUNT(temp); 1135 1136 if (port == &pdev->eusb_port) { 1137 /* 1138 * If controller has usb2 + eusb port then eusb is as 1139 * second port 1140 */ 1141 if (port_count == 2) 1142 port_offset++; 1143 1144 if (port_count == 1 && pdev->usb2_port.exist) 1145 return; 1146 } 1147 1148 trace_cdnsp_port_info(addr, port_offset, port_count, port->maj_rev); 1149 1150 port->port_num = port_offset; 1151 port->exist = 1; 1152 } 1153 1154 /* 1155 * Scan the Extended Capabilities for the "Supported Protocol Capabilities" that 1156 * specify what speeds each port is supposed to be. 1157 */ 1158 static int cdnsp_setup_port_arrays(struct cdnsp_device *pdev) 1159 { 1160 void __iomem *base; 1161 u32 offset; 1162 int i; 1163 1164 base = &pdev->cap_regs->hc_capbase; 1165 offset = cdnsp_find_next_ext_cap(base, 0, 1166 EXT_CAP_CFG_DEV_20PORT_CAP_ID); 1167 if (offset) 1168 pdev->port20_regs = base + offset; 1169 1170 offset = 0; 1171 1172 /* Driver expects max 2 extended protocol capability. */ 1173 for (i = 0; i < 2; i++) { 1174 u32 temp; 1175 1176 offset = cdnsp_find_next_ext_cap(base, offset, 1177 EXT_CAPS_PROTOCOL); 1178 temp = readl(base + offset); 1179 1180 if (CDNSP_EXT_PORT_MAJOR(temp) == 0x03 && 1181 !pdev->usb3_port.port_num) 1182 cdnsp_add_in_port(pdev, &pdev->usb3_port, 1183 base + offset); 1184 1185 if (CDNSP_EXT_PORT_MAJOR(temp) == 0x02) { 1186 if (!pdev->usb2_port.port_num && pdev->port20_regs) 1187 cdnsp_add_in_port(pdev, &pdev->usb2_port, 1188 base + offset); 1189 1190 if (!pdev->eusb_port.port_num) 1191 cdnsp_add_in_port(pdev, &pdev->eusb_port, 1192 base + offset); 1193 } 1194 } 1195 1196 if (!pdev->usb2_port.exist && !pdev->eusb_port.exist && 1197 !pdev->usb3_port.exist) { 1198 dev_err(pdev->dev, "Error: No port detected\n"); 1199 return -ENODEV; 1200 } 1201 1202 if (pdev->usb2_port.exist) { 1203 pdev->usb2_port.regs = (struct cdnsp_port_regs __iomem *) 1204 (&pdev->op_regs->port_reg_base + NUM_PORT_REGS * 1205 (pdev->usb2_port.port_num - 1)); 1206 trace_cdnsp_init("Found USB 2.0 port."); 1207 } 1208 1209 if (pdev->eusb_port.exist) { 1210 pdev->eusb_port.regs = (struct cdnsp_port_regs __iomem *) 1211 (&pdev->op_regs->port_reg_base + NUM_PORT_REGS * 1212 (pdev->eusb_port.port_num - 1)); 1213 trace_cdnsp_init("Found eUSB 2.0 port."); 1214 } 1215 1216 if (pdev->usb3_port.exist) { 1217 offset = cdnsp_find_next_ext_cap(base, 0, D_XEC_CFG_3XPORT_CAP); 1218 pdev->port3x_regs = base + offset; 1219 1220 pdev->usb3_port.regs = (struct cdnsp_port_regs __iomem *) 1221 (&pdev->op_regs->port_reg_base + NUM_PORT_REGS * 1222 (pdev->usb3_port.port_num - 1)); 1223 trace_cdnsp_init("Found USB 3.x port."); 1224 } 1225 1226 return 0; 1227 } 1228 1229 /* 1230 * Initialize memory for CDNSP (one-time init). 1231 * 1232 * Program the PAGESIZE register, initialize the device context array, create 1233 * device contexts, set up a command ring segment, create event 1234 * ring (one for now). 1235 */ 1236 int cdnsp_mem_init(struct cdnsp_device *pdev) 1237 { 1238 struct device *dev = pdev->dev; 1239 int ret = -ENOMEM; 1240 unsigned int val; 1241 dma_addr_t dma; 1242 u32 page_size; 1243 u64 val_64; 1244 1245 /* 1246 * Use 4K pages, since that's common and the minimum the 1247 * controller supports 1248 */ 1249 page_size = 1 << 12; 1250 1251 val = readl(&pdev->op_regs->config_reg); 1252 val |= ((val & ~MAX_DEVS) | CDNSP_DEV_MAX_SLOTS) | CONFIG_U3E; 1253 writel(val, &pdev->op_regs->config_reg); 1254 1255 /* 1256 * Doorbell array must be physically contiguous 1257 * and 64-byte (cache line) aligned. 1258 */ 1259 pdev->dcbaa = dma_alloc_coherent(dev, sizeof(*pdev->dcbaa), 1260 &dma, GFP_KERNEL); 1261 if (!pdev->dcbaa) 1262 return -ENOMEM; 1263 1264 pdev->dcbaa->dma = dma; 1265 1266 cdnsp_write_64(dma, &pdev->op_regs->dcbaa_ptr); 1267 1268 /* 1269 * Initialize the ring segment pool. The ring must be a contiguous 1270 * structure comprised of TRBs. The TRBs must be 16 byte aligned, 1271 * however, the command ring segment needs 64-byte aligned segments 1272 * and our use of dma addresses in the trb_address_map radix tree needs 1273 * TRB_SEGMENT_SIZE alignment, so driver pick the greater alignment 1274 * need. 1275 */ 1276 pdev->segment_pool = dma_pool_create("CDNSP ring segments", dev, 1277 TRB_SEGMENT_SIZE, TRB_SEGMENT_SIZE, 1278 page_size); 1279 if (!pdev->segment_pool) 1280 goto release_dcbaa; 1281 1282 pdev->device_pool = dma_pool_create("CDNSP input/output contexts", dev, 1283 CDNSP_CTX_SIZE, 64, page_size); 1284 if (!pdev->device_pool) 1285 goto destroy_segment_pool; 1286 1287 1288 /* Set up the command ring to have one segments for now. */ 1289 pdev->cmd_ring = cdnsp_ring_alloc(pdev, 1, TYPE_COMMAND, 0, GFP_KERNEL); 1290 if (!pdev->cmd_ring) 1291 goto destroy_device_pool; 1292 1293 /* Set the address in the Command Ring Control register */ 1294 val_64 = cdnsp_read_64(&pdev->op_regs->cmd_ring); 1295 val_64 = (val_64 & (u64)CMD_RING_RSVD_BITS) | 1296 (pdev->cmd_ring->first_seg->dma & (u64)~CMD_RING_RSVD_BITS) | 1297 pdev->cmd_ring->cycle_state; 1298 cdnsp_write_64(val_64, &pdev->op_regs->cmd_ring); 1299 1300 val = readl(&pdev->cap_regs->db_off); 1301 val &= DBOFF_MASK; 1302 pdev->dba = (void __iomem *)pdev->cap_regs + val; 1303 1304 /* Set ir_set to interrupt register set 0 */ 1305 pdev->ir_set = &pdev->run_regs->ir_set[0]; 1306 1307 /* 1308 * Event ring setup: Allocate a normal ring, but also setup 1309 * the event ring segment table (ERST). 1310 */ 1311 pdev->event_ring = cdnsp_ring_alloc(pdev, ERST_NUM_SEGS, TYPE_EVENT, 1312 0, GFP_KERNEL); 1313 if (!pdev->event_ring) 1314 goto free_cmd_ring; 1315 1316 ret = cdnsp_alloc_erst(pdev, pdev->event_ring, &pdev->erst); 1317 if (ret) 1318 goto free_event_ring; 1319 1320 /* Set ERST count with the number of entries in the segment table. */ 1321 val = readl(&pdev->ir_set->erst_size); 1322 val &= ERST_SIZE_MASK; 1323 val |= ERST_NUM_SEGS; 1324 writel(val, &pdev->ir_set->erst_size); 1325 1326 /* Set the segment table base address. */ 1327 val_64 = cdnsp_read_64(&pdev->ir_set->erst_base); 1328 val_64 &= ERST_PTR_MASK; 1329 val_64 |= (pdev->erst.erst_dma_addr & (u64)~ERST_PTR_MASK); 1330 cdnsp_write_64(val_64, &pdev->ir_set->erst_base); 1331 1332 /* Set the event ring dequeue address. */ 1333 cdnsp_set_event_deq(pdev); 1334 1335 ret = cdnsp_setup_port_arrays(pdev); 1336 if (ret) 1337 goto free_erst; 1338 1339 ret = cdnsp_alloc_priv_device(pdev); 1340 if (ret) { 1341 dev_err(pdev->dev, 1342 "Could not allocate cdnsp_device data structures\n"); 1343 goto free_erst; 1344 } 1345 1346 return 0; 1347 1348 free_erst: 1349 cdnsp_free_erst(pdev, &pdev->erst); 1350 free_event_ring: 1351 cdnsp_ring_free(pdev, pdev->event_ring); 1352 free_cmd_ring: 1353 cdnsp_ring_free(pdev, pdev->cmd_ring); 1354 destroy_device_pool: 1355 dma_pool_destroy(pdev->device_pool); 1356 destroy_segment_pool: 1357 dma_pool_destroy(pdev->segment_pool); 1358 release_dcbaa: 1359 dma_free_coherent(dev, sizeof(*pdev->dcbaa), pdev->dcbaa, 1360 pdev->dcbaa->dma); 1361 1362 cdnsp_reset(pdev); 1363 1364 return ret; 1365 } 1366