1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * xhci-dbgcap.c - xHCI debug capability support 4 * 5 * Copyright (C) 2017 Intel Corporation 6 * 7 * Author: Lu Baolu <baolu.lu@linux.intel.com> 8 */ 9 #include <linux/bug.h> 10 #include <linux/device.h> 11 #include <linux/dma-mapping.h> 12 #include <linux/errno.h> 13 #include <linux/kstrtox.h> 14 #include <linux/list.h> 15 #include <linux/nls.h> 16 #include <linux/pm_runtime.h> 17 #include <linux/slab.h> 18 #include <linux/spinlock.h> 19 #include <linux/string.h> 20 #include <linux/sysfs.h> 21 #include <linux/types.h> 22 #include <linux/workqueue.h> 23 24 #include <linux/io-64-nonatomic-lo-hi.h> 25 26 #include <asm/byteorder.h> 27 28 #include "xhci.h" 29 #include "xhci-trace.h" 30 #include "xhci-dbgcap.h" 31 32 static const struct dbc_str dbc_str_default = { 33 .manufacturer = "Linux Foundation", 34 .product = "Linux USB Debug Target", 35 .serial = "0001", 36 }; 37 38 static void dbc_free_ctx(struct device *dev, struct xhci_container_ctx *ctx) 39 { 40 if (!ctx) 41 return; 42 dma_free_coherent(dev, ctx->size, ctx->bytes, ctx->dma); 43 kfree(ctx); 44 } 45 46 /* we use only one segment for DbC rings */ 47 static void dbc_ring_free(struct device *dev, struct xhci_ring *ring) 48 { 49 if (!ring) 50 return; 51 52 if (ring->first_seg) { 53 dma_free_coherent(dev, TRB_SEGMENT_SIZE, 54 ring->first_seg->trbs, 55 ring->first_seg->dma); 56 kfree(ring->first_seg); 57 } 58 kfree(ring); 59 } 60 61 static void xhci_dbc_init_ep_contexts(struct xhci_dbc *dbc) 62 { 63 struct xhci_ep_ctx *ep_ctx; 64 unsigned int max_burst; 65 dma_addr_t deq; 66 67 max_burst = DBC_CTRL_MAXBURST(readl(&dbc->regs->control)); 68 69 /* Populate bulk out endpoint context: */ 70 ep_ctx = dbc_bulkout_ctx(dbc); 71 deq = dbc_bulkout_enq(dbc); 72 ep_ctx->ep_info = 0; 73 ep_ctx->ep_info2 = dbc_epctx_info2(BULK_OUT_EP, 1024, max_burst); 74 ep_ctx->deq = cpu_to_le64(deq | dbc->ring_out->cycle_state); 75 76 /* Populate bulk in endpoint context: */ 77 ep_ctx = dbc_bulkin_ctx(dbc); 78 deq = dbc_bulkin_enq(dbc); 79 ep_ctx->ep_info = 0; 80 ep_ctx->ep_info2 = dbc_epctx_info2(BULK_IN_EP, 1024, max_burst); 81 ep_ctx->deq = cpu_to_le64(deq | dbc->ring_in->cycle_state); 82 } 83 84 static u8 get_str_desc_len(const char *desc) 85 { 86 return ((struct usb_string_descriptor *)desc)->bLength; 87 } 88 89 static u32 dbc_prepare_info_context_str_len(struct dbc_str_descs *descs) 90 { 91 u32 len; 92 93 len = get_str_desc_len(descs->serial); 94 len <<= 8; 95 len += get_str_desc_len(descs->product); 96 len <<= 8; 97 len += get_str_desc_len(descs->manufacturer); 98 len <<= 8; 99 len += get_str_desc_len(descs->string0); 100 101 return len; 102 } 103 104 static int xhci_dbc_populate_str_desc(char *desc, const char *src) 105 { 106 struct usb_string_descriptor *s_desc; 107 int len; 108 109 s_desc = (struct usb_string_descriptor *)desc; 110 111 /* len holds number of 2 byte UTF-16 characters */ 112 len = utf8s_to_utf16s(src, strlen(src), UTF16_LITTLE_ENDIAN, 113 (wchar_t *)s_desc->wData, USB_MAX_STRING_LEN * 2); 114 if (len < 0) 115 return len; 116 117 s_desc->bLength = len * 2 + 2; 118 s_desc->bDescriptorType = USB_DT_STRING; 119 120 return s_desc->bLength; 121 } 122 123 static void xhci_dbc_populate_str_descs(struct dbc_str_descs *str_descs, 124 struct dbc_str *str) 125 { 126 /* Serial string: */ 127 xhci_dbc_populate_str_desc(str_descs->serial, str->serial); 128 129 /* Product string: */ 130 xhci_dbc_populate_str_desc(str_descs->product, str->product); 131 132 /* Manufacturer string: */ 133 xhci_dbc_populate_str_desc(str_descs->manufacturer, str->manufacturer); 134 135 /* String0: */ 136 str_descs->string0[0] = 4; 137 str_descs->string0[1] = USB_DT_STRING; 138 str_descs->string0[2] = 0x09; 139 str_descs->string0[3] = 0x04; 140 } 141 142 static void xhci_dbc_init_contexts(struct xhci_dbc *dbc) 143 { 144 struct dbc_info_context *info; 145 u32 dev_info; 146 dma_addr_t dma; 147 148 if (!dbc) 149 return; 150 151 /* Populate info Context: */ 152 info = (struct dbc_info_context *)dbc->ctx->bytes; 153 dma = dbc->str_descs_dma; 154 info->string0 = cpu_to_le64(dma); 155 info->manufacturer = cpu_to_le64(dma + USB_MAX_STRING_DESC_LEN); 156 info->product = cpu_to_le64(dma + USB_MAX_STRING_DESC_LEN * 2); 157 info->serial = cpu_to_le64(dma + USB_MAX_STRING_DESC_LEN * 3); 158 info->length = cpu_to_le32(dbc_prepare_info_context_str_len(dbc->str_descs)); 159 160 /* Populate bulk in and out endpoint contexts: */ 161 xhci_dbc_init_ep_contexts(dbc); 162 163 /* Set DbC context and info registers: */ 164 lo_hi_writeq(dbc->ctx->dma, &dbc->regs->dccp); 165 166 dev_info = (dbc->idVendor << 16) | dbc->bInterfaceProtocol; 167 writel(dev_info, &dbc->regs->devinfo1); 168 169 dev_info = (dbc->bcdDevice << 16) | dbc->idProduct; 170 writel(dev_info, &dbc->regs->devinfo2); 171 } 172 173 static void xhci_dbc_giveback(struct dbc_request *req, int status) 174 __releases(&dbc->lock) 175 __acquires(&dbc->lock) 176 { 177 struct xhci_dbc *dbc = req->dbc; 178 struct device *dev = dbc->dev; 179 180 list_del_init(&req->list_pending); 181 req->trb_dma = 0; 182 req->trb = NULL; 183 184 if (req->status == -EINPROGRESS) 185 req->status = status; 186 187 trace_xhci_dbc_giveback_request(req); 188 189 dma_unmap_single(dev, 190 req->dma, 191 req->length, 192 dbc_ep_dma_direction(req)); 193 194 /* Give back the transfer request: */ 195 spin_unlock(&dbc->lock); 196 req->complete(dbc, req); 197 spin_lock(&dbc->lock); 198 } 199 200 static void trb_to_noop(union xhci_trb *trb) 201 { 202 trb->generic.field[0] = 0; 203 trb->generic.field[1] = 0; 204 trb->generic.field[2] = 0; 205 trb->generic.field[3] &= cpu_to_le32(TRB_CYCLE); 206 trb->generic.field[3] |= cpu_to_le32(TRB_TYPE(TRB_TR_NOOP)); 207 } 208 209 static void xhci_dbc_flush_single_request(struct dbc_request *req) 210 { 211 trb_to_noop(req->trb); 212 xhci_dbc_giveback(req, -ESHUTDOWN); 213 } 214 215 static void xhci_dbc_flush_endpoint_requests(struct dbc_ep *dep) 216 { 217 struct dbc_request *req, *tmp; 218 219 list_for_each_entry_safe(req, tmp, &dep->list_pending, list_pending) 220 xhci_dbc_flush_single_request(req); 221 } 222 223 static void xhci_dbc_flush_requests(struct xhci_dbc *dbc) 224 { 225 xhci_dbc_flush_endpoint_requests(&dbc->eps[BULK_OUT]); 226 xhci_dbc_flush_endpoint_requests(&dbc->eps[BULK_IN]); 227 } 228 229 struct dbc_request * 230 dbc_alloc_request(struct xhci_dbc *dbc, unsigned int direction, gfp_t flags) 231 { 232 struct dbc_request *req; 233 234 if (direction != BULK_IN && 235 direction != BULK_OUT) 236 return NULL; 237 238 if (!dbc) 239 return NULL; 240 241 req = kzalloc_obj(*req, flags); 242 if (!req) 243 return NULL; 244 245 req->dbc = dbc; 246 INIT_LIST_HEAD(&req->list_pending); 247 INIT_LIST_HEAD(&req->list_pool); 248 req->direction = direction; 249 250 trace_xhci_dbc_alloc_request(req); 251 252 return req; 253 } 254 255 void 256 dbc_free_request(struct dbc_request *req) 257 { 258 trace_xhci_dbc_free_request(req); 259 260 kfree(req); 261 } 262 263 static void 264 xhci_dbc_queue_trb(struct xhci_ring *ring, u32 field1, 265 u32 field2, u32 field3, u32 field4) 266 { 267 union xhci_trb *trb, *next; 268 269 trb = ring->enqueue; 270 trb->generic.field[0] = cpu_to_le32(field1); 271 trb->generic.field[1] = cpu_to_le32(field2); 272 trb->generic.field[2] = cpu_to_le32(field3); 273 trb->generic.field[3] = cpu_to_le32(field4); 274 275 trace_xhci_dbc_gadget_ep_queue(ring, &trb->generic, 276 xhci_trb_virt_to_dma(ring->enq_seg, 277 ring->enqueue)); 278 next = ++(ring->enqueue); 279 if (TRB_TYPE_LINK_LE32(next->link.control)) { 280 next->link.control ^= cpu_to_le32(TRB_CYCLE); 281 ring->enqueue = ring->enq_seg->trbs; 282 ring->cycle_state ^= 1; 283 } 284 } 285 286 static int xhci_dbc_queue_bulk_tx(struct dbc_ep *dep, 287 struct dbc_request *req) 288 { 289 u64 addr; 290 union xhci_trb *trb; 291 unsigned int num_trbs; 292 struct xhci_dbc *dbc = req->dbc; 293 struct xhci_ring *ring = dep->ring; 294 u32 length, control, cycle; 295 296 num_trbs = count_trbs(req->dma, req->length); 297 WARN_ON(num_trbs != 1); 298 if (xhci_num_trbs_free(ring) <= num_trbs) 299 return -EBUSY; 300 301 addr = req->dma; 302 trb = ring->enqueue; 303 cycle = ring->cycle_state; 304 length = TRB_LEN(req->length); 305 control = TRB_TYPE(TRB_NORMAL) | TRB_IOC; 306 307 if (cycle) 308 control &= cpu_to_le32(~TRB_CYCLE); 309 else 310 control |= cpu_to_le32(TRB_CYCLE); 311 312 req->trb = ring->enqueue; 313 req->trb_dma = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue); 314 xhci_dbc_queue_trb(ring, 315 lower_32_bits(addr), 316 upper_32_bits(addr), 317 length, control); 318 319 /* 320 * Add a barrier between writes of trb fields and flipping 321 * the cycle bit: 322 */ 323 wmb(); 324 325 if (cycle) 326 trb->generic.field[3] |= cpu_to_le32(TRB_CYCLE); 327 else 328 trb->generic.field[3] &= cpu_to_le32(~TRB_CYCLE); 329 330 writel(DBC_DOOR_BELL_TARGET(dep->direction), &dbc->regs->doorbell); 331 332 return 0; 333 } 334 335 static int 336 dbc_ep_do_queue(struct dbc_request *req) 337 { 338 int ret; 339 struct xhci_dbc *dbc = req->dbc; 340 struct device *dev = dbc->dev; 341 struct dbc_ep *dep = &dbc->eps[req->direction]; 342 343 if (!req->length || !req->buf) 344 return -EINVAL; 345 346 req->actual = 0; 347 req->status = -EINPROGRESS; 348 349 req->dma = dma_map_single(dev, 350 req->buf, 351 req->length, 352 dbc_ep_dma_direction(dep)); 353 if (dma_mapping_error(dev, req->dma)) { 354 dev_err(dbc->dev, "failed to map buffer\n"); 355 return -EFAULT; 356 } 357 358 ret = xhci_dbc_queue_bulk_tx(dep, req); 359 if (ret) { 360 dev_err(dbc->dev, "failed to queue trbs\n"); 361 dma_unmap_single(dev, 362 req->dma, 363 req->length, 364 dbc_ep_dma_direction(dep)); 365 return -EFAULT; 366 } 367 368 list_add_tail(&req->list_pending, &dep->list_pending); 369 370 return 0; 371 } 372 373 int dbc_ep_queue(struct dbc_request *req) 374 { 375 unsigned long flags; 376 struct xhci_dbc *dbc = req->dbc; 377 int ret = -ESHUTDOWN; 378 379 if (!dbc) 380 return -ENODEV; 381 382 if (req->direction != BULK_IN && 383 req->direction != BULK_OUT) 384 return -EINVAL; 385 386 spin_lock_irqsave(&dbc->lock, flags); 387 if (dbc->state == DS_CONFIGURED) 388 ret = dbc_ep_do_queue(req); 389 spin_unlock_irqrestore(&dbc->lock, flags); 390 391 mod_delayed_work(system_percpu_wq, &dbc->event_work, 0); 392 393 trace_xhci_dbc_queue_request(req); 394 395 return ret; 396 } 397 398 static inline void xhci_dbc_do_eps_init(struct xhci_dbc *dbc, bool direction) 399 { 400 struct dbc_ep *dep; 401 402 dep = &dbc->eps[direction]; 403 dep->dbc = dbc; 404 dep->direction = direction; 405 dep->ring = direction ? dbc->ring_in : dbc->ring_out; 406 407 INIT_LIST_HEAD(&dep->list_pending); 408 } 409 410 static void xhci_dbc_eps_init(struct xhci_dbc *dbc) 411 { 412 xhci_dbc_do_eps_init(dbc, BULK_OUT); 413 xhci_dbc_do_eps_init(dbc, BULK_IN); 414 } 415 416 static void xhci_dbc_eps_exit(struct xhci_dbc *dbc) 417 { 418 memset(dbc->eps, 0, sizeof_field(struct xhci_dbc, eps)); 419 } 420 421 static int dbc_erst_alloc(struct device *dev, struct xhci_ring *evt_ring, 422 struct xhci_erst *erst, gfp_t flags) 423 { 424 erst->entries = dma_alloc_coherent(dev, sizeof(*erst->entries), 425 &erst->erst_dma_addr, flags); 426 if (!erst->entries) 427 return -ENOMEM; 428 429 erst->num_entries = 1; 430 erst->entries[0].seg_addr = cpu_to_le64(evt_ring->first_seg->dma); 431 erst->entries[0].seg_size = cpu_to_le32(TRBS_PER_SEGMENT); 432 erst->entries[0].rsvd = 0; 433 return 0; 434 } 435 436 static void dbc_erst_free(struct device *dev, struct xhci_erst *erst) 437 { 438 dma_free_coherent(dev, sizeof(*erst->entries), erst->entries, 439 erst->erst_dma_addr); 440 erst->entries = NULL; 441 } 442 443 static struct xhci_container_ctx * 444 dbc_alloc_ctx(struct device *dev, gfp_t flags) 445 { 446 struct xhci_container_ctx *ctx; 447 448 ctx = kzalloc_obj(*ctx, flags); 449 if (!ctx) 450 return NULL; 451 452 /* xhci 7.6.9, all three contexts; info, ep-out and ep-in. Each 64 bytes*/ 453 ctx->size = 3 * DBC_CONTEXT_SIZE; 454 ctx->bytes = dma_alloc_coherent(dev, ctx->size, &ctx->dma, flags); 455 if (!ctx->bytes) { 456 kfree(ctx); 457 return NULL; 458 } 459 return ctx; 460 } 461 462 static void xhci_dbc_ring_init(struct xhci_ring *ring) 463 { 464 struct xhci_segment *seg = ring->first_seg; 465 466 /* clear all trbs on ring in case of old ring */ 467 memset(seg->trbs, 0, TRB_SEGMENT_SIZE); 468 469 /* Only event ring does not use link TRB */ 470 if (ring->type != TYPE_EVENT) { 471 union xhci_trb *trb = &seg->trbs[TRBS_PER_SEGMENT - 1]; 472 473 trb->link.segment_ptr = cpu_to_le64(ring->first_seg->dma); 474 trb->link.control = cpu_to_le32(LINK_TOGGLE | TRB_TYPE(TRB_LINK)); 475 } 476 xhci_initialize_ring_info(ring); 477 } 478 479 static int xhci_dbc_reinit_ep_rings(struct xhci_dbc *dbc) 480 { 481 struct xhci_ring *in_ring = dbc->eps[BULK_IN].ring; 482 struct xhci_ring *out_ring = dbc->eps[BULK_OUT].ring; 483 484 if (!in_ring || !out_ring || !dbc->ctx) { 485 dev_warn(dbc->dev, "Can't re-init unallocated endpoints\n"); 486 return -ENODEV; 487 } 488 489 xhci_dbc_ring_init(in_ring); 490 xhci_dbc_ring_init(out_ring); 491 492 /* set ep context enqueue, dequeue, and cycle to initial values */ 493 xhci_dbc_init_ep_contexts(dbc); 494 495 return 0; 496 } 497 498 static struct xhci_ring * 499 xhci_dbc_ring_alloc(struct device *dev, enum xhci_ring_type type, gfp_t flags) 500 { 501 struct xhci_ring *ring; 502 struct xhci_segment *seg; 503 dma_addr_t dma; 504 505 ring = kzalloc_obj(*ring, flags); 506 if (!ring) 507 return NULL; 508 509 ring->num_segs = 1; 510 ring->type = type; 511 512 seg = kzalloc_obj(*seg, flags); 513 if (!seg) 514 goto seg_fail; 515 516 ring->first_seg = seg; 517 ring->last_seg = seg; 518 seg->next = seg; 519 520 seg->trbs = dma_alloc_coherent(dev, TRB_SEGMENT_SIZE, &dma, flags); 521 if (!seg->trbs) 522 goto dma_fail; 523 524 seg->dma = dma; 525 526 INIT_LIST_HEAD(&ring->td_list); 527 528 xhci_dbc_ring_init(ring); 529 530 return ring; 531 dma_fail: 532 kfree(seg); 533 seg_fail: 534 kfree(ring); 535 return NULL; 536 } 537 538 static int xhci_dbc_mem_init(struct xhci_dbc *dbc, gfp_t flags) 539 { 540 int ret; 541 dma_addr_t deq; 542 struct device *dev = dbc->dev; 543 544 /* Allocate various rings for events and transfers: */ 545 dbc->ring_evt = xhci_dbc_ring_alloc(dev, TYPE_EVENT, flags); 546 if (!dbc->ring_evt) 547 goto evt_fail; 548 549 dbc->ring_in = xhci_dbc_ring_alloc(dev, TYPE_BULK, flags); 550 if (!dbc->ring_in) 551 goto in_fail; 552 553 dbc->ring_out = xhci_dbc_ring_alloc(dev, TYPE_BULK, flags); 554 if (!dbc->ring_out) 555 goto out_fail; 556 557 /* Allocate and populate ERST: */ 558 ret = dbc_erst_alloc(dev, dbc->ring_evt, &dbc->erst, flags); 559 if (ret) 560 goto erst_fail; 561 562 /* Allocate context data structure: */ 563 dbc->ctx = dbc_alloc_ctx(dev, flags); /* was sysdev, and is still */ 564 if (!dbc->ctx) 565 goto ctx_fail; 566 567 /* Allocate the string table: */ 568 dbc->str_descs_size = sizeof(*dbc->str_descs); 569 dbc->str_descs = dma_alloc_coherent(dev, dbc->str_descs_size, 570 &dbc->str_descs_dma, flags); 571 if (!dbc->str_descs) 572 goto str_descs_fail; 573 574 /* Setup ERST register: */ 575 writel(dbc->erst.num_entries, &dbc->regs->ersts); 576 577 lo_hi_writeq(dbc->erst.erst_dma_addr, &dbc->regs->erstba); 578 deq = xhci_trb_virt_to_dma(dbc->ring_evt->deq_seg, 579 dbc->ring_evt->dequeue); 580 lo_hi_writeq(deq, &dbc->regs->erdp); 581 582 /* Setup string descriptors and contexts: */ 583 xhci_dbc_populate_str_descs(dbc->str_descs, &dbc->str); 584 xhci_dbc_init_contexts(dbc); 585 586 xhci_dbc_eps_init(dbc); 587 dbc->state = DS_INITIALIZED; 588 589 return 0; 590 591 str_descs_fail: 592 dbc_free_ctx(dev, dbc->ctx); 593 dbc->ctx = NULL; 594 ctx_fail: 595 dbc_erst_free(dev, &dbc->erst); 596 erst_fail: 597 dbc_ring_free(dev, dbc->ring_out); 598 dbc->ring_out = NULL; 599 out_fail: 600 dbc_ring_free(dev, dbc->ring_in); 601 dbc->ring_in = NULL; 602 in_fail: 603 dbc_ring_free(dev, dbc->ring_evt); 604 dbc->ring_evt = NULL; 605 evt_fail: 606 return -ENOMEM; 607 } 608 609 static void xhci_dbc_mem_cleanup(struct xhci_dbc *dbc) 610 { 611 if (!dbc) 612 return; 613 614 xhci_dbc_eps_exit(dbc); 615 616 dma_free_coherent(dbc->dev, dbc->str_descs_size, dbc->str_descs, dbc->str_descs_dma); 617 dbc->str_descs = NULL; 618 619 dbc_free_ctx(dbc->dev, dbc->ctx); 620 dbc->ctx = NULL; 621 622 dbc_erst_free(dbc->dev, &dbc->erst); 623 dbc_ring_free(dbc->dev, dbc->ring_out); 624 dbc_ring_free(dbc->dev, dbc->ring_in); 625 dbc_ring_free(dbc->dev, dbc->ring_evt); 626 dbc->ring_in = NULL; 627 dbc->ring_out = NULL; 628 dbc->ring_evt = NULL; 629 } 630 631 static int xhci_dbc_enable_dce(struct xhci_dbc *dbc, bool enable) 632 { 633 u32 done_state = 0; 634 u32 ctrl = 0; 635 636 if (enable) { 637 ctrl = readl(&dbc->regs->control); 638 ctrl |= DBC_CTRL_DBC_ENABLE | DBC_CTRL_PORT_ENABLE; 639 done_state = DBC_CTRL_DBC_ENABLE; 640 } 641 642 writel(ctrl, &dbc->regs->control); 643 return xhci_handshake(&dbc->regs->control, DBC_CTRL_DBC_ENABLE, 644 done_state, 1000); 645 } 646 647 static void xhci_dbc_set_state(struct xhci_dbc *dbc, enum dbc_state new_state) 648 { 649 dbc->state_timestamp = jiffies; 650 dbc->state = new_state; 651 } 652 653 static int xhci_do_dbc_start(struct xhci_dbc *dbc) 654 { 655 int ret; 656 657 if (dbc->state != DS_DISABLED) 658 return -EINVAL; 659 660 ret = xhci_dbc_enable_dce(dbc, false); 661 if (ret) 662 return ret; 663 664 ret = xhci_dbc_mem_init(dbc, GFP_ATOMIC); 665 if (ret) 666 return ret; 667 668 ret = xhci_dbc_enable_dce(dbc, true); 669 if (ret) 670 return ret; 671 672 xhci_dbc_set_state(dbc, DS_ENABLED); 673 674 return 0; 675 } 676 677 static int xhci_dbc_start(struct xhci_dbc *dbc) 678 { 679 int ret; 680 unsigned long flags; 681 682 WARN_ON(!dbc); 683 684 pm_runtime_get_sync(dbc->dev); /* note this was self.controller */ 685 686 spin_lock_irqsave(&dbc->lock, flags); 687 ret = xhci_do_dbc_start(dbc); 688 if (ret) 689 goto err_unlock; 690 691 spin_unlock_irqrestore(&dbc->lock, flags); 692 693 mod_delayed_work(system_percpu_wq, &dbc->event_work, 694 msecs_to_jiffies(dbc->poll_interval)); 695 696 return 0; 697 698 err_unlock: 699 700 spin_unlock_irqrestore(&dbc->lock, flags); 701 pm_runtime_put(dbc->dev); /* note this was self.controller */ 702 703 return ret; 704 } 705 706 static void xhci_dbc_stop(struct xhci_dbc *dbc) 707 { 708 unsigned long flags; 709 710 WARN_ON(!dbc); 711 712 spin_lock(&dbc->lock); 713 714 switch (dbc->state) { 715 case DS_DISABLED: 716 spin_unlock(&dbc->lock); 717 return; 718 case DS_CONFIGURED: 719 xhci_dbc_flush_requests(dbc); 720 spin_unlock(&dbc->lock); 721 722 if (dbc->driver->disconnect) 723 dbc->driver->disconnect(dbc); 724 break; 725 default: 726 spin_unlock(&dbc->lock); 727 break; 728 } 729 730 cancel_delayed_work_sync(&dbc->event_work); 731 732 spin_lock_irqsave(&dbc->lock, flags); 733 writel(0, &dbc->regs->control); 734 xhci_dbc_set_state(dbc, DS_DISABLED); 735 spin_unlock_irqrestore(&dbc->lock, flags); 736 737 xhci_dbc_mem_cleanup(dbc); 738 739 pm_runtime_put(dbc->dev); /* note, was self.controller */ 740 } 741 742 static void 743 handle_ep_halt_changes(struct xhci_dbc *dbc, struct dbc_ep *dep, bool halted) 744 { 745 if (halted) { 746 dev_info(dbc->dev, "DbC Endpoint halted\n"); 747 dep->halted = 1; 748 749 } else if (dep->halted) { 750 dev_info(dbc->dev, "DbC Endpoint halt cleared\n"); 751 dep->halted = 0; 752 753 if (!list_empty(&dep->list_pending)) 754 writel(DBC_DOOR_BELL_TARGET(dep->direction), 755 &dbc->regs->doorbell); 756 } 757 } 758 759 static void 760 dbc_handle_port_status(struct xhci_dbc *dbc, union xhci_trb *event) 761 { 762 u32 portsc; 763 764 portsc = readl(&dbc->regs->portsc); 765 if (portsc & DBC_PORTSC_CONN_CHANGE) 766 dev_info(dbc->dev, "DbC port connect change\n"); 767 768 if (portsc & DBC_PORTSC_RESET_CHANGE) 769 dev_info(dbc->dev, "DbC port reset change\n"); 770 771 if (portsc & DBC_PORTSC_LINK_CHANGE) 772 dev_info(dbc->dev, "DbC port link status change\n"); 773 774 if (portsc & DBC_PORTSC_CONFIG_CHANGE) 775 dev_info(dbc->dev, "DbC config error change\n"); 776 777 /* Port reset change bit will be cleared in other place: */ 778 writel(portsc & ~DBC_PORTSC_RESET_CHANGE, &dbc->regs->portsc); 779 } 780 781 static void dbc_handle_xfer_event(struct xhci_dbc *dbc, union xhci_trb *event) 782 { 783 struct dbc_ep *dep; 784 struct xhci_ring *ring; 785 int ep_id; 786 int status; 787 struct xhci_ep_ctx *ep_ctx; 788 u32 comp_code; 789 size_t remain_length; 790 struct dbc_request *req = NULL, *r; 791 792 comp_code = GET_COMP_CODE(le32_to_cpu(event->generic.field[2])); 793 remain_length = EVENT_TRB_LEN(le32_to_cpu(event->generic.field[2])); 794 ep_id = TRB_TO_EP_ID(le32_to_cpu(event->generic.field[3])); 795 dep = (ep_id == EPID_OUT) ? 796 get_out_ep(dbc) : get_in_ep(dbc); 797 ep_ctx = (ep_id == EPID_OUT) ? 798 dbc_bulkout_ctx(dbc) : dbc_bulkin_ctx(dbc); 799 ring = dep->ring; 800 801 /* Match the pending request: */ 802 list_for_each_entry(r, &dep->list_pending, list_pending) { 803 if (r->trb_dma == event->trans_event.buffer) { 804 req = r; 805 break; 806 } 807 if (r->status == -COMP_STALL_ERROR) { 808 dev_warn(dbc->dev, "Give back stale stalled req\n"); 809 xhci_dbc_giveback(r, 0); 810 } 811 } 812 813 if (!req) { 814 dev_warn(dbc->dev, "no matched request\n"); 815 return; 816 } 817 818 trace_xhci_dbc_handle_transfer(ring, &req->trb->generic, req->trb_dma); 819 820 switch (comp_code) { 821 case COMP_SUCCESS: 822 remain_length = 0; 823 fallthrough; 824 case COMP_SHORT_PACKET: 825 status = 0; 826 break; 827 case COMP_TRB_ERROR: 828 case COMP_BABBLE_DETECTED_ERROR: 829 case COMP_USB_TRANSACTION_ERROR: 830 dev_warn(dbc->dev, "tx error %d detected\n", comp_code); 831 status = -comp_code; 832 break; 833 case COMP_STALL_ERROR: 834 dev_warn(dbc->dev, "Stall error at bulk TRB %llx, remaining %zu, ep deq %llx\n", 835 event->trans_event.buffer, remain_length, ep_ctx->deq); 836 status = 0; 837 dep->halted = 1; 838 839 /* 840 * xHC DbC may trigger a STALL bulk xfer event when host sends a 841 * ClearFeature(ENDPOINT_HALT) request even if there wasn't an 842 * active bulk transfer. 843 * 844 * Don't give back this transfer request as hardware will later 845 * start processing TRBs starting from this 'STALLED' TRB, 846 * causing TRBs and requests to be out of sync. 847 * 848 * If STALL event shows some bytes were transferred then assume 849 * it's an actual transfer issue and give back the request. 850 * In this case mark the TRB as No-Op to avoid hw from using the 851 * TRB again. 852 */ 853 854 if ((ep_ctx->deq & ~TRB_CYCLE) == event->trans_event.buffer) { 855 dev_dbg(dbc->dev, "Ep stopped on Stalled TRB\n"); 856 if (remain_length == req->length) { 857 dev_dbg(dbc->dev, "Spurious stall event, keep req\n"); 858 req->status = -COMP_STALL_ERROR; 859 req->actual = 0; 860 return; 861 } 862 dev_dbg(dbc->dev, "Give back stalled req, but turn TRB to No-op\n"); 863 trb_to_noop(req->trb); 864 } 865 break; 866 867 default: 868 dev_err(dbc->dev, "unknown tx error %d\n", comp_code); 869 status = -comp_code; 870 break; 871 } 872 873 req->actual = req->length - remain_length; 874 xhci_dbc_giveback(req, status); 875 } 876 877 static void inc_evt_deq(struct xhci_ring *ring) 878 { 879 /* If on the last TRB of the segment go back to the beginning */ 880 if (ring->dequeue == &ring->deq_seg->trbs[TRBS_PER_SEGMENT - 1]) { 881 ring->cycle_state ^= 1; 882 ring->dequeue = ring->deq_seg->trbs; 883 return; 884 } 885 ring->dequeue++; 886 } 887 888 static enum evtreturn xhci_dbc_do_handle_events(struct xhci_dbc *dbc) 889 { 890 dma_addr_t deq; 891 union xhci_trb *evt; 892 enum evtreturn ret = EVT_DONE; 893 u32 ctrl, portsc; 894 bool update_erdp = false; 895 896 /* DbC state machine: */ 897 switch (dbc->state) { 898 case DS_DISABLED: 899 case DS_INITIALIZED: 900 901 return EVT_ERR; 902 case DS_ENABLED: 903 portsc = readl(&dbc->regs->portsc); 904 ctrl = readl(&dbc->regs->control); 905 906 if (portsc & DBC_PORTSC_CONN_STATUS) { 907 xhci_dbc_set_state(dbc, DS_CONNECTED); 908 dev_info(dbc->dev, "DbC connected\n"); 909 } else if (!(ctrl & DBC_CTRL_DBC_ENABLE)) { 910 dev_err(dbc->dev, "unexpected DbC disable, xHC reset?\n"); 911 } 912 913 return EVT_DONE; 914 case DS_CONNECTED: 915 ctrl = readl(&dbc->regs->control); 916 portsc = readl(&dbc->regs->portsc); 917 if (ctrl & DBC_CTRL_DBC_RUN) { 918 xhci_dbc_set_state(dbc, DS_CONFIGURED); 919 dev_info(dbc->dev, "DbC configured\n"); 920 writel(portsc, &dbc->regs->portsc); 921 ret = EVT_GSER; 922 break; 923 } 924 925 /* Connection lost */ 926 if (!(portsc & DBC_PORTSC_CONN_STATUS)) { 927 /* covers DCE == 0 as it also sets CONN_STATUS to 0 */ 928 dev_warn(dbc->dev, "DbC connection lost mid enumeration\n"); 929 xhci_dbc_set_state(dbc, DS_ENABLED); 930 931 return EVT_DONE; 932 } 933 934 /* Enumeration timeout */ 935 if (time_is_before_jiffies(dbc->state_timestamp + 936 msecs_to_jiffies(DBC_ENUMERATION_TIMEOUT))) { 937 dev_err(dbc->dev, "DbC enumeration timeout, re-enabling DbC\n"); 938 dev_dbg(dbc->dev, "dcctrl %x, dcportsc %x\n", ctrl, portsc); 939 940 /* Toggle DCE to retry enumeration */ 941 ret = xhci_dbc_enable_dce(dbc, false); 942 udelay(100); 943 ret = xhci_dbc_enable_dce(dbc, true); 944 xhci_dbc_set_state(dbc, DS_ENABLED); 945 } 946 947 return EVT_DONE; 948 case DS_CONFIGURED: 949 /* Handle cable unplug event: */ 950 portsc = readl(&dbc->regs->portsc); 951 if (!(portsc & DBC_PORTSC_PORT_ENABLED) && 952 !(portsc & DBC_PORTSC_CONN_STATUS)) { 953 dev_info(dbc->dev, "DbC cable unplugged\n"); 954 xhci_dbc_set_state(dbc, DS_ENABLED); 955 xhci_dbc_flush_requests(dbc); 956 xhci_dbc_reinit_ep_rings(dbc); 957 return EVT_DISC; 958 } 959 960 /* Handle debug port reset event: */ 961 if (portsc & DBC_PORTSC_RESET_CHANGE) { 962 dev_info(dbc->dev, "DbC port reset\n"); 963 writel(portsc, &dbc->regs->portsc); 964 xhci_dbc_set_state(dbc, DS_ENABLED); 965 xhci_dbc_flush_requests(dbc); 966 xhci_dbc_reinit_ep_rings(dbc); 967 return EVT_DISC; 968 } 969 970 /* Check and handle changes in endpoint halt status */ 971 ctrl = readl(&dbc->regs->control); 972 handle_ep_halt_changes(dbc, get_in_ep(dbc), ctrl & DBC_CTRL_HALT_IN_TR); 973 handle_ep_halt_changes(dbc, get_out_ep(dbc), ctrl & DBC_CTRL_HALT_OUT_TR); 974 975 /* Clear DbC run change bit: */ 976 if (ctrl & DBC_CTRL_DBC_RUN_CHANGE) { 977 writel(ctrl, &dbc->regs->control); 978 ctrl = readl(&dbc->regs->control); 979 } 980 break; 981 default: 982 dev_err(dbc->dev, "Unknown DbC state %d\n", dbc->state); 983 break; 984 } 985 986 /* Handle the events in the event ring: */ 987 evt = dbc->ring_evt->dequeue; 988 while ((le32_to_cpu(evt->event_cmd.flags) & TRB_CYCLE) == 989 dbc->ring_evt->cycle_state) { 990 /* 991 * Add a barrier between reading the cycle flag and any 992 * reads of the event's flags/data below: 993 */ 994 rmb(); 995 996 trace_xhci_dbc_handle_event(dbc->ring_evt, &evt->generic, 997 xhci_trb_virt_to_dma(dbc->ring_evt->deq_seg, 998 dbc->ring_evt->dequeue)); 999 1000 switch (le32_to_cpu(evt->event_cmd.flags) & TRB_TYPE_BITMASK) { 1001 case TRB_TYPE(TRB_PORT_STATUS): 1002 dbc_handle_port_status(dbc, evt); 1003 break; 1004 case TRB_TYPE(TRB_TRANSFER): 1005 dbc_handle_xfer_event(dbc, evt); 1006 if (ret != EVT_GSER) 1007 ret = EVT_XFER_DONE; 1008 break; 1009 default: 1010 break; 1011 } 1012 1013 inc_evt_deq(dbc->ring_evt); 1014 1015 evt = dbc->ring_evt->dequeue; 1016 update_erdp = true; 1017 } 1018 1019 /* Update event ring dequeue pointer: */ 1020 if (update_erdp) { 1021 deq = xhci_trb_virt_to_dma(dbc->ring_evt->deq_seg, 1022 dbc->ring_evt->dequeue); 1023 lo_hi_writeq(deq, &dbc->regs->erdp); 1024 } 1025 1026 return ret; 1027 } 1028 1029 static void xhci_dbc_handle_events(struct work_struct *work) 1030 { 1031 enum evtreturn evtr; 1032 struct xhci_dbc *dbc; 1033 unsigned long flags; 1034 unsigned int poll_interval; 1035 unsigned long busypoll_timelimit; 1036 1037 dbc = container_of(to_delayed_work(work), struct xhci_dbc, event_work); 1038 poll_interval = dbc->poll_interval; 1039 1040 spin_lock_irqsave(&dbc->lock, flags); 1041 evtr = xhci_dbc_do_handle_events(dbc); 1042 spin_unlock_irqrestore(&dbc->lock, flags); 1043 1044 switch (evtr) { 1045 case EVT_GSER: 1046 if (dbc->driver->configure) 1047 dbc->driver->configure(dbc); 1048 break; 1049 case EVT_DISC: 1050 if (dbc->driver->disconnect) 1051 dbc->driver->disconnect(dbc); 1052 break; 1053 case EVT_DONE: 1054 /* 1055 * Set fast poll rate if there are pending out transfers, or 1056 * a transfer was recently processed 1057 */ 1058 busypoll_timelimit = dbc->xfer_timestamp + 1059 msecs_to_jiffies(DBC_XFER_INACTIVITY_TIMEOUT); 1060 1061 if (!list_empty(&dbc->eps[BULK_OUT].list_pending) || 1062 time_is_after_jiffies(busypoll_timelimit)) 1063 poll_interval = 0; 1064 break; 1065 case EVT_XFER_DONE: 1066 dbc->xfer_timestamp = jiffies; 1067 poll_interval = 0; 1068 break; 1069 default: 1070 dev_info(dbc->dev, "stop handling dbc events\n"); 1071 return; 1072 } 1073 1074 mod_delayed_work(system_percpu_wq, &dbc->event_work, 1075 msecs_to_jiffies(poll_interval)); 1076 } 1077 1078 static const char * const dbc_state_strings[DS_MAX] = { 1079 [DS_DISABLED] = "disabled", 1080 [DS_INITIALIZED] = "initialized", 1081 [DS_ENABLED] = "enabled", 1082 [DS_CONNECTED] = "connected", 1083 [DS_CONFIGURED] = "configured", 1084 }; 1085 1086 static ssize_t dbc_show(struct device *dev, 1087 struct device_attribute *attr, 1088 char *buf) 1089 { 1090 struct xhci_dbc *dbc; 1091 struct xhci_hcd *xhci; 1092 1093 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1094 dbc = xhci->dbc; 1095 1096 if (dbc->state >= ARRAY_SIZE(dbc_state_strings)) 1097 return sysfs_emit(buf, "unknown\n"); 1098 1099 return sysfs_emit(buf, "%s\n", dbc_state_strings[dbc->state]); 1100 } 1101 1102 static ssize_t dbc_store(struct device *dev, 1103 struct device_attribute *attr, 1104 const char *buf, size_t count) 1105 { 1106 struct xhci_hcd *xhci; 1107 struct xhci_dbc *dbc; 1108 1109 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1110 dbc = xhci->dbc; 1111 1112 if (sysfs_streq(buf, "enable")) { 1113 mutex_lock(&dbc->enable_mutex); 1114 xhci_dbc_start(dbc); 1115 mutex_unlock(&dbc->enable_mutex); 1116 } else if (sysfs_streq(buf, "disable")) { 1117 mutex_lock(&dbc->enable_mutex); 1118 xhci_dbc_stop(dbc); 1119 mutex_unlock(&dbc->enable_mutex); 1120 } else { 1121 return -EINVAL; 1122 } 1123 1124 return count; 1125 } 1126 1127 static ssize_t dbc_idVendor_show(struct device *dev, 1128 struct device_attribute *attr, 1129 char *buf) 1130 { 1131 struct xhci_dbc *dbc; 1132 struct xhci_hcd *xhci; 1133 1134 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1135 dbc = xhci->dbc; 1136 1137 return sysfs_emit(buf, "%04x\n", dbc->idVendor); 1138 } 1139 1140 static ssize_t dbc_idVendor_store(struct device *dev, 1141 struct device_attribute *attr, 1142 const char *buf, size_t size) 1143 { 1144 struct xhci_dbc *dbc; 1145 struct xhci_hcd *xhci; 1146 void __iomem *ptr; 1147 u16 value; 1148 u32 dev_info; 1149 int ret; 1150 1151 ret = kstrtou16(buf, 0, &value); 1152 if (ret) 1153 return ret; 1154 1155 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1156 dbc = xhci->dbc; 1157 if (dbc->state != DS_DISABLED) 1158 return -EBUSY; 1159 1160 dbc->idVendor = value; 1161 ptr = &dbc->regs->devinfo1; 1162 dev_info = readl(ptr); 1163 dev_info = (dev_info & ~(0xffffu << 16)) | (value << 16); 1164 writel(dev_info, ptr); 1165 1166 return size; 1167 } 1168 1169 static ssize_t dbc_idProduct_show(struct device *dev, 1170 struct device_attribute *attr, 1171 char *buf) 1172 { 1173 struct xhci_dbc *dbc; 1174 struct xhci_hcd *xhci; 1175 1176 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1177 dbc = xhci->dbc; 1178 1179 return sysfs_emit(buf, "%04x\n", dbc->idProduct); 1180 } 1181 1182 static ssize_t dbc_idProduct_store(struct device *dev, 1183 struct device_attribute *attr, 1184 const char *buf, size_t size) 1185 { 1186 struct xhci_dbc *dbc; 1187 struct xhci_hcd *xhci; 1188 void __iomem *ptr; 1189 u32 dev_info; 1190 u16 value; 1191 int ret; 1192 1193 ret = kstrtou16(buf, 0, &value); 1194 if (ret) 1195 return ret; 1196 1197 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1198 dbc = xhci->dbc; 1199 if (dbc->state != DS_DISABLED) 1200 return -EBUSY; 1201 1202 dbc->idProduct = value; 1203 ptr = &dbc->regs->devinfo2; 1204 dev_info = readl(ptr); 1205 dev_info = (dev_info & ~(0xffffu)) | value; 1206 writel(dev_info, ptr); 1207 return size; 1208 } 1209 1210 static ssize_t dbc_bcdDevice_show(struct device *dev, 1211 struct device_attribute *attr, 1212 char *buf) 1213 { 1214 struct xhci_dbc *dbc; 1215 struct xhci_hcd *xhci; 1216 1217 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1218 dbc = xhci->dbc; 1219 1220 return sysfs_emit(buf, "%04x\n", dbc->bcdDevice); 1221 } 1222 1223 static ssize_t dbc_bcdDevice_store(struct device *dev, 1224 struct device_attribute *attr, 1225 const char *buf, size_t size) 1226 { 1227 struct xhci_dbc *dbc; 1228 struct xhci_hcd *xhci; 1229 void __iomem *ptr; 1230 u32 dev_info; 1231 u16 value; 1232 int ret; 1233 1234 ret = kstrtou16(buf, 0, &value); 1235 if (ret) 1236 return ret; 1237 1238 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1239 dbc = xhci->dbc; 1240 if (dbc->state != DS_DISABLED) 1241 return -EBUSY; 1242 1243 dbc->bcdDevice = value; 1244 ptr = &dbc->regs->devinfo2; 1245 dev_info = readl(ptr); 1246 dev_info = (dev_info & ~(0xffffu << 16)) | (value << 16); 1247 writel(dev_info, ptr); 1248 1249 return size; 1250 } 1251 1252 static ssize_t dbc_manufacturer_show(struct device *dev, 1253 struct device_attribute *attr, 1254 char *buf) 1255 { 1256 struct xhci_hcd *xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1257 struct xhci_dbc *dbc = xhci->dbc; 1258 1259 return sysfs_emit(buf, "%s\n", dbc->str.manufacturer); 1260 } 1261 1262 static ssize_t dbc_manufacturer_store(struct device *dev, 1263 struct device_attribute *attr, 1264 const char *buf, size_t size) 1265 { 1266 struct xhci_hcd *xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1267 struct xhci_dbc *dbc = xhci->dbc; 1268 size_t len; 1269 1270 if (dbc->state != DS_DISABLED) 1271 return -EBUSY; 1272 1273 len = strcspn(buf, "\n"); 1274 if (!len) 1275 return -EINVAL; 1276 1277 if (len > USB_MAX_STRING_LEN) 1278 return -E2BIG; 1279 1280 memcpy(dbc->str.manufacturer, buf, len); 1281 dbc->str.manufacturer[len] = '\0'; 1282 1283 return size; 1284 } 1285 1286 static ssize_t dbc_product_show(struct device *dev, 1287 struct device_attribute *attr, 1288 char *buf) 1289 { 1290 struct xhci_hcd *xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1291 struct xhci_dbc *dbc = xhci->dbc; 1292 1293 return sysfs_emit(buf, "%s\n", dbc->str.product); 1294 } 1295 1296 static ssize_t dbc_product_store(struct device *dev, 1297 struct device_attribute *attr, 1298 const char *buf, size_t size) 1299 { 1300 struct xhci_hcd *xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1301 struct xhci_dbc *dbc = xhci->dbc; 1302 size_t len; 1303 1304 if (dbc->state != DS_DISABLED) 1305 return -EBUSY; 1306 1307 len = strcspn(buf, "\n"); 1308 if (!len) 1309 return -EINVAL; 1310 1311 if (len > USB_MAX_STRING_LEN) 1312 return -E2BIG; 1313 1314 memcpy(dbc->str.product, buf, len); 1315 dbc->str.product[len] = '\0'; 1316 1317 return size; 1318 } 1319 1320 static ssize_t dbc_serial_show(struct device *dev, 1321 struct device_attribute *attr, 1322 char *buf) 1323 { 1324 struct xhci_hcd *xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1325 struct xhci_dbc *dbc = xhci->dbc; 1326 1327 return sysfs_emit(buf, "%s\n", dbc->str.serial); 1328 } 1329 1330 static ssize_t dbc_serial_store(struct device *dev, 1331 struct device_attribute *attr, 1332 const char *buf, size_t size) 1333 { 1334 struct xhci_hcd *xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1335 struct xhci_dbc *dbc = xhci->dbc; 1336 size_t len; 1337 1338 if (dbc->state != DS_DISABLED) 1339 return -EBUSY; 1340 1341 len = strcspn(buf, "\n"); 1342 if (!len) 1343 return -EINVAL; 1344 1345 if (len > USB_MAX_STRING_LEN) 1346 return -E2BIG; 1347 1348 memcpy(dbc->str.serial, buf, len); 1349 dbc->str.serial[len] = '\0'; 1350 1351 return size; 1352 } 1353 1354 static ssize_t dbc_bInterfaceProtocol_show(struct device *dev, 1355 struct device_attribute *attr, 1356 char *buf) 1357 { 1358 struct xhci_dbc *dbc; 1359 struct xhci_hcd *xhci; 1360 1361 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1362 dbc = xhci->dbc; 1363 1364 return sysfs_emit(buf, "%02x\n", dbc->bInterfaceProtocol); 1365 } 1366 1367 static ssize_t dbc_bInterfaceProtocol_store(struct device *dev, 1368 struct device_attribute *attr, 1369 const char *buf, size_t size) 1370 { 1371 struct xhci_dbc *dbc; 1372 struct xhci_hcd *xhci; 1373 void __iomem *ptr; 1374 u32 dev_info; 1375 u8 value; 1376 int ret; 1377 1378 /* bInterfaceProtocol is 8 bit, but... */ 1379 ret = kstrtou8(buf, 0, &value); 1380 if (ret) 1381 return ret; 1382 1383 /* ...xhci only supports values 0 and 1 */ 1384 if (value > 1) 1385 return -EINVAL; 1386 1387 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1388 dbc = xhci->dbc; 1389 if (dbc->state != DS_DISABLED) 1390 return -EBUSY; 1391 1392 dbc->bInterfaceProtocol = value; 1393 ptr = &dbc->regs->devinfo1; 1394 dev_info = readl(ptr); 1395 dev_info = (dev_info & ~(0xffu)) | value; 1396 writel(dev_info, ptr); 1397 1398 return size; 1399 } 1400 1401 static ssize_t dbc_poll_interval_ms_show(struct device *dev, 1402 struct device_attribute *attr, 1403 char *buf) 1404 { 1405 struct xhci_dbc *dbc; 1406 struct xhci_hcd *xhci; 1407 1408 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1409 dbc = xhci->dbc; 1410 1411 return sysfs_emit(buf, "%u\n", dbc->poll_interval); 1412 } 1413 1414 static ssize_t dbc_poll_interval_ms_store(struct device *dev, 1415 struct device_attribute *attr, 1416 const char *buf, size_t size) 1417 { 1418 struct xhci_dbc *dbc; 1419 struct xhci_hcd *xhci; 1420 u32 value; 1421 int ret; 1422 1423 ret = kstrtou32(buf, 0, &value); 1424 if (ret || value > DBC_POLL_INTERVAL_MAX) 1425 return -EINVAL; 1426 1427 xhci = hcd_to_xhci(dev_get_drvdata(dev)); 1428 dbc = xhci->dbc; 1429 1430 dbc->poll_interval = value; 1431 1432 mod_delayed_work(system_percpu_wq, &dbc->event_work, 0); 1433 1434 return size; 1435 } 1436 1437 static DEVICE_ATTR_RW(dbc); 1438 static DEVICE_ATTR_RW(dbc_idVendor); 1439 static DEVICE_ATTR_RW(dbc_idProduct); 1440 static DEVICE_ATTR_RW(dbc_bcdDevice); 1441 static DEVICE_ATTR_RW(dbc_serial); 1442 static DEVICE_ATTR_RW(dbc_product); 1443 static DEVICE_ATTR_RW(dbc_manufacturer); 1444 static DEVICE_ATTR_RW(dbc_bInterfaceProtocol); 1445 static DEVICE_ATTR_RW(dbc_poll_interval_ms); 1446 1447 static struct attribute *dbc_dev_attrs[] = { 1448 &dev_attr_dbc.attr, 1449 &dev_attr_dbc_idVendor.attr, 1450 &dev_attr_dbc_idProduct.attr, 1451 &dev_attr_dbc_bcdDevice.attr, 1452 &dev_attr_dbc_serial.attr, 1453 &dev_attr_dbc_product.attr, 1454 &dev_attr_dbc_manufacturer.attr, 1455 &dev_attr_dbc_bInterfaceProtocol.attr, 1456 &dev_attr_dbc_poll_interval_ms.attr, 1457 NULL 1458 }; 1459 ATTRIBUTE_GROUPS(dbc_dev); 1460 1461 struct xhci_dbc * 1462 xhci_alloc_dbc(struct device *dev, void __iomem *base, const struct dbc_driver *driver) 1463 { 1464 struct xhci_dbc *dbc; 1465 int ret; 1466 1467 dbc = kzalloc_obj(*dbc); 1468 if (!dbc) 1469 return NULL; 1470 1471 dbc->regs = base; 1472 dbc->dev = dev; 1473 dbc->driver = driver; 1474 dbc->idProduct = DBC_PRODUCT_ID; 1475 dbc->idVendor = DBC_VENDOR_ID; 1476 dbc->bcdDevice = DBC_DEVICE_REV; 1477 dbc->bInterfaceProtocol = DBC_PROTOCOL; 1478 dbc->poll_interval = DBC_POLL_INTERVAL_DEFAULT; 1479 1480 /* initialize serial, product and manufacturer with default values */ 1481 dbc->str = dbc_str_default; 1482 1483 if (readl(&dbc->regs->control) & DBC_CTRL_DBC_ENABLE) 1484 goto err; 1485 1486 INIT_DELAYED_WORK(&dbc->event_work, xhci_dbc_handle_events); 1487 spin_lock_init(&dbc->lock); 1488 mutex_init(&dbc->enable_mutex); 1489 1490 ret = sysfs_create_groups(&dev->kobj, dbc_dev_groups); 1491 if (ret) 1492 goto err; 1493 1494 return dbc; 1495 err: 1496 kfree(dbc); 1497 return NULL; 1498 } 1499 1500 /* undo what xhci_alloc_dbc() did */ 1501 void xhci_dbc_remove(struct xhci_dbc *dbc) 1502 { 1503 if (!dbc) 1504 return; 1505 /* stop hw, stop wq and call dbc->ops->stop() */ 1506 mutex_lock(&dbc->enable_mutex); 1507 xhci_dbc_stop(dbc); 1508 mutex_unlock(&dbc->enable_mutex); 1509 /* remove sysfs files */ 1510 sysfs_remove_groups(&dbc->dev->kobj, dbc_dev_groups); 1511 1512 kfree(dbc); 1513 } 1514 1515 1516 int xhci_create_dbc_dev(struct xhci_hcd *xhci) 1517 { 1518 struct device *dev; 1519 void __iomem *base; 1520 int ret; 1521 int dbc_cap_offs; 1522 1523 /* create all parameters needed resembling a dbc device */ 1524 dev = xhci_to_hcd(xhci)->self.controller; 1525 base = &xhci->cap_regs->hc_capbase; 1526 1527 dbc_cap_offs = xhci_find_next_ext_cap(base, 0, XHCI_EXT_CAPS_DEBUG); 1528 if (!dbc_cap_offs) 1529 return -ENODEV; 1530 1531 /* already allocated and in use */ 1532 if (xhci->dbc) 1533 return -EBUSY; 1534 1535 ret = xhci_dbc_tty_probe(dev, base + dbc_cap_offs, xhci); 1536 1537 return ret; 1538 } 1539 1540 void xhci_remove_dbc_dev(struct xhci_hcd *xhci) 1541 { 1542 unsigned long flags; 1543 1544 if (!xhci->dbc) 1545 return; 1546 1547 xhci_dbc_tty_remove(xhci->dbc); 1548 spin_lock_irqsave(&xhci->lock, flags); 1549 xhci->dbc = NULL; 1550 spin_unlock_irqrestore(&xhci->lock, flags); 1551 } 1552 1553 #ifdef CONFIG_PM 1554 int xhci_dbc_suspend(struct xhci_hcd *xhci) 1555 { 1556 struct xhci_dbc *dbc = xhci->dbc; 1557 1558 if (!dbc) 1559 return 0; 1560 1561 mutex_lock(&dbc->enable_mutex); 1562 1563 switch (dbc->state) { 1564 case DS_ENABLED: 1565 case DS_CONNECTED: 1566 case DS_CONFIGURED: 1567 dbc->resume_required = 1; 1568 break; 1569 default: 1570 break; 1571 } 1572 1573 xhci_dbc_stop(dbc); 1574 mutex_unlock(&dbc->enable_mutex); 1575 1576 return 0; 1577 } 1578 1579 int xhci_dbc_resume(struct xhci_hcd *xhci) 1580 { 1581 int ret = 0; 1582 struct xhci_dbc *dbc = xhci->dbc; 1583 1584 if (!dbc) 1585 return 0; 1586 1587 mutex_lock(&dbc->enable_mutex); 1588 1589 if (dbc->resume_required) { 1590 dbc->resume_required = 0; 1591 xhci_dbc_start(dbc); 1592 } 1593 1594 mutex_unlock(&dbc->enable_mutex); 1595 1596 return ret; 1597 } 1598 #endif /* CONFIG_PM */ 1599 1600 int xhci_dbc_init(void) 1601 { 1602 return dbc_tty_init(); 1603 } 1604 1605 void xhci_dbc_exit(void) 1606 { 1607 dbc_tty_exit(); 1608 } 1609