1 /** 2 * debugfs.c - DesignWare USB3 DRD Controller DebugFS file 3 * 4 * Copyright (C) 2010-2011 Texas Instruments Incorporated - http://www.ti.com 5 * 6 * Authors: Felipe Balbi <balbi@ti.com>, 7 * Sebastian Andrzej Siewior <bigeasy@linutronix.de> 8 * 9 * This program is free software: you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 of 11 * the License as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #include <linux/kernel.h> 20 #include <linux/slab.h> 21 #include <linux/ptrace.h> 22 #include <linux/types.h> 23 #include <linux/spinlock.h> 24 #include <linux/debugfs.h> 25 #include <linux/seq_file.h> 26 #include <linux/delay.h> 27 #include <linux/uaccess.h> 28 29 #include <linux/usb/ch9.h> 30 31 #include "core.h" 32 #include "gadget.h" 33 #include "io.h" 34 #include "debug.h" 35 36 #define dump_register(nm) \ 37 { \ 38 .name = __stringify(nm), \ 39 .offset = DWC3_ ##nm, \ 40 } 41 42 #define dump_ep_register_set(n) \ 43 { \ 44 .name = "DEPCMDPAR2("__stringify(n)")", \ 45 .offset = DWC3_DEP_BASE(n) + \ 46 DWC3_DEPCMDPAR2, \ 47 }, \ 48 { \ 49 .name = "DEPCMDPAR1("__stringify(n)")", \ 50 .offset = DWC3_DEP_BASE(n) + \ 51 DWC3_DEPCMDPAR1, \ 52 }, \ 53 { \ 54 .name = "DEPCMDPAR0("__stringify(n)")", \ 55 .offset = DWC3_DEP_BASE(n) + \ 56 DWC3_DEPCMDPAR0, \ 57 }, \ 58 { \ 59 .name = "DEPCMD("__stringify(n)")", \ 60 .offset = DWC3_DEP_BASE(n) + \ 61 DWC3_DEPCMD, \ 62 } 63 64 65 static const struct debugfs_reg32 dwc3_regs[] = { 66 dump_register(GSBUSCFG0), 67 dump_register(GSBUSCFG1), 68 dump_register(GTXTHRCFG), 69 dump_register(GRXTHRCFG), 70 dump_register(GCTL), 71 dump_register(GEVTEN), 72 dump_register(GSTS), 73 dump_register(GUCTL1), 74 dump_register(GSNPSID), 75 dump_register(GGPIO), 76 dump_register(GUID), 77 dump_register(GUCTL), 78 dump_register(GBUSERRADDR0), 79 dump_register(GBUSERRADDR1), 80 dump_register(GPRTBIMAP0), 81 dump_register(GPRTBIMAP1), 82 dump_register(GHWPARAMS0), 83 dump_register(GHWPARAMS1), 84 dump_register(GHWPARAMS2), 85 dump_register(GHWPARAMS3), 86 dump_register(GHWPARAMS4), 87 dump_register(GHWPARAMS5), 88 dump_register(GHWPARAMS6), 89 dump_register(GHWPARAMS7), 90 dump_register(GDBGFIFOSPACE), 91 dump_register(GDBGLTSSM), 92 dump_register(GPRTBIMAP_HS0), 93 dump_register(GPRTBIMAP_HS1), 94 dump_register(GPRTBIMAP_FS0), 95 dump_register(GPRTBIMAP_FS1), 96 97 dump_register(GUSB2PHYCFG(0)), 98 dump_register(GUSB2PHYCFG(1)), 99 dump_register(GUSB2PHYCFG(2)), 100 dump_register(GUSB2PHYCFG(3)), 101 dump_register(GUSB2PHYCFG(4)), 102 dump_register(GUSB2PHYCFG(5)), 103 dump_register(GUSB2PHYCFG(6)), 104 dump_register(GUSB2PHYCFG(7)), 105 dump_register(GUSB2PHYCFG(8)), 106 dump_register(GUSB2PHYCFG(9)), 107 dump_register(GUSB2PHYCFG(10)), 108 dump_register(GUSB2PHYCFG(11)), 109 dump_register(GUSB2PHYCFG(12)), 110 dump_register(GUSB2PHYCFG(13)), 111 dump_register(GUSB2PHYCFG(14)), 112 dump_register(GUSB2PHYCFG(15)), 113 114 dump_register(GUSB2I2CCTL(0)), 115 dump_register(GUSB2I2CCTL(1)), 116 dump_register(GUSB2I2CCTL(2)), 117 dump_register(GUSB2I2CCTL(3)), 118 dump_register(GUSB2I2CCTL(4)), 119 dump_register(GUSB2I2CCTL(5)), 120 dump_register(GUSB2I2CCTL(6)), 121 dump_register(GUSB2I2CCTL(7)), 122 dump_register(GUSB2I2CCTL(8)), 123 dump_register(GUSB2I2CCTL(9)), 124 dump_register(GUSB2I2CCTL(10)), 125 dump_register(GUSB2I2CCTL(11)), 126 dump_register(GUSB2I2CCTL(12)), 127 dump_register(GUSB2I2CCTL(13)), 128 dump_register(GUSB2I2CCTL(14)), 129 dump_register(GUSB2I2CCTL(15)), 130 131 dump_register(GUSB2PHYACC(0)), 132 dump_register(GUSB2PHYACC(1)), 133 dump_register(GUSB2PHYACC(2)), 134 dump_register(GUSB2PHYACC(3)), 135 dump_register(GUSB2PHYACC(4)), 136 dump_register(GUSB2PHYACC(5)), 137 dump_register(GUSB2PHYACC(6)), 138 dump_register(GUSB2PHYACC(7)), 139 dump_register(GUSB2PHYACC(8)), 140 dump_register(GUSB2PHYACC(9)), 141 dump_register(GUSB2PHYACC(10)), 142 dump_register(GUSB2PHYACC(11)), 143 dump_register(GUSB2PHYACC(12)), 144 dump_register(GUSB2PHYACC(13)), 145 dump_register(GUSB2PHYACC(14)), 146 dump_register(GUSB2PHYACC(15)), 147 148 dump_register(GUSB3PIPECTL(0)), 149 dump_register(GUSB3PIPECTL(1)), 150 dump_register(GUSB3PIPECTL(2)), 151 dump_register(GUSB3PIPECTL(3)), 152 dump_register(GUSB3PIPECTL(4)), 153 dump_register(GUSB3PIPECTL(5)), 154 dump_register(GUSB3PIPECTL(6)), 155 dump_register(GUSB3PIPECTL(7)), 156 dump_register(GUSB3PIPECTL(8)), 157 dump_register(GUSB3PIPECTL(9)), 158 dump_register(GUSB3PIPECTL(10)), 159 dump_register(GUSB3PIPECTL(11)), 160 dump_register(GUSB3PIPECTL(12)), 161 dump_register(GUSB3PIPECTL(13)), 162 dump_register(GUSB3PIPECTL(14)), 163 dump_register(GUSB3PIPECTL(15)), 164 165 dump_register(GTXFIFOSIZ(0)), 166 dump_register(GTXFIFOSIZ(1)), 167 dump_register(GTXFIFOSIZ(2)), 168 dump_register(GTXFIFOSIZ(3)), 169 dump_register(GTXFIFOSIZ(4)), 170 dump_register(GTXFIFOSIZ(5)), 171 dump_register(GTXFIFOSIZ(6)), 172 dump_register(GTXFIFOSIZ(7)), 173 dump_register(GTXFIFOSIZ(8)), 174 dump_register(GTXFIFOSIZ(9)), 175 dump_register(GTXFIFOSIZ(10)), 176 dump_register(GTXFIFOSIZ(11)), 177 dump_register(GTXFIFOSIZ(12)), 178 dump_register(GTXFIFOSIZ(13)), 179 dump_register(GTXFIFOSIZ(14)), 180 dump_register(GTXFIFOSIZ(15)), 181 dump_register(GTXFIFOSIZ(16)), 182 dump_register(GTXFIFOSIZ(17)), 183 dump_register(GTXFIFOSIZ(18)), 184 dump_register(GTXFIFOSIZ(19)), 185 dump_register(GTXFIFOSIZ(20)), 186 dump_register(GTXFIFOSIZ(21)), 187 dump_register(GTXFIFOSIZ(22)), 188 dump_register(GTXFIFOSIZ(23)), 189 dump_register(GTXFIFOSIZ(24)), 190 dump_register(GTXFIFOSIZ(25)), 191 dump_register(GTXFIFOSIZ(26)), 192 dump_register(GTXFIFOSIZ(27)), 193 dump_register(GTXFIFOSIZ(28)), 194 dump_register(GTXFIFOSIZ(29)), 195 dump_register(GTXFIFOSIZ(30)), 196 dump_register(GTXFIFOSIZ(31)), 197 198 dump_register(GRXFIFOSIZ(0)), 199 dump_register(GRXFIFOSIZ(1)), 200 dump_register(GRXFIFOSIZ(2)), 201 dump_register(GRXFIFOSIZ(3)), 202 dump_register(GRXFIFOSIZ(4)), 203 dump_register(GRXFIFOSIZ(5)), 204 dump_register(GRXFIFOSIZ(6)), 205 dump_register(GRXFIFOSIZ(7)), 206 dump_register(GRXFIFOSIZ(8)), 207 dump_register(GRXFIFOSIZ(9)), 208 dump_register(GRXFIFOSIZ(10)), 209 dump_register(GRXFIFOSIZ(11)), 210 dump_register(GRXFIFOSIZ(12)), 211 dump_register(GRXFIFOSIZ(13)), 212 dump_register(GRXFIFOSIZ(14)), 213 dump_register(GRXFIFOSIZ(15)), 214 dump_register(GRXFIFOSIZ(16)), 215 dump_register(GRXFIFOSIZ(17)), 216 dump_register(GRXFIFOSIZ(18)), 217 dump_register(GRXFIFOSIZ(19)), 218 dump_register(GRXFIFOSIZ(20)), 219 dump_register(GRXFIFOSIZ(21)), 220 dump_register(GRXFIFOSIZ(22)), 221 dump_register(GRXFIFOSIZ(23)), 222 dump_register(GRXFIFOSIZ(24)), 223 dump_register(GRXFIFOSIZ(25)), 224 dump_register(GRXFIFOSIZ(26)), 225 dump_register(GRXFIFOSIZ(27)), 226 dump_register(GRXFIFOSIZ(28)), 227 dump_register(GRXFIFOSIZ(29)), 228 dump_register(GRXFIFOSIZ(30)), 229 dump_register(GRXFIFOSIZ(31)), 230 231 dump_register(GEVNTADRLO(0)), 232 dump_register(GEVNTADRHI(0)), 233 dump_register(GEVNTSIZ(0)), 234 dump_register(GEVNTCOUNT(0)), 235 236 dump_register(GHWPARAMS8), 237 dump_register(DCFG), 238 dump_register(DCTL), 239 dump_register(DEVTEN), 240 dump_register(DSTS), 241 dump_register(DGCMDPAR), 242 dump_register(DGCMD), 243 dump_register(DALEPENA), 244 245 dump_ep_register_set(0), 246 dump_ep_register_set(1), 247 dump_ep_register_set(2), 248 dump_ep_register_set(3), 249 dump_ep_register_set(4), 250 dump_ep_register_set(5), 251 dump_ep_register_set(6), 252 dump_ep_register_set(7), 253 dump_ep_register_set(8), 254 dump_ep_register_set(9), 255 dump_ep_register_set(10), 256 dump_ep_register_set(11), 257 dump_ep_register_set(12), 258 dump_ep_register_set(13), 259 dump_ep_register_set(14), 260 dump_ep_register_set(15), 261 dump_ep_register_set(16), 262 dump_ep_register_set(17), 263 dump_ep_register_set(18), 264 dump_ep_register_set(19), 265 dump_ep_register_set(20), 266 dump_ep_register_set(21), 267 dump_ep_register_set(22), 268 dump_ep_register_set(23), 269 dump_ep_register_set(24), 270 dump_ep_register_set(25), 271 dump_ep_register_set(26), 272 dump_ep_register_set(27), 273 dump_ep_register_set(28), 274 dump_ep_register_set(29), 275 dump_ep_register_set(30), 276 dump_ep_register_set(31), 277 278 dump_register(OCFG), 279 dump_register(OCTL), 280 dump_register(OEVT), 281 dump_register(OEVTEN), 282 dump_register(OSTS), 283 }; 284 285 static int dwc3_mode_show(struct seq_file *s, void *unused) 286 { 287 struct dwc3 *dwc = s->private; 288 unsigned long flags; 289 u32 reg; 290 291 spin_lock_irqsave(&dwc->lock, flags); 292 reg = dwc3_readl(dwc->regs, DWC3_GCTL); 293 spin_unlock_irqrestore(&dwc->lock, flags); 294 295 switch (DWC3_GCTL_PRTCAP(reg)) { 296 case DWC3_GCTL_PRTCAP_HOST: 297 seq_printf(s, "host\n"); 298 break; 299 case DWC3_GCTL_PRTCAP_DEVICE: 300 seq_printf(s, "device\n"); 301 break; 302 case DWC3_GCTL_PRTCAP_OTG: 303 seq_printf(s, "OTG\n"); 304 break; 305 default: 306 seq_printf(s, "UNKNOWN %08x\n", DWC3_GCTL_PRTCAP(reg)); 307 } 308 309 return 0; 310 } 311 312 static int dwc3_mode_open(struct inode *inode, struct file *file) 313 { 314 return single_open(file, dwc3_mode_show, inode->i_private); 315 } 316 317 static ssize_t dwc3_mode_write(struct file *file, 318 const char __user *ubuf, size_t count, loff_t *ppos) 319 { 320 struct seq_file *s = file->private_data; 321 struct dwc3 *dwc = s->private; 322 unsigned long flags; 323 u32 mode = 0; 324 char buf[32]; 325 326 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 327 return -EFAULT; 328 329 if (!strncmp(buf, "host", 4)) 330 mode |= DWC3_GCTL_PRTCAP_HOST; 331 332 if (!strncmp(buf, "device", 6)) 333 mode |= DWC3_GCTL_PRTCAP_DEVICE; 334 335 if (!strncmp(buf, "otg", 3)) 336 mode |= DWC3_GCTL_PRTCAP_OTG; 337 338 if (mode) { 339 spin_lock_irqsave(&dwc->lock, flags); 340 dwc3_set_mode(dwc, mode); 341 spin_unlock_irqrestore(&dwc->lock, flags); 342 } 343 return count; 344 } 345 346 static const struct file_operations dwc3_mode_fops = { 347 .open = dwc3_mode_open, 348 .write = dwc3_mode_write, 349 .read = seq_read, 350 .llseek = seq_lseek, 351 .release = single_release, 352 }; 353 354 static int dwc3_testmode_show(struct seq_file *s, void *unused) 355 { 356 struct dwc3 *dwc = s->private; 357 unsigned long flags; 358 u32 reg; 359 360 spin_lock_irqsave(&dwc->lock, flags); 361 reg = dwc3_readl(dwc->regs, DWC3_DCTL); 362 reg &= DWC3_DCTL_TSTCTRL_MASK; 363 reg >>= 1; 364 spin_unlock_irqrestore(&dwc->lock, flags); 365 366 switch (reg) { 367 case 0: 368 seq_printf(s, "no test\n"); 369 break; 370 case TEST_J: 371 seq_printf(s, "test_j\n"); 372 break; 373 case TEST_K: 374 seq_printf(s, "test_k\n"); 375 break; 376 case TEST_SE0_NAK: 377 seq_printf(s, "test_se0_nak\n"); 378 break; 379 case TEST_PACKET: 380 seq_printf(s, "test_packet\n"); 381 break; 382 case TEST_FORCE_EN: 383 seq_printf(s, "test_force_enable\n"); 384 break; 385 default: 386 seq_printf(s, "UNKNOWN %d\n", reg); 387 } 388 389 return 0; 390 } 391 392 static int dwc3_testmode_open(struct inode *inode, struct file *file) 393 { 394 return single_open(file, dwc3_testmode_show, inode->i_private); 395 } 396 397 static ssize_t dwc3_testmode_write(struct file *file, 398 const char __user *ubuf, size_t count, loff_t *ppos) 399 { 400 struct seq_file *s = file->private_data; 401 struct dwc3 *dwc = s->private; 402 unsigned long flags; 403 u32 testmode = 0; 404 char buf[32]; 405 406 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 407 return -EFAULT; 408 409 if (!strncmp(buf, "test_j", 6)) 410 testmode = TEST_J; 411 else if (!strncmp(buf, "test_k", 6)) 412 testmode = TEST_K; 413 else if (!strncmp(buf, "test_se0_nak", 12)) 414 testmode = TEST_SE0_NAK; 415 else if (!strncmp(buf, "test_packet", 11)) 416 testmode = TEST_PACKET; 417 else if (!strncmp(buf, "test_force_enable", 17)) 418 testmode = TEST_FORCE_EN; 419 else 420 testmode = 0; 421 422 spin_lock_irqsave(&dwc->lock, flags); 423 dwc3_gadget_set_test_mode(dwc, testmode); 424 spin_unlock_irqrestore(&dwc->lock, flags); 425 426 return count; 427 } 428 429 static const struct file_operations dwc3_testmode_fops = { 430 .open = dwc3_testmode_open, 431 .write = dwc3_testmode_write, 432 .read = seq_read, 433 .llseek = seq_lseek, 434 .release = single_release, 435 }; 436 437 static int dwc3_link_state_show(struct seq_file *s, void *unused) 438 { 439 struct dwc3 *dwc = s->private; 440 unsigned long flags; 441 enum dwc3_link_state state; 442 u32 reg; 443 444 spin_lock_irqsave(&dwc->lock, flags); 445 reg = dwc3_readl(dwc->regs, DWC3_DSTS); 446 state = DWC3_DSTS_USBLNKST(reg); 447 spin_unlock_irqrestore(&dwc->lock, flags); 448 449 switch (state) { 450 case DWC3_LINK_STATE_U0: 451 seq_printf(s, "U0\n"); 452 break; 453 case DWC3_LINK_STATE_U1: 454 seq_printf(s, "U1\n"); 455 break; 456 case DWC3_LINK_STATE_U2: 457 seq_printf(s, "U2\n"); 458 break; 459 case DWC3_LINK_STATE_U3: 460 seq_printf(s, "U3\n"); 461 break; 462 case DWC3_LINK_STATE_SS_DIS: 463 seq_printf(s, "SS.Disabled\n"); 464 break; 465 case DWC3_LINK_STATE_RX_DET: 466 seq_printf(s, "Rx.Detect\n"); 467 break; 468 case DWC3_LINK_STATE_SS_INACT: 469 seq_printf(s, "SS.Inactive\n"); 470 break; 471 case DWC3_LINK_STATE_POLL: 472 seq_printf(s, "Poll\n"); 473 break; 474 case DWC3_LINK_STATE_RECOV: 475 seq_printf(s, "Recovery\n"); 476 break; 477 case DWC3_LINK_STATE_HRESET: 478 seq_printf(s, "HRESET\n"); 479 break; 480 case DWC3_LINK_STATE_CMPLY: 481 seq_printf(s, "Compliance\n"); 482 break; 483 case DWC3_LINK_STATE_LPBK: 484 seq_printf(s, "Loopback\n"); 485 break; 486 case DWC3_LINK_STATE_RESET: 487 seq_printf(s, "Reset\n"); 488 break; 489 case DWC3_LINK_STATE_RESUME: 490 seq_printf(s, "Resume\n"); 491 break; 492 default: 493 seq_printf(s, "UNKNOWN %d\n", state); 494 } 495 496 return 0; 497 } 498 499 static int dwc3_link_state_open(struct inode *inode, struct file *file) 500 { 501 return single_open(file, dwc3_link_state_show, inode->i_private); 502 } 503 504 static ssize_t dwc3_link_state_write(struct file *file, 505 const char __user *ubuf, size_t count, loff_t *ppos) 506 { 507 struct seq_file *s = file->private_data; 508 struct dwc3 *dwc = s->private; 509 unsigned long flags; 510 enum dwc3_link_state state = 0; 511 char buf[32]; 512 513 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 514 return -EFAULT; 515 516 if (!strncmp(buf, "SS.Disabled", 11)) 517 state = DWC3_LINK_STATE_SS_DIS; 518 else if (!strncmp(buf, "Rx.Detect", 9)) 519 state = DWC3_LINK_STATE_RX_DET; 520 else if (!strncmp(buf, "SS.Inactive", 11)) 521 state = DWC3_LINK_STATE_SS_INACT; 522 else if (!strncmp(buf, "Recovery", 8)) 523 state = DWC3_LINK_STATE_RECOV; 524 else if (!strncmp(buf, "Compliance", 10)) 525 state = DWC3_LINK_STATE_CMPLY; 526 else if (!strncmp(buf, "Loopback", 8)) 527 state = DWC3_LINK_STATE_LPBK; 528 else 529 return -EINVAL; 530 531 spin_lock_irqsave(&dwc->lock, flags); 532 dwc3_gadget_set_link_state(dwc, state); 533 spin_unlock_irqrestore(&dwc->lock, flags); 534 535 return count; 536 } 537 538 static const struct file_operations dwc3_link_state_fops = { 539 .open = dwc3_link_state_open, 540 .write = dwc3_link_state_write, 541 .read = seq_read, 542 .llseek = seq_lseek, 543 .release = single_release, 544 }; 545 546 struct dwc3_ep_file_map { 547 char name[25]; 548 int (*show)(struct seq_file *s, void *unused); 549 }; 550 551 static int dwc3_tx_fifo_queue_show(struct seq_file *s, void *unused) 552 { 553 struct dwc3_ep *dep = s->private; 554 struct dwc3 *dwc = dep->dwc; 555 unsigned long flags; 556 u32 val; 557 558 spin_lock_irqsave(&dwc->lock, flags); 559 val = dwc3_core_fifo_space(dep, DWC3_TXFIFOQ); 560 seq_printf(s, "%u\n", val); 561 spin_unlock_irqrestore(&dwc->lock, flags); 562 563 return 0; 564 } 565 566 static int dwc3_rx_fifo_queue_show(struct seq_file *s, void *unused) 567 { 568 struct dwc3_ep *dep = s->private; 569 struct dwc3 *dwc = dep->dwc; 570 unsigned long flags; 571 u32 val; 572 573 spin_lock_irqsave(&dwc->lock, flags); 574 val = dwc3_core_fifo_space(dep, DWC3_RXFIFOQ); 575 seq_printf(s, "%u\n", val); 576 spin_unlock_irqrestore(&dwc->lock, flags); 577 578 return 0; 579 } 580 581 static int dwc3_tx_request_queue_show(struct seq_file *s, void *unused) 582 { 583 struct dwc3_ep *dep = s->private; 584 struct dwc3 *dwc = dep->dwc; 585 unsigned long flags; 586 u32 val; 587 588 spin_lock_irqsave(&dwc->lock, flags); 589 val = dwc3_core_fifo_space(dep, DWC3_TXREQQ); 590 seq_printf(s, "%u\n", val); 591 spin_unlock_irqrestore(&dwc->lock, flags); 592 593 return 0; 594 } 595 596 static int dwc3_rx_request_queue_show(struct seq_file *s, void *unused) 597 { 598 struct dwc3_ep *dep = s->private; 599 struct dwc3 *dwc = dep->dwc; 600 unsigned long flags; 601 u32 val; 602 603 spin_lock_irqsave(&dwc->lock, flags); 604 val = dwc3_core_fifo_space(dep, DWC3_RXREQQ); 605 seq_printf(s, "%u\n", val); 606 spin_unlock_irqrestore(&dwc->lock, flags); 607 608 return 0; 609 } 610 611 static int dwc3_rx_info_queue_show(struct seq_file *s, void *unused) 612 { 613 struct dwc3_ep *dep = s->private; 614 struct dwc3 *dwc = dep->dwc; 615 unsigned long flags; 616 u32 val; 617 618 spin_lock_irqsave(&dwc->lock, flags); 619 val = dwc3_core_fifo_space(dep, DWC3_RXINFOQ); 620 seq_printf(s, "%u\n", val); 621 spin_unlock_irqrestore(&dwc->lock, flags); 622 623 return 0; 624 } 625 626 static int dwc3_descriptor_fetch_queue_show(struct seq_file *s, void *unused) 627 { 628 struct dwc3_ep *dep = s->private; 629 struct dwc3 *dwc = dep->dwc; 630 unsigned long flags; 631 u32 val; 632 633 spin_lock_irqsave(&dwc->lock, flags); 634 val = dwc3_core_fifo_space(dep, DWC3_DESCFETCHQ); 635 seq_printf(s, "%u\n", val); 636 spin_unlock_irqrestore(&dwc->lock, flags); 637 638 return 0; 639 } 640 641 static int dwc3_event_queue_show(struct seq_file *s, void *unused) 642 { 643 struct dwc3_ep *dep = s->private; 644 struct dwc3 *dwc = dep->dwc; 645 unsigned long flags; 646 u32 val; 647 648 spin_lock_irqsave(&dwc->lock, flags); 649 val = dwc3_core_fifo_space(dep, DWC3_EVENTQ); 650 seq_printf(s, "%u\n", val); 651 spin_unlock_irqrestore(&dwc->lock, flags); 652 653 return 0; 654 } 655 656 static int dwc3_ep_transfer_type_show(struct seq_file *s, void *unused) 657 { 658 struct dwc3_ep *dep = s->private; 659 struct dwc3 *dwc = dep->dwc; 660 unsigned long flags; 661 662 spin_lock_irqsave(&dwc->lock, flags); 663 if (!(dep->flags & DWC3_EP_ENABLED) || 664 !dep->endpoint.desc) { 665 seq_printf(s, "--\n"); 666 goto out; 667 } 668 669 switch (usb_endpoint_type(dep->endpoint.desc)) { 670 case USB_ENDPOINT_XFER_CONTROL: 671 seq_printf(s, "control\n"); 672 break; 673 case USB_ENDPOINT_XFER_ISOC: 674 seq_printf(s, "isochronous\n"); 675 break; 676 case USB_ENDPOINT_XFER_BULK: 677 seq_printf(s, "bulk\n"); 678 break; 679 case USB_ENDPOINT_XFER_INT: 680 seq_printf(s, "interrupt\n"); 681 break; 682 default: 683 seq_printf(s, "--\n"); 684 } 685 686 out: 687 spin_unlock_irqrestore(&dwc->lock, flags); 688 689 return 0; 690 } 691 692 static inline const char *dwc3_trb_type_string(struct dwc3_trb *trb) 693 { 694 switch (DWC3_TRBCTL_TYPE(trb->ctrl)) { 695 case DWC3_TRBCTL_NORMAL: 696 return "normal"; 697 case DWC3_TRBCTL_CONTROL_SETUP: 698 return "control-setup"; 699 case DWC3_TRBCTL_CONTROL_STATUS2: 700 return "control-status2"; 701 case DWC3_TRBCTL_CONTROL_STATUS3: 702 return "control-status3"; 703 case DWC3_TRBCTL_CONTROL_DATA: 704 return "control-data"; 705 case DWC3_TRBCTL_ISOCHRONOUS_FIRST: 706 return "isoc-first"; 707 case DWC3_TRBCTL_ISOCHRONOUS: 708 return "isoc"; 709 case DWC3_TRBCTL_LINK_TRB: 710 return "link"; 711 default: 712 return "UNKNOWN"; 713 } 714 } 715 716 static int dwc3_ep_trb_ring_show(struct seq_file *s, void *unused) 717 { 718 struct dwc3_ep *dep = s->private; 719 struct dwc3 *dwc = dep->dwc; 720 unsigned long flags; 721 int i; 722 723 spin_lock_irqsave(&dwc->lock, flags); 724 if (dep->number <= 1) { 725 seq_printf(s, "--\n"); 726 goto out; 727 } 728 729 seq_printf(s, "enqueue pointer %d\n", dep->trb_enqueue); 730 seq_printf(s, "dequeue pointer %d\n", dep->trb_dequeue); 731 seq_printf(s, "\n--------------------------------------------------\n\n"); 732 seq_printf(s, "buffer_addr,size,type,ioc,isp_imi,csp,chn,lst,hwo\n"); 733 734 for (i = 0; i < DWC3_TRB_NUM; i++) { 735 struct dwc3_trb *trb = &dep->trb_pool[i]; 736 737 seq_printf(s, "%08x%08x,%d,%s,%d,%d,%d,%d,%d,%d\n", 738 trb->bph, trb->bpl, trb->size, 739 dwc3_trb_type_string(trb), 740 !!(trb->ctrl & DWC3_TRB_CTRL_IOC), 741 !!(trb->ctrl & DWC3_TRB_CTRL_ISP_IMI), 742 !!(trb->ctrl & DWC3_TRB_CTRL_CSP), 743 !!(trb->ctrl & DWC3_TRB_CTRL_CHN), 744 !!(trb->ctrl & DWC3_TRB_CTRL_LST), 745 !!(trb->ctrl & DWC3_TRB_CTRL_HWO)); 746 } 747 748 out: 749 spin_unlock_irqrestore(&dwc->lock, flags); 750 751 return 0; 752 } 753 754 static struct dwc3_ep_file_map map[] = { 755 { "tx_fifo_queue", dwc3_tx_fifo_queue_show, }, 756 { "rx_fifo_queue", dwc3_rx_fifo_queue_show, }, 757 { "tx_request_queue", dwc3_tx_request_queue_show, }, 758 { "rx_request_queue", dwc3_rx_request_queue_show, }, 759 { "rx_info_queue", dwc3_rx_info_queue_show, }, 760 { "descriptor_fetch_queue", dwc3_descriptor_fetch_queue_show, }, 761 { "event_queue", dwc3_event_queue_show, }, 762 { "transfer_type", dwc3_ep_transfer_type_show, }, 763 { "trb_ring", dwc3_ep_trb_ring_show, }, 764 }; 765 766 static int dwc3_endpoint_open(struct inode *inode, struct file *file) 767 { 768 const char *file_name = file_dentry(file)->d_iname; 769 struct dwc3_ep_file_map *f_map; 770 int i; 771 772 for (i = 0; i < ARRAY_SIZE(map); i++) { 773 f_map = &map[i]; 774 775 if (strcmp(f_map->name, file_name) == 0) 776 break; 777 } 778 779 return single_open(file, f_map->show, inode->i_private); 780 } 781 782 static const struct file_operations dwc3_endpoint_fops = { 783 .open = dwc3_endpoint_open, 784 .read = seq_read, 785 .llseek = seq_lseek, 786 .release = single_release, 787 }; 788 789 static void dwc3_debugfs_create_endpoint_file(struct dwc3_ep *dep, 790 struct dentry *parent, int type) 791 { 792 struct dentry *file; 793 struct dwc3_ep_file_map *ep_file = &map[type]; 794 795 file = debugfs_create_file(ep_file->name, S_IRUGO, parent, dep, 796 &dwc3_endpoint_fops); 797 } 798 799 static void dwc3_debugfs_create_endpoint_files(struct dwc3_ep *dep, 800 struct dentry *parent) 801 { 802 int i; 803 804 for (i = 0; i < ARRAY_SIZE(map); i++) 805 dwc3_debugfs_create_endpoint_file(dep, parent, i); 806 } 807 808 static void dwc3_debugfs_create_endpoint_dir(struct dwc3_ep *dep, 809 struct dentry *parent) 810 { 811 struct dentry *dir; 812 813 dir = debugfs_create_dir(dep->name, parent); 814 if (IS_ERR_OR_NULL(dir)) 815 return; 816 817 dwc3_debugfs_create_endpoint_files(dep, dir); 818 } 819 820 static void dwc3_debugfs_create_endpoint_dirs(struct dwc3 *dwc, 821 struct dentry *parent) 822 { 823 int i; 824 825 for (i = 0; i < dwc->num_in_eps; i++) { 826 u8 epnum = (i << 1) | 1; 827 struct dwc3_ep *dep = dwc->eps[epnum]; 828 829 if (!dep) 830 continue; 831 832 dwc3_debugfs_create_endpoint_dir(dep, parent); 833 } 834 835 for (i = 0; i < dwc->num_out_eps; i++) { 836 u8 epnum = (i << 1); 837 struct dwc3_ep *dep = dwc->eps[epnum]; 838 839 if (!dep) 840 continue; 841 842 dwc3_debugfs_create_endpoint_dir(dep, parent); 843 } 844 } 845 846 void dwc3_debugfs_init(struct dwc3 *dwc) 847 { 848 struct dentry *root; 849 struct dentry *file; 850 851 root = debugfs_create_dir(dev_name(dwc->dev), NULL); 852 if (IS_ERR_OR_NULL(root)) { 853 if (!root) 854 dev_err(dwc->dev, "Can't create debugfs root\n"); 855 return; 856 } 857 dwc->root = root; 858 859 dwc->regset = kzalloc(sizeof(*dwc->regset), GFP_KERNEL); 860 if (!dwc->regset) { 861 debugfs_remove_recursive(root); 862 return; 863 } 864 865 dwc->regset->regs = dwc3_regs; 866 dwc->regset->nregs = ARRAY_SIZE(dwc3_regs); 867 dwc->regset->base = dwc->regs - DWC3_GLOBALS_REGS_START; 868 869 file = debugfs_create_regset32("regdump", S_IRUGO, root, dwc->regset); 870 if (!file) 871 dev_dbg(dwc->dev, "Can't create debugfs regdump\n"); 872 873 if (IS_ENABLED(CONFIG_USB_DWC3_DUAL_ROLE)) { 874 file = debugfs_create_file("mode", S_IRUGO | S_IWUSR, root, 875 dwc, &dwc3_mode_fops); 876 if (!file) 877 dev_dbg(dwc->dev, "Can't create debugfs mode\n"); 878 } 879 880 if (IS_ENABLED(CONFIG_USB_DWC3_DUAL_ROLE) || 881 IS_ENABLED(CONFIG_USB_DWC3_GADGET)) { 882 file = debugfs_create_file("testmode", S_IRUGO | S_IWUSR, root, 883 dwc, &dwc3_testmode_fops); 884 if (!file) 885 dev_dbg(dwc->dev, "Can't create debugfs testmode\n"); 886 887 file = debugfs_create_file("link_state", S_IRUGO | S_IWUSR, 888 root, dwc, &dwc3_link_state_fops); 889 if (!file) 890 dev_dbg(dwc->dev, "Can't create debugfs link_state\n"); 891 892 dwc3_debugfs_create_endpoint_dirs(dwc, root); 893 } 894 } 895 896 void dwc3_debugfs_exit(struct dwc3 *dwc) 897 { 898 debugfs_remove_recursive(dwc->root); 899 kfree(dwc->regset); 900 } 901