drivers/usb/host/xhci-dbgcap.c

   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 <[email protected]>
   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 void dbc_free_ctx(struct device *dev, struct xhci_container_ctx *ctx)
  33 {
  34         if (!ctx)
  35                 return;
  36         dma_free_coherent(dev, ctx->size, ctx->bytes, ctx->dma);
  37         kfree(ctx);
  38 }
  39
  40 /* we use only one segment for DbC rings */
  41 static void dbc_ring_free(struct device *dev, struct xhci_ring *ring)
  42 {
  43         if (!ring)
  44                 return;
  45
  46         if (ring->first_seg) {
  47                 dma_free_coherent(dev, TRB_SEGMENT_SIZE,
  48                                   ring->first_seg->trbs,
  49                                   ring->first_seg->dma);
  50                 kfree(ring->first_seg);
  51         }
  52         kfree(ring);
  53 }
  54
  55 static u32 xhci_dbc_populate_strings(struct dbc_str_descs *strings)
  56 {
  57         struct usb_string_descriptor    *s_desc;
  58         u32                             string_length;
  59
  60         /* Serial string: */
  61         s_desc = (struct usb_string_descriptor *)strings->serial;
  62         utf8s_to_utf16s(DBC_STRING_SERIAL, strlen(DBC_STRING_SERIAL),
  63                         UTF16_LITTLE_ENDIAN, (wchar_t *)s_desc->wData,
  64                         DBC_MAX_STRING_LENGTH);
  65
  66         s_desc->bLength         = (strlen(DBC_STRING_SERIAL) + 1) * 2;
  67         s_desc->bDescriptorType = USB_DT_STRING;
  68         string_length           = s_desc->bLength;
  69         string_length           <<= 8;
  70
  71         /* Product string: */
  72         s_desc = (struct usb_string_descriptor *)strings->product;
  73         utf8s_to_utf16s(DBC_STRING_PRODUCT, strlen(DBC_STRING_PRODUCT),
  74                         UTF16_LITTLE_ENDIAN, (wchar_t *)s_desc->wData,
  75                         DBC_MAX_STRING_LENGTH);
  76
  77         s_desc->bLength         = (strlen(DBC_STRING_PRODUCT) + 1) * 2;
  78         s_desc->bDescriptorType = USB_DT_STRING;
  79         string_length           += s_desc->bLength;
  80         string_length           <<= 8;
  81
  82         /* Manufacture string: */
  83         s_desc = (struct usb_string_descriptor *)strings->manufacturer;
  84         utf8s_to_utf16s(DBC_STRING_MANUFACTURER,
  85                         strlen(DBC_STRING_MANUFACTURER),
  86                         UTF16_LITTLE_ENDIAN, (wchar_t *)s_desc->wData,
  87                         DBC_MAX_STRING_LENGTH);
  88
  89         s_desc->bLength         = (strlen(DBC_STRING_MANUFACTURER) + 1) * 2;
  90         s_desc->bDescriptorType = USB_DT_STRING;
  91         string_length           += s_desc->bLength;
  92         string_length           <<= 8;
  93
  94         /* String0: */
  95         strings->string0[0]     = 4;
  96         strings->string0[1]     = USB_DT_STRING;
  97         strings->string0[2]     = 0x09;
  98         strings->string0[3]     = 0x04;
  99         string_length           += 4;
 100
 101         return string_length;
 102 }
 103
 104 static void xhci_dbc_init_contexts(struct xhci_dbc *dbc, u32 string_length)
 105 {
 106         struct dbc_info_context *info;
 107         struct xhci_ep_ctx      *ep_ctx;
 108         u32                     dev_info;
 109         dma_addr_t              deq, dma;
 110         unsigned int            max_burst;
 111
 112         if (!dbc)
 113                 return;
 114
 115         /* Populate info Context: */
 116         info                    = (struct dbc_info_context *)dbc->ctx->bytes;
 117         dma                     = dbc->string_dma;
 118         info->string0           = cpu_to_le64(dma);
 119         info->manufacturer      = cpu_to_le64(dma + DBC_MAX_STRING_LENGTH);
 120         info->product           = cpu_to_le64(dma + DBC_MAX_STRING_LENGTH * 2);
 121         info->serial            = cpu_to_le64(dma + DBC_MAX_STRING_LENGTH * 3);
 122         info->length            = cpu_to_le32(string_length);
 123
 124         /* Populate bulk out endpoint context: */
 125         ep_ctx                  = dbc_bulkout_ctx(dbc);
 126         max_burst               = DBC_CTRL_MAXBURST(readl(&dbc->regs->control));
 127         deq                     = dbc_bulkout_enq(dbc);
 128         ep_ctx->ep_info         = 0;
 129         ep_ctx->ep_info2        = dbc_epctx_info2(BULK_OUT_EP, 1024, max_burst);
 130         ep_ctx->deq             = cpu_to_le64(deq | dbc->ring_out->cycle_state);
 131
 132         /* Populate bulk in endpoint context: */
 133         ep_ctx                  = dbc_bulkin_ctx(dbc);
 134         deq                     = dbc_bulkin_enq(dbc);
 135         ep_ctx->ep_info         = 0;
 136         ep_ctx->ep_info2        = dbc_epctx_info2(BULK_IN_EP, 1024, max_burst);
 137         ep_ctx->deq             = cpu_to_le64(deq | dbc->ring_in->cycle_state);
 138
 139         /* Set DbC context and info registers: */
 140         lo_hi_writeq(dbc->ctx->dma, &dbc->regs->dccp);
 141
 142         dev_info = (dbc->idVendor << 16) | dbc->bInterfaceProtocol;
 143         writel(dev_info, &dbc->regs->devinfo1);
 144
 145         dev_info = (dbc->bcdDevice << 16) | dbc->idProduct;
 146         writel(dev_info, &dbc->regs->devinfo2);
 147 }
 148
 149 static void xhci_dbc_giveback(struct dbc_request *req, int status)
 150         __releases(&dbc->lock)
 151         __acquires(&dbc->lock)
 152 {
 153         struct xhci_dbc         *dbc = req->dbc;
 154         struct device           *dev = dbc->dev;
 155
 156         list_del_init(&req->list_pending);
 157         req->trb_dma = 0;
 158         req->trb = NULL;
 159
 160         if (req->status == -EINPROGRESS)
 161                 req->status = status;
 162
 163         trace_xhci_dbc_giveback_request(req);
 164
 165         dma_unmap_single(dev,
 166                          req->dma,
 167                          req->length,
 168                          dbc_ep_dma_direction(req));
 169
 170         /* Give back the transfer request: */
 171         spin_unlock(&dbc->lock);
 172         req->complete(dbc, req);
 173         spin_lock(&dbc->lock);
 174 }
 175
 176 static void xhci_dbc_flush_single_request(struct dbc_request *req)
 177 {
 178         union xhci_trb  *trb = req->trb;
 179
 180         trb->generic.field[0]   = 0;
 181         trb->generic.field[1]   = 0;
 182         trb->generic.field[2]   = 0;
 183         trb->generic.field[3]   &= cpu_to_le32(TRB_CYCLE);
 184         trb->generic.field[3]   |= cpu_to_le32(TRB_TYPE(TRB_TR_NOOP));
 185
 186         xhci_dbc_giveback(req, -ESHUTDOWN);
 187 }
 188
 189 static void xhci_dbc_flush_endpoint_requests(struct dbc_ep *dep)
 190 {
 191         struct dbc_request      *req, *tmp;
 192
 193         list_for_each_entry_safe(req, tmp, &dep->list_pending, list_pending)
 194                 xhci_dbc_flush_single_request(req);
 195 }
 196
 197 static void xhci_dbc_flush_requests(struct xhci_dbc *dbc)
 198 {
 199         xhci_dbc_flush_endpoint_requests(&dbc->eps[BULK_OUT]);
 200         xhci_dbc_flush_endpoint_requests(&dbc->eps[BULK_IN]);
 201 }
 202
 203 struct dbc_request *
 204 dbc_alloc_request(struct xhci_dbc *dbc, unsigned int direction, gfp_t flags)
 205 {
 206         struct dbc_request      *req;
 207
 208         if (direction != BULK_IN &&
 209             direction != BULK_OUT)
 210                 return NULL;
 211
 212         if (!dbc)
 213                 return NULL;
 214
 215         req = kzalloc(sizeof(*req), flags);
 216         if (!req)
 217                 return NULL;
 218
 219         req->dbc = dbc;
 220         INIT_LIST_HEAD(&req->list_pending);
 221         INIT_LIST_HEAD(&req->list_pool);
 222         req->direction = direction;
 223
 224         trace_xhci_dbc_alloc_request(req);
 225
 226         return req;
 227 }
 228
 229 void
 230 dbc_free_request(struct dbc_request *req)
 231 {
 232         trace_xhci_dbc_free_request(req);
 233
 234         kfree(req);
 235 }
 236
 237 static void
 238 xhci_dbc_queue_trb(struct xhci_ring *ring, u32 field1,
 239                    u32 field2, u32 field3, u32 field4)
 240 {
 241         union xhci_trb          *trb, *next;
 242
 243         trb = ring->enqueue;
 244         trb->generic.field[0]   = cpu_to_le32(field1);
 245         trb->generic.field[1]   = cpu_to_le32(field2);
 246         trb->generic.field[2]   = cpu_to_le32(field3);
 247         trb->generic.field[3]   = cpu_to_le32(field4);
 248
 249         trace_xhci_dbc_gadget_ep_queue(ring, &trb->generic);
 250
 251         ring->num_trbs_free--;
 252         next = ++(ring->enqueue);
 253         if (TRB_TYPE_LINK_LE32(next->link.control)) {
 254                 next->link.control ^= cpu_to_le32(TRB_CYCLE);
 255                 ring->enqueue = ring->enq_seg->trbs;
 256                 ring->cycle_state ^= 1;
 257         }
 258 }
 259
 260 static int xhci_dbc_queue_bulk_tx(struct dbc_ep *dep,
 261                                   struct dbc_request *req)
 262 {
 263         u64                     addr;
 264         union xhci_trb          *trb;
 265         unsigned int            num_trbs;
 266         struct xhci_dbc         *dbc = req->dbc;
 267         struct xhci_ring        *ring = dep->ring;
 268         u32                     length, control, cycle;
 269
 270         num_trbs = count_trbs(req->dma, req->length);
 271         WARN_ON(num_trbs != 1);
 272         if (ring->num_trbs_free < num_trbs)
 273                 return -EBUSY;
 274
 275         addr    = req->dma;
 276         trb     = ring->enqueue;
 277         cycle   = ring->cycle_state;
 278         length  = TRB_LEN(req->length);
 279         control = TRB_TYPE(TRB_NORMAL) | TRB_IOC;
 280
 281         if (cycle)
 282                 control &= cpu_to_le32(~TRB_CYCLE);
 283         else
 284                 control |= cpu_to_le32(TRB_CYCLE);
 285
 286         req->trb = ring->enqueue;
 287         req->trb_dma = xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
 288         xhci_dbc_queue_trb(ring,
 289                            lower_32_bits(addr),
 290                            upper_32_bits(addr),
 291                            length, control);
 292
 293         /*
 294          * Add a barrier between writes of trb fields and flipping
 295          * the cycle bit:
 296          */
 297         wmb();
 298
 299         if (cycle)
 300                 trb->generic.field[3] |= cpu_to_le32(TRB_CYCLE);
 301         else
 302                 trb->generic.field[3] &= cpu_to_le32(~TRB_CYCLE);
 303
 304         writel(DBC_DOOR_BELL_TARGET(dep->direction), &dbc->regs->doorbell);
 305
 306         return 0;
 307 }
 308
 309 static int
 310 dbc_ep_do_queue(struct dbc_request *req)
 311 {
 312         int                     ret;
 313         struct xhci_dbc         *dbc = req->dbc;
 314         struct device           *dev = dbc->dev;
 315         struct dbc_ep           *dep = &dbc->eps[req->direction];
 316
 317         if (!req->length || !req->buf)
 318                 return -EINVAL;
 319
 320         req->actual             = 0;
 321         req->status             = -EINPROGRESS;
 322
 323         req->dma = dma_map_single(dev,
 324                                   req->buf,
 325                                   req->length,
 326                                   dbc_ep_dma_direction(dep));
 327         if (dma_mapping_error(dev, req->dma)) {
 328                 dev_err(dbc->dev, "failed to map buffer\n");
 329                 return -EFAULT;
 330         }
 331
 332         ret = xhci_dbc_queue_bulk_tx(dep, req);
 333         if (ret) {
 334                 dev_err(dbc->dev, "failed to queue trbs\n");
 335                 dma_unmap_single(dev,
 336                                  req->dma,
 337                                  req->length,
 338                                  dbc_ep_dma_direction(dep));
 339                 return -EFAULT;
 340         }
 341
 342         list_add_tail(&req->list_pending, &dep->list_pending);
 343
 344         return 0;
 345 }
 346
 347 int dbc_ep_queue(struct dbc_request *req)
 348 {
 349         unsigned long           flags;
 350         struct xhci_dbc         *dbc = req->dbc;
 351         int                     ret = -ESHUTDOWN;
 352
 353         if (!dbc)
 354                 return -ENODEV;
 355
 356         if (req->direction != BULK_IN &&
 357             req->direction != BULK_OUT)
 358                 return -EINVAL;
 359
 360         spin_lock_irqsave(&dbc->lock, flags);
 361         if (dbc->state == DS_CONFIGURED)
 362                 ret = dbc_ep_do_queue(req);
 363         spin_unlock_irqrestore(&dbc->lock, flags);
 364
 365         mod_delayed_work(system_wq, &dbc->event_work, 0);
 366
 367         trace_xhci_dbc_queue_request(req);
 368
 369         return ret;
 370 }
 371
 372 static inline void xhci_dbc_do_eps_init(struct xhci_dbc *dbc, bool direction)
 373 {
 374         struct dbc_ep           *dep;
 375
 376         dep                     = &dbc->eps[direction];
 377         dep->dbc                = dbc;
 378         dep->direction          = direction;
 379         dep->ring               = direction ? dbc->ring_in : dbc->ring_out;
 380
 381         INIT_LIST_HEAD(&dep->list_pending);
 382 }
 383
 384 static void xhci_dbc_eps_init(struct xhci_dbc *dbc)
 385 {
 386         xhci_dbc_do_eps_init(dbc, BULK_OUT);
 387         xhci_dbc_do_eps_init(dbc, BULK_IN);
 388 }
 389
 390 static void xhci_dbc_eps_exit(struct xhci_dbc *dbc)
 391 {
 392         memset(dbc->eps, 0, sizeof_field(struct xhci_dbc, eps));
 393 }
 394
 395 static int dbc_erst_alloc(struct device *dev, struct xhci_ring *evt_ring,
 396                     struct xhci_erst *erst, gfp_t flags)
 397 {
 398         erst->entries = dma_alloc_coherent(dev, sizeof(*erst->entries),
 399                                            &erst->erst_dma_addr, flags);
 400         if (!erst->entries)
 401                 return -ENOMEM;
 402
 403         erst->num_entries = 1;
 404         erst->entries[0].seg_addr = cpu_to_le64(evt_ring->first_seg->dma);
 405         erst->entries[0].seg_size = cpu_to_le32(TRBS_PER_SEGMENT);
 406         erst->entries[0].rsvd = 0;
 407         return 0;
 408 }
 409
 410 static void dbc_erst_free(struct device *dev, struct xhci_erst *erst)
 411 {
 412         dma_free_coherent(dev, sizeof(*erst->entries), erst->entries,
 413                           erst->erst_dma_addr);
 414         erst->entries = NULL;
 415 }
 416
 417 static struct xhci_container_ctx *
 418 dbc_alloc_ctx(struct device *dev, gfp_t flags)
 419 {
 420         struct xhci_container_ctx *ctx;
 421
 422         ctx = kzalloc(sizeof(*ctx), flags);
 423         if (!ctx)
 424                 return NULL;
 425
 426         /* xhci 7.6.9, all three contexts; info, ep-out and ep-in. Each 64 bytes*/
 427         ctx->size = 3 * DBC_CONTEXT_SIZE;
 428         ctx->bytes = dma_alloc_coherent(dev, ctx->size, &ctx->dma, flags);
 429         if (!ctx->bytes) {
 430                 kfree(ctx);
 431                 return NULL;
 432         }
 433         return ctx;
 434 }
 435
 436 static struct xhci_ring *
 437 xhci_dbc_ring_alloc(struct device *dev, enum xhci_ring_type type, gfp_t flags)
 438 {
 439         struct xhci_ring *ring;
 440         struct xhci_segment *seg;
 441         dma_addr_t dma;
 442
 443         ring = kzalloc(sizeof(*ring), flags);
 444         if (!ring)
 445                 return NULL;
 446
 447         ring->num_segs = 1;
 448         ring->type = type;
 449
 450         seg = kzalloc(sizeof(*seg), flags);
 451         if (!seg)
 452                 goto seg_fail;
 453
 454         ring->first_seg = seg;
 455         ring->last_seg = seg;
 456         seg->next = seg;
 457
 458         seg->trbs = dma_alloc_coherent(dev, TRB_SEGMENT_SIZE, &dma, flags);
 459         if (!seg->trbs)
 460                 goto dma_fail;
 461
 462         seg->dma = dma;
 463
 464         /* Only event ring does not use link TRB */
 465         if (type != TYPE_EVENT) {
 466                 union xhci_trb *trb = &seg->trbs[TRBS_PER_SEGMENT - 1];
 467
 468                 trb->link.segment_ptr = cpu_to_le64(dma);
 469                 trb->link.control = cpu_to_le32(LINK_TOGGLE | TRB_TYPE(TRB_LINK));
 470         }
 471         INIT_LIST_HEAD(&ring->td_list);
 472         xhci_initialize_ring_info(ring, 1);
 473         return ring;
 474 dma_fail:
 475         kfree(seg);
 476 seg_fail:
 477         kfree(ring);
 478         return NULL;
 479 }
 480
 481 static int xhci_dbc_mem_init(struct xhci_dbc *dbc, gfp_t flags)
 482 {
 483         int                     ret;
 484         dma_addr_t              deq;
 485         u32                     string_length;
 486         struct device           *dev = dbc->dev;
 487
 488         /* Allocate various rings for events and transfers: */
 489         dbc->ring_evt = xhci_dbc_ring_alloc(dev, TYPE_EVENT, flags);
 490         if (!dbc->ring_evt)
 491                 goto evt_fail;
 492
 493         dbc->ring_in = xhci_dbc_ring_alloc(dev, TYPE_BULK, flags);
 494         if (!dbc->ring_in)
 495                 goto in_fail;
 496
 497         dbc->ring_out = xhci_dbc_ring_alloc(dev, TYPE_BULK, flags);
 498         if (!dbc->ring_out)
 499                 goto out_fail;
 500
 501         /* Allocate and populate ERST: */
 502         ret = dbc_erst_alloc(dev, dbc->ring_evt, &dbc->erst, flags);
 503         if (ret)
 504                 goto erst_fail;
 505
 506         /* Allocate context data structure: */
 507         dbc->ctx = dbc_alloc_ctx(dev, flags); /* was sysdev, and is still */
 508         if (!dbc->ctx)
 509                 goto ctx_fail;
 510
 511         /* Allocate the string table: */
 512         dbc->string_size = sizeof(*dbc->string);
 513         dbc->string = dma_alloc_coherent(dev, dbc->string_size,
 514                                          &dbc->string_dma, flags);
 515         if (!dbc->string)
 516                 goto string_fail;
 517
 518         /* Setup ERST register: */
 519         writel(dbc->erst.num_entries, &dbc->regs->ersts);
 520
 521         lo_hi_writeq(dbc->erst.erst_dma_addr, &dbc->regs->erstba);
 522         deq = xhci_trb_virt_to_dma(dbc->ring_evt->deq_seg,
 523                                    dbc->ring_evt->dequeue);
 524         lo_hi_writeq(deq, &dbc->regs->erdp);
 525
 526         /* Setup strings and contexts: */
 527         string_length = xhci_dbc_populate_strings(dbc->string);
 528         xhci_dbc_init_contexts(dbc, string_length);
 529
 530         xhci_dbc_eps_init(dbc);
 531         dbc->state = DS_INITIALIZED;
 532
 533         return 0;
 534
 535 string_fail:
 536         dbc_free_ctx(dev, dbc->ctx);
 537         dbc->ctx = NULL;
 538 ctx_fail:
 539         dbc_erst_free(dev, &dbc->erst);
 540 erst_fail:
 541         dbc_ring_free(dev, dbc->ring_out);
 542         dbc->ring_out = NULL;
 543 out_fail:
 544         dbc_ring_free(dev, dbc->ring_in);
 545         dbc->ring_in = NULL;
 546 in_fail:
 547         dbc_ring_free(dev, dbc->ring_evt);
 548         dbc->ring_evt = NULL;
 549 evt_fail:
 550         return -ENOMEM;
 551 }
 552
 553 static void xhci_dbc_mem_cleanup(struct xhci_dbc *dbc)
 554 {
 555         if (!dbc)
 556                 return;
 557
 558         xhci_dbc_eps_exit(dbc);
 559
 560         dma_free_coherent(dbc->dev, dbc->string_size, dbc->string, dbc->string_dma);
 561         dbc->string = NULL;
 562
 563         dbc_free_ctx(dbc->dev, dbc->ctx);
 564         dbc->ctx = NULL;
 565
 566         dbc_erst_free(dbc->dev, &dbc->erst);
 567         dbc_ring_free(dbc->dev, dbc->ring_out);
 568         dbc_ring_free(dbc->dev, dbc->ring_in);
 569         dbc_ring_free(dbc->dev, dbc->ring_evt);
 570         dbc->ring_in = NULL;
 571         dbc->ring_out = NULL;
 572         dbc->ring_evt = NULL;
 573 }
 574
 575 static int xhci_do_dbc_start(struct xhci_dbc *dbc)
 576 {
 577         int                     ret;
 578         u32                     ctrl;
 579
 580         if (dbc->state != DS_DISABLED)
 581                 return -EINVAL;
 582
 583         writel(0, &dbc->regs->control);
 584         ret = xhci_handshake(&dbc->regs->control,
 585                              DBC_CTRL_DBC_ENABLE,
 586                              0, 1000);
 587         if (ret)
 588                 return ret;
 589
 590         ret = xhci_dbc_mem_init(dbc, GFP_ATOMIC);
 591         if (ret)
 592                 return ret;
 593
 594         ctrl = readl(&dbc->regs->control);
 595         writel(ctrl | DBC_CTRL_DBC_ENABLE | DBC_CTRL_PORT_ENABLE,
 596                &dbc->regs->control);
 597         ret = xhci_handshake(&dbc->regs->control,
 598                              DBC_CTRL_DBC_ENABLE,
 599                              DBC_CTRL_DBC_ENABLE, 1000);
 600         if (ret)
 601                 return ret;
 602
 603         dbc->state = DS_ENABLED;
 604
 605         return 0;
 606 }
 607
 608 static int xhci_do_dbc_stop(struct xhci_dbc *dbc)
 609 {
 610         if (dbc->state == DS_DISABLED)
 611                 return -EINVAL;
 612
 613         writel(0, &dbc->regs->control);
 614         dbc->state = DS_DISABLED;
 615
 616         return 0;
 617 }
 618
 619 static int xhci_dbc_start(struct xhci_dbc *dbc)
 620 {
 621         int                     ret;
 622         unsigned long           flags;
 623
 624         WARN_ON(!dbc);
 625
 626         pm_runtime_get_sync(dbc->dev); /* note this was self.controller */
 627
 628         spin_lock_irqsave(&dbc->lock, flags);
 629         ret = xhci_do_dbc_start(dbc);
 630         spin_unlock_irqrestore(&dbc->lock, flags);
 631
 632         if (ret) {
 633                 pm_runtime_put(dbc->dev); /* note this was self.controller */
 634                 return ret;
 635         }
 636
 637         return mod_delayed_work(system_wq, &dbc->event_work,
 638                                 msecs_to_jiffies(dbc->poll_interval));
 639 }
 640
 641 static void xhci_dbc_stop(struct xhci_dbc *dbc)
 642 {
 643         int ret;
 644         unsigned long           flags;
 645
 646         WARN_ON(!dbc);
 647
 648         switch (dbc->state) {
 649         case DS_DISABLED:
 650                 return;
 651         case DS_CONFIGURED:
 652         case DS_STALLED:
 653                 if (dbc->driver->disconnect)
 654                         dbc->driver->disconnect(dbc);
 655                 break;
 656         default:
 657                 break;
 658         }
 659
 660         cancel_delayed_work_sync(&dbc->event_work);
 661
 662         spin_lock_irqsave(&dbc->lock, flags);
 663         ret = xhci_do_dbc_stop(dbc);
 664         spin_unlock_irqrestore(&dbc->lock, flags);
 665         if (ret)
 666                 return;
 667
 668         xhci_dbc_mem_cleanup(dbc);
 669         pm_runtime_put_sync(dbc->dev); /* note, was self.controller */
 670 }
 671
 672 static void
 673 dbc_handle_port_status(struct xhci_dbc *dbc, union xhci_trb *event)
 674 {
 675         u32                     portsc;
 676
 677         portsc = readl(&dbc->regs->portsc);
 678         if (portsc & DBC_PORTSC_CONN_CHANGE)
 679                 dev_info(dbc->dev, "DbC port connect change\n");
 680
 681         if (portsc & DBC_PORTSC_RESET_CHANGE)
 682                 dev_info(dbc->dev, "DbC port reset change\n");
 683
 684         if (portsc & DBC_PORTSC_LINK_CHANGE)
 685                 dev_info(dbc->dev, "DbC port link status change\n");
 686
 687         if (portsc & DBC_PORTSC_CONFIG_CHANGE)
 688                 dev_info(dbc->dev, "DbC config error change\n");
 689
 690         /* Port reset change bit will be cleared in other place: */
 691         writel(portsc & ~DBC_PORTSC_RESET_CHANGE, &dbc->regs->portsc);
 692 }
 693
 694 static void dbc_handle_xfer_event(struct xhci_dbc *dbc, union xhci_trb *event)
 695 {
 696         struct dbc_ep           *dep;
 697         struct xhci_ring        *ring;
 698         int                     ep_id;
 699         int                     status;
 700         u32                     comp_code;
 701         size_t                  remain_length;
 702         struct dbc_request      *req = NULL, *r;
 703
 704         comp_code       = GET_COMP_CODE(le32_to_cpu(event->generic.field[2]));
 705         remain_length   = EVENT_TRB_LEN(le32_to_cpu(event->generic.field[2]));
 706         ep_id           = TRB_TO_EP_ID(le32_to_cpu(event->generic.field[3]));
 707         dep             = (ep_id == EPID_OUT) ?
 708                                 get_out_ep(dbc) : get_in_ep(dbc);
 709         ring            = dep->ring;
 710
 711         switch (comp_code) {
 712         case COMP_SUCCESS:
 713                 remain_length = 0;
 714                 fallthrough;
 715         case COMP_SHORT_PACKET:
 716                 status = 0;
 717                 break;
 718         case COMP_TRB_ERROR:
 719         case COMP_BABBLE_DETECTED_ERROR:
 720         case COMP_USB_TRANSACTION_ERROR:
 721         case COMP_STALL_ERROR:
 722                 dev_warn(dbc->dev, "tx error %d detected\n", comp_code);
 723                 status = -comp_code;
 724                 break;
 725         default:
 726                 dev_err(dbc->dev, "unknown tx error %d\n", comp_code);
 727                 status = -comp_code;
 728                 break;
 729         }
 730
 731         /* Match the pending request: */
 732         list_for_each_entry(r, &dep->list_pending, list_pending) {
 733                 if (r->trb_dma == event->trans_event.buffer) {
 734                         req = r;
 735                         break;
 736                 }
 737         }
 738
 739         if (!req) {
 740                 dev_warn(dbc->dev, "no matched request\n");
 741                 return;
 742         }
 743
 744         trace_xhci_dbc_handle_transfer(ring, &req->trb->generic);
 745
 746         ring->num_trbs_free++;
 747         req->actual = req->length - remain_length;
 748         xhci_dbc_giveback(req, status);
 749 }
 750
 751 static void inc_evt_deq(struct xhci_ring *ring)
 752 {
 753         /* If on the last TRB of the segment go back to the beginning */
 754         if (ring->dequeue == &ring->deq_seg->trbs[TRBS_PER_SEGMENT - 1]) {
 755                 ring->cycle_state ^= 1;
 756                 ring->dequeue = ring->deq_seg->trbs;
 757                 return;
 758         }
 759         ring->dequeue++;
 760 }
 761
 762 static enum evtreturn xhci_dbc_do_handle_events(struct xhci_dbc *dbc)
 763 {
 764         dma_addr_t              deq;
 765         struct dbc_ep           *dep;
 766         union xhci_trb          *evt;
 767         u32                     ctrl, portsc;
 768         bool                    update_erdp = false;
 769
 770         /* DbC state machine: */
 771         switch (dbc->state) {
 772         case DS_DISABLED:
 773         case DS_INITIALIZED:
 774
 775                 return EVT_ERR;
 776         case DS_ENABLED:
 777                 portsc = readl(&dbc->regs->portsc);
 778                 if (portsc & DBC_PORTSC_CONN_STATUS) {
 779                         dbc->state = DS_CONNECTED;
 780                         dev_info(dbc->dev, "DbC connected\n");
 781                 }
 782
 783                 return EVT_DONE;
 784         case DS_CONNECTED:
 785                 ctrl = readl(&dbc->regs->control);
 786                 if (ctrl & DBC_CTRL_DBC_RUN) {
 787                         dbc->state = DS_CONFIGURED;
 788                         dev_info(dbc->dev, "DbC configured\n");
 789                         portsc = readl(&dbc->regs->portsc);
 790                         writel(portsc, &dbc->regs->portsc);
 791                         return EVT_GSER;
 792                 }
 793
 794                 return EVT_DONE;
 795         case DS_CONFIGURED:
 796                 /* Handle cable unplug event: */
 797                 portsc = readl(&dbc->regs->portsc);
 798                 if (!(portsc & DBC_PORTSC_PORT_ENABLED) &&
 799                     !(portsc & DBC_PORTSC_CONN_STATUS)) {
 800                         dev_info(dbc->dev, "DbC cable unplugged\n");
 801                         dbc->state = DS_ENABLED;
 802                         xhci_dbc_flush_requests(dbc);
 803
 804                         return EVT_DISC;
 805                 }
 806
 807                 /* Handle debug port reset event: */
 808                 if (portsc & DBC_PORTSC_RESET_CHANGE) {
 809                         dev_info(dbc->dev, "DbC port reset\n");
 810                         writel(portsc, &dbc->regs->portsc);
 811                         dbc->state = DS_ENABLED;
 812                         xhci_dbc_flush_requests(dbc);
 813
 814                         return EVT_DISC;
 815                 }
 816
 817                 /* Handle endpoint stall event: */
 818                 ctrl = readl(&dbc->regs->control);
 819                 if ((ctrl & DBC_CTRL_HALT_IN_TR) ||
 820                     (ctrl & DBC_CTRL_HALT_OUT_TR)) {
 821                         dev_info(dbc->dev, "DbC Endpoint stall\n");
 822                         dbc->state = DS_STALLED;
 823
 824                         if (ctrl & DBC_CTRL_HALT_IN_TR) {
 825                                 dep = get_in_ep(dbc);
 826                                 xhci_dbc_flush_endpoint_requests(dep);
 827                         }
 828
 829                         if (ctrl & DBC_CTRL_HALT_OUT_TR) {
 830                                 dep = get_out_ep(dbc);
 831                                 xhci_dbc_flush_endpoint_requests(dep);
 832                         }
 833
 834                         return EVT_DONE;
 835                 }
 836
 837                 /* Clear DbC run change bit: */
 838                 if (ctrl & DBC_CTRL_DBC_RUN_CHANGE) {
 839                         writel(ctrl, &dbc->regs->control);
 840                         ctrl = readl(&dbc->regs->control);
 841                 }
 842
 843                 break;
 844         case DS_STALLED:
 845                 ctrl = readl(&dbc->regs->control);
 846                 if (!(ctrl & DBC_CTRL_HALT_IN_TR) &&
 847                     !(ctrl & DBC_CTRL_HALT_OUT_TR) &&
 848                     (ctrl & DBC_CTRL_DBC_RUN)) {
 849                         dbc->state = DS_CONFIGURED;
 850                         break;
 851                 }
 852
 853                 return EVT_DONE;
 854         default:
 855                 dev_err(dbc->dev, "Unknown DbC state %d\n", dbc->state);
 856                 break;
 857         }
 858
 859         /* Handle the events in the event ring: */
 860         evt = dbc->ring_evt->dequeue;
 861         while ((le32_to_cpu(evt->event_cmd.flags) & TRB_CYCLE) ==
 862                         dbc->ring_evt->cycle_state) {
 863                 /*
 864                  * Add a barrier between reading the cycle flag and any
 865                  * reads of the event's flags/data below:
 866                  */
 867                 rmb();
 868
 869                 trace_xhci_dbc_handle_event(dbc->ring_evt, &evt->generic);
 870
 871                 switch (le32_to_cpu(evt->event_cmd.flags) & TRB_TYPE_BITMASK) {
 872                 case TRB_TYPE(TRB_PORT_STATUS):
 873                         dbc_handle_port_status(dbc, evt);
 874                         break;
 875                 case TRB_TYPE(TRB_TRANSFER):
 876                         dbc_handle_xfer_event(dbc, evt);
 877                         break;
 878                 default:
 879                         break;
 880                 }
 881
 882                 inc_evt_deq(dbc->ring_evt);
 883
 884                 evt = dbc->ring_evt->dequeue;
 885                 update_erdp = true;
 886         }
 887
 888         /* Update event ring dequeue pointer: */
 889         if (update_erdp) {
 890                 deq = xhci_trb_virt_to_dma(dbc->ring_evt->deq_seg,
 891                                            dbc->ring_evt->dequeue);
 892                 lo_hi_writeq(deq, &dbc->regs->erdp);
 893         }
 894
 895         return EVT_DONE;
 896 }
 897
 898 static void xhci_dbc_handle_events(struct work_struct *work)
 899 {
 900         enum evtreturn          evtr;
 901         struct xhci_dbc         *dbc;
 902         unsigned long           flags;
 903         unsigned int            poll_interval;
 904
 905         dbc = container_of(to_delayed_work(work), struct xhci_dbc, event_work);
 906         poll_interval = dbc->poll_interval;
 907
 908         spin_lock_irqsave(&dbc->lock, flags);
 909         evtr = xhci_dbc_do_handle_events(dbc);
 910         spin_unlock_irqrestore(&dbc->lock, flags);
 911
 912         switch (evtr) {
 913         case EVT_GSER:
 914                 if (dbc->driver->configure)
 915                         dbc->driver->configure(dbc);
 916                 break;
 917         case EVT_DISC:
 918                 if (dbc->driver->disconnect)
 919                         dbc->driver->disconnect(dbc);
 920                 break;
 921         case EVT_DONE:
 922                 /* set fast poll rate if there are pending data transfers */
 923                 if (!list_empty(&dbc->eps[BULK_OUT].list_pending) ||
 924                     !list_empty(&dbc->eps[BULK_IN].list_pending))
 925                         poll_interval = 1;
 926                 break;
 927         default:
 928                 dev_info(dbc->dev, "stop handling dbc events\n");
 929                 return;
 930         }
 931
 932         mod_delayed_work(system_wq, &dbc->event_work,
 933                          msecs_to_jiffies(poll_interval));
 934 }
 935
 936 static const char * const dbc_state_strings[DS_MAX] = {
 937         [DS_DISABLED] = "disabled",
 938         [DS_INITIALIZED] = "initialized",
 939         [DS_ENABLED] = "enabled",
 940         [DS_CONNECTED] = "connected",
 941         [DS_CONFIGURED] = "configured",
 942         [DS_STALLED] = "stalled",
 943 };
 944
 945 static ssize_t dbc_show(struct device *dev,
 946                         struct device_attribute *attr,
 947                         char *buf)
 948 {
 949         struct xhci_dbc         *dbc;
 950         struct xhci_hcd         *xhci;
 951
 952         xhci = hcd_to_xhci(dev_get_drvdata(dev));
 953         dbc = xhci->dbc;
 954
 955         if (dbc->state >= ARRAY_SIZE(dbc_state_strings))
 956                 return sysfs_emit(buf, "unknown\n");
 957
 958         return sysfs_emit(buf, "%s\n", dbc_state_strings[dbc->state]);
 959 }
 960
 961 static ssize_t dbc_store(struct device *dev,
 962                          struct device_attribute *attr,
 963                          const char *buf, size_t count)
 964 {
 965         struct xhci_hcd         *xhci;
 966         struct xhci_dbc         *dbc;
 967
 968         xhci = hcd_to_xhci(dev_get_drvdata(dev));
 969         dbc = xhci->dbc;
 970
 971         if (sysfs_streq(buf, "enable"))
 972                 xhci_dbc_start(dbc);
 973         else if (sysfs_streq(buf, "disable"))
 974                 xhci_dbc_stop(dbc);
 975         else
 976                 return -EINVAL;
 977
 978         return count;
 979 }
 980
 981 static ssize_t dbc_idVendor_show(struct device *dev,
 982                             struct device_attribute *attr,
 983                             char *buf)
 984 {
 985         struct xhci_dbc         *dbc;
 986         struct xhci_hcd         *xhci;
 987
 988         xhci = hcd_to_xhci(dev_get_drvdata(dev));
 989         dbc = xhci->dbc;
 990
 991         return sysfs_emit(buf, "%04x\n", dbc->idVendor);
 992 }
 993
 994 static ssize_t dbc_idVendor_store(struct device *dev,
 995                              struct device_attribute *attr,
 996                              const char *buf, size_t size)
 997 {
 998         struct xhci_dbc         *dbc;
 999         struct xhci_hcd         *xhci;
1000         void __iomem            *ptr;
1001         u16                     value;
1002         u32                     dev_info;
1003         int ret;
1004
1005         ret = kstrtou16(buf, 0, &value);
1006         if (ret)
1007                 return ret;
1008
1009         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1010         dbc = xhci->dbc;
1011         if (dbc->state != DS_DISABLED)
1012                 return -EBUSY;
1013
1014         dbc->idVendor = value;
1015         ptr = &dbc->regs->devinfo1;
1016         dev_info = readl(ptr);
1017         dev_info = (dev_info & ~(0xffffu << 16)) | (value << 16);
1018         writel(dev_info, ptr);
1019
1020         return size;
1021 }
1022
1023 static ssize_t dbc_idProduct_show(struct device *dev,
1024                             struct device_attribute *attr,
1025                             char *buf)
1026 {
1027         struct xhci_dbc         *dbc;
1028         struct xhci_hcd         *xhci;
1029
1030         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1031         dbc = xhci->dbc;
1032
1033         return sysfs_emit(buf, "%04x\n", dbc->idProduct);
1034 }
1035
1036 static ssize_t dbc_idProduct_store(struct device *dev,
1037                              struct device_attribute *attr,
1038                              const char *buf, size_t size)
1039 {
1040         struct xhci_dbc         *dbc;
1041         struct xhci_hcd         *xhci;
1042         void __iomem            *ptr;
1043         u32                     dev_info;
1044         u16                     value;
1045         int ret;
1046
1047         ret = kstrtou16(buf, 0, &value);
1048         if (ret)
1049                 return ret;
1050
1051         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1052         dbc = xhci->dbc;
1053         if (dbc->state != DS_DISABLED)
1054                 return -EBUSY;
1055
1056         dbc->idProduct = value;
1057         ptr = &dbc->regs->devinfo2;
1058         dev_info = readl(ptr);
1059         dev_info = (dev_info & ~(0xffffu)) | value;
1060         writel(dev_info, ptr);
1061         return size;
1062 }
1063
1064 static ssize_t dbc_bcdDevice_show(struct device *dev,
1065                                    struct device_attribute *attr,
1066                                    char *buf)
1067 {
1068         struct xhci_dbc *dbc;
1069         struct xhci_hcd *xhci;
1070
1071         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1072         dbc = xhci->dbc;
1073
1074         return sysfs_emit(buf, "%04x\n", dbc->bcdDevice);
1075 }
1076
1077 static ssize_t dbc_bcdDevice_store(struct device *dev,
1078                                     struct device_attribute *attr,
1079                                     const char *buf, size_t size)
1080 {
1081         struct xhci_dbc *dbc;
1082         struct xhci_hcd *xhci;
1083         void __iomem *ptr;
1084         u32 dev_info;
1085         u16 value;
1086         int ret;
1087
1088         ret = kstrtou16(buf, 0, &value);
1089         if (ret)
1090                 return ret;
1091
1092         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1093         dbc = xhci->dbc;
1094         if (dbc->state != DS_DISABLED)
1095                 return -EBUSY;
1096
1097         dbc->bcdDevice = value;
1098         ptr = &dbc->regs->devinfo2;
1099         dev_info = readl(ptr);
1100         dev_info = (dev_info & ~(0xffffu << 16)) | (value << 16);
1101         writel(dev_info, ptr);
1102
1103         return size;
1104 }
1105
1106 static ssize_t dbc_bInterfaceProtocol_show(struct device *dev,
1107                                  struct device_attribute *attr,
1108                                  char *buf)
1109 {
1110         struct xhci_dbc *dbc;
1111         struct xhci_hcd *xhci;
1112
1113         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1114         dbc = xhci->dbc;
1115
1116         return sysfs_emit(buf, "%02x\n", dbc->bInterfaceProtocol);
1117 }
1118
1119 static ssize_t dbc_bInterfaceProtocol_store(struct device *dev,
1120                                   struct device_attribute *attr,
1121                                   const char *buf, size_t size)
1122 {
1123         struct xhci_dbc *dbc;
1124         struct xhci_hcd *xhci;
1125         void __iomem *ptr;
1126         u32 dev_info;
1127         u8 value;
1128         int ret;
1129
1130         /* bInterfaceProtocol is 8 bit, but... */
1131         ret = kstrtou8(buf, 0, &value);
1132         if (ret)
1133                 return ret;
1134
1135         /* ...xhci only supports values 0 and 1 */
1136         if (value > 1)
1137                 return -EINVAL;
1138
1139         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1140         dbc = xhci->dbc;
1141         if (dbc->state != DS_DISABLED)
1142                 return -EBUSY;
1143
1144         dbc->bInterfaceProtocol = value;
1145         ptr = &dbc->regs->devinfo1;
1146         dev_info = readl(ptr);
1147         dev_info = (dev_info & ~(0xffu)) | value;
1148         writel(dev_info, ptr);
1149
1150         return size;
1151 }
1152
1153 static ssize_t dbc_poll_interval_ms_show(struct device *dev,
1154                                          struct device_attribute *attr,
1155                                          char *buf)
1156 {
1157         struct xhci_dbc *dbc;
1158         struct xhci_hcd *xhci;
1159
1160         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1161         dbc = xhci->dbc;
1162
1163         return sysfs_emit(buf, "%u\n", dbc->poll_interval);
1164 }
1165
1166 static ssize_t dbc_poll_interval_ms_store(struct device *dev,
1167                                           struct device_attribute *attr,
1168                                           const char *buf, size_t size)
1169 {
1170         struct xhci_dbc *dbc;
1171         struct xhci_hcd *xhci;
1172         u32 value;
1173         int ret;
1174
1175         ret = kstrtou32(buf, 0, &value);
1176         if (ret || value > DBC_POLL_INTERVAL_MAX)
1177                 return -EINVAL;
1178
1179         xhci = hcd_to_xhci(dev_get_drvdata(dev));
1180         dbc = xhci->dbc;
1181
1182         dbc->poll_interval = value;
1183
1184         mod_delayed_work(system_wq, &dbc->event_work, 0);
1185
1186         return size;
1187 }
1188
1189 static DEVICE_ATTR_RW(dbc);
1190 static DEVICE_ATTR_RW(dbc_idVendor);
1191 static DEVICE_ATTR_RW(dbc_idProduct);
1192 static DEVICE_ATTR_RW(dbc_bcdDevice);
1193 static DEVICE_ATTR_RW(dbc_bInterfaceProtocol);
1194 static DEVICE_ATTR_RW(dbc_poll_interval_ms);
1195
1196 static struct attribute *dbc_dev_attrs[] = {
1197         &dev_attr_dbc.attr,
1198         &dev_attr_dbc_idVendor.attr,
1199         &dev_attr_dbc_idProduct.attr,
1200         &dev_attr_dbc_bcdDevice.attr,
1201         &dev_attr_dbc_bInterfaceProtocol.attr,
1202         &dev_attr_dbc_poll_interval_ms.attr,
1203         NULL
1204 };
1205 ATTRIBUTE_GROUPS(dbc_dev);
1206
1207 struct xhci_dbc *
1208 xhci_alloc_dbc(struct device *dev, void __iomem *base, const struct dbc_driver *driver)
1209 {
1210         struct xhci_dbc         *dbc;
1211         int                     ret;
1212
1213         dbc = kzalloc(sizeof(*dbc), GFP_KERNEL);
1214         if (!dbc)
1215                 return NULL;
1216
1217         dbc->regs = base;
1218         dbc->dev = dev;
1219         dbc->driver = driver;
1220         dbc->idProduct = DBC_PRODUCT_ID;
1221         dbc->idVendor = DBC_VENDOR_ID;
1222         dbc->bcdDevice = DBC_DEVICE_REV;
1223         dbc->bInterfaceProtocol = DBC_PROTOCOL;
1224         dbc->poll_interval = DBC_POLL_INTERVAL_DEFAULT;
1225
1226         if (readl(&dbc->regs->control) & DBC_CTRL_DBC_ENABLE)
1227                 goto err;
1228
1229         INIT_DELAYED_WORK(&dbc->event_work, xhci_dbc_handle_events);
1230         spin_lock_init(&dbc->lock);
1231
1232         ret = sysfs_create_groups(&dev->kobj, dbc_dev_groups);
1233         if (ret)
1234                 goto err;
1235
1236         return dbc;
1237 err:
1238         kfree(dbc);
1239         return NULL;
1240 }
1241
1242 /* undo what xhci_alloc_dbc() did */
1243 void xhci_dbc_remove(struct xhci_dbc *dbc)
1244 {
1245         if (!dbc)
1246                 return;
1247         /* stop hw, stop wq and call dbc->ops->stop() */
1248         xhci_dbc_stop(dbc);
1249
1250         /* remove sysfs files */
1251         sysfs_remove_groups(&dbc->dev->kobj, dbc_dev_groups);
1252
1253         kfree(dbc);
1254 }
1255
1256
1257 int xhci_create_dbc_dev(struct xhci_hcd *xhci)
1258 {
1259         struct device           *dev;
1260         void __iomem            *base;
1261         int                     ret;
1262         int                     dbc_cap_offs;
1263
1264         /* create all parameters needed resembling a dbc device */
1265         dev = xhci_to_hcd(xhci)->self.controller;
1266         base = &xhci->cap_regs->hc_capbase;
1267
1268         dbc_cap_offs = xhci_find_next_ext_cap(base, 0, XHCI_EXT_CAPS_DEBUG);
1269         if (!dbc_cap_offs)
1270                 return -ENODEV;
1271
1272         /* already allocated and in use */
1273         if (xhci->dbc)
1274                 return -EBUSY;
1275
1276         ret = xhci_dbc_tty_probe(dev, base + dbc_cap_offs, xhci);
1277
1278         return ret;
1279 }
1280
1281 void xhci_remove_dbc_dev(struct xhci_hcd *xhci)
1282 {
1283         unsigned long           flags;
1284
1285         if (!xhci->dbc)
1286                 return;
1287
1288         xhci_dbc_tty_remove(xhci->dbc);
1289         spin_lock_irqsave(&xhci->lock, flags);
1290         xhci->dbc = NULL;
1291         spin_unlock_irqrestore(&xhci->lock, flags);
1292 }
1293
1294 #ifdef CONFIG_PM
1295 int xhci_dbc_suspend(struct xhci_hcd *xhci)
1296 {
1297         struct xhci_dbc         *dbc = xhci->dbc;
1298
1299         if (!dbc)
1300                 return 0;
1301
1302         if (dbc->state == DS_CONFIGURED)
1303                 dbc->resume_required = 1;
1304
1305         xhci_dbc_stop(dbc);
1306
1307         return 0;
1308 }
1309
1310 int xhci_dbc_resume(struct xhci_hcd *xhci)
1311 {
1312         int                     ret = 0;
1313         struct xhci_dbc         *dbc = xhci->dbc;
1314
1315         if (!dbc)
1316                 return 0;
1317
1318         if (dbc->resume_required) {
1319                 dbc->resume_required = 0;
1320                 xhci_dbc_start(dbc);
1321         }
1322
1323         return ret;
1324 }
1325 #endif /* CONFIG_PM */
1326
1327 int xhci_dbc_init(void)
1328 {
1329         return dbc_tty_init();
1330 }
1331
1332 void xhci_dbc_exit(void)
1333 {
1334         dbc_tty_exit();
1335 }