1 // SPDX-License-Identifier: GPL-2.0 2 /** 3 * debugfs.c - Designware USB2 DRD controller debugfs 4 * 5 * Copyright (C) 2015 Intel Corporation 6 * Mian Yousaf Kaukab <yousaf.kaukab@intel.com> 7 * 8 * This program is free software: you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 of 10 * the License as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 */ 17 18 #include <linux/spinlock.h> 19 #include <linux/debugfs.h> 20 #include <linux/seq_file.h> 21 #include <linux/uaccess.h> 22 23 #include "core.h" 24 #include "debug.h" 25 26 #if IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL) || \ 27 IS_ENABLED(CONFIG_USB_DWC2_DUAL_ROLE) 28 /** 29 * testmode_write - debugfs: change usb test mode 30 * @seq: The seq file to write to. 31 * @v: Unused parameter. 32 * 33 * This debugfs entry modify the current usb test mode. 34 */ 35 static ssize_t testmode_write(struct file *file, const char __user *ubuf, size_t 36 count, loff_t *ppos) 37 { 38 struct seq_file *s = file->private_data; 39 struct dwc2_hsotg *hsotg = s->private; 40 unsigned long flags; 41 u32 testmode = 0; 42 char buf[32]; 43 44 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 45 return -EFAULT; 46 47 if (!strncmp(buf, "test_j", 6)) 48 testmode = TEST_J; 49 else if (!strncmp(buf, "test_k", 6)) 50 testmode = TEST_K; 51 else if (!strncmp(buf, "test_se0_nak", 12)) 52 testmode = TEST_SE0_NAK; 53 else if (!strncmp(buf, "test_packet", 11)) 54 testmode = TEST_PACKET; 55 else if (!strncmp(buf, "test_force_enable", 17)) 56 testmode = TEST_FORCE_EN; 57 else 58 testmode = 0; 59 60 spin_lock_irqsave(&hsotg->lock, flags); 61 dwc2_hsotg_set_test_mode(hsotg, testmode); 62 spin_unlock_irqrestore(&hsotg->lock, flags); 63 return count; 64 } 65 66 /** 67 * testmode_show - debugfs: show usb test mode state 68 * @seq: The seq file to write to. 69 * @v: Unused parameter. 70 * 71 * This debugfs entry shows which usb test mode is currently enabled. 72 */ 73 static int testmode_show(struct seq_file *s, void *unused) 74 { 75 struct dwc2_hsotg *hsotg = s->private; 76 unsigned long flags; 77 int dctl; 78 79 spin_lock_irqsave(&hsotg->lock, flags); 80 dctl = dwc2_readl(hsotg->regs + DCTL); 81 dctl &= DCTL_TSTCTL_MASK; 82 dctl >>= DCTL_TSTCTL_SHIFT; 83 spin_unlock_irqrestore(&hsotg->lock, flags); 84 85 switch (dctl) { 86 case 0: 87 seq_puts(s, "no test\n"); 88 break; 89 case TEST_J: 90 seq_puts(s, "test_j\n"); 91 break; 92 case TEST_K: 93 seq_puts(s, "test_k\n"); 94 break; 95 case TEST_SE0_NAK: 96 seq_puts(s, "test_se0_nak\n"); 97 break; 98 case TEST_PACKET: 99 seq_puts(s, "test_packet\n"); 100 break; 101 case TEST_FORCE_EN: 102 seq_puts(s, "test_force_enable\n"); 103 break; 104 default: 105 seq_printf(s, "UNKNOWN %d\n", dctl); 106 } 107 108 return 0; 109 } 110 111 static int testmode_open(struct inode *inode, struct file *file) 112 { 113 return single_open(file, testmode_show, inode->i_private); 114 } 115 116 static const struct file_operations testmode_fops = { 117 .owner = THIS_MODULE, 118 .open = testmode_open, 119 .write = testmode_write, 120 .read = seq_read, 121 .llseek = seq_lseek, 122 .release = single_release, 123 }; 124 125 /** 126 * state_show - debugfs: show overall driver and device state. 127 * @seq: The seq file to write to. 128 * @v: Unused parameter. 129 * 130 * This debugfs entry shows the overall state of the hardware and 131 * some general information about each of the endpoints available 132 * to the system. 133 */ 134 static int state_show(struct seq_file *seq, void *v) 135 { 136 struct dwc2_hsotg *hsotg = seq->private; 137 void __iomem *regs = hsotg->regs; 138 int idx; 139 140 seq_printf(seq, "DCFG=0x%08x, DCTL=0x%08x, DSTS=0x%08x\n", 141 dwc2_readl(regs + DCFG), 142 dwc2_readl(regs + DCTL), 143 dwc2_readl(regs + DSTS)); 144 145 seq_printf(seq, "DIEPMSK=0x%08x, DOEPMASK=0x%08x\n", 146 dwc2_readl(regs + DIEPMSK), dwc2_readl(regs + DOEPMSK)); 147 148 seq_printf(seq, "GINTMSK=0x%08x, GINTSTS=0x%08x\n", 149 dwc2_readl(regs + GINTMSK), 150 dwc2_readl(regs + GINTSTS)); 151 152 seq_printf(seq, "DAINTMSK=0x%08x, DAINT=0x%08x\n", 153 dwc2_readl(regs + DAINTMSK), 154 dwc2_readl(regs + DAINT)); 155 156 seq_printf(seq, "GNPTXSTS=0x%08x, GRXSTSR=%08x\n", 157 dwc2_readl(regs + GNPTXSTS), 158 dwc2_readl(regs + GRXSTSR)); 159 160 seq_puts(seq, "\nEndpoint status:\n"); 161 162 for (idx = 0; idx < hsotg->num_of_eps; idx++) { 163 u32 in, out; 164 165 in = dwc2_readl(regs + DIEPCTL(idx)); 166 out = dwc2_readl(regs + DOEPCTL(idx)); 167 168 seq_printf(seq, "ep%d: DIEPCTL=0x%08x, DOEPCTL=0x%08x", 169 idx, in, out); 170 171 in = dwc2_readl(regs + DIEPTSIZ(idx)); 172 out = dwc2_readl(regs + DOEPTSIZ(idx)); 173 174 seq_printf(seq, ", DIEPTSIZ=0x%08x, DOEPTSIZ=0x%08x", 175 in, out); 176 177 seq_puts(seq, "\n"); 178 } 179 180 return 0; 181 } 182 183 static int state_open(struct inode *inode, struct file *file) 184 { 185 return single_open(file, state_show, inode->i_private); 186 } 187 188 static const struct file_operations state_fops = { 189 .owner = THIS_MODULE, 190 .open = state_open, 191 .read = seq_read, 192 .llseek = seq_lseek, 193 .release = single_release, 194 }; 195 196 /** 197 * fifo_show - debugfs: show the fifo information 198 * @seq: The seq_file to write data to. 199 * @v: Unused parameter. 200 * 201 * Show the FIFO information for the overall fifo and all the 202 * periodic transmission FIFOs. 203 */ 204 static int fifo_show(struct seq_file *seq, void *v) 205 { 206 struct dwc2_hsotg *hsotg = seq->private; 207 void __iomem *regs = hsotg->regs; 208 u32 val; 209 int idx; 210 211 seq_puts(seq, "Non-periodic FIFOs:\n"); 212 seq_printf(seq, "RXFIFO: Size %d\n", dwc2_readl(regs + GRXFSIZ)); 213 214 val = dwc2_readl(regs + GNPTXFSIZ); 215 seq_printf(seq, "NPTXFIFO: Size %d, Start 0x%08x\n", 216 val >> FIFOSIZE_DEPTH_SHIFT, 217 val & FIFOSIZE_STARTADDR_MASK); 218 219 seq_puts(seq, "\nPeriodic TXFIFOs:\n"); 220 221 for (idx = 1; idx < hsotg->num_of_eps; idx++) { 222 val = dwc2_readl(regs + DPTXFSIZN(idx)); 223 224 seq_printf(seq, "\tDPTXFIFO%2d: Size %d, Start 0x%08x\n", idx, 225 val >> FIFOSIZE_DEPTH_SHIFT, 226 val & FIFOSIZE_STARTADDR_MASK); 227 } 228 229 return 0; 230 } 231 232 static int fifo_open(struct inode *inode, struct file *file) 233 { 234 return single_open(file, fifo_show, inode->i_private); 235 } 236 237 static const struct file_operations fifo_fops = { 238 .owner = THIS_MODULE, 239 .open = fifo_open, 240 .read = seq_read, 241 .llseek = seq_lseek, 242 .release = single_release, 243 }; 244 245 static const char *decode_direction(int is_in) 246 { 247 return is_in ? "in" : "out"; 248 } 249 250 /** 251 * ep_show - debugfs: show the state of an endpoint. 252 * @seq: The seq_file to write data to. 253 * @v: Unused parameter. 254 * 255 * This debugfs entry shows the state of the given endpoint (one is 256 * registered for each available). 257 */ 258 static int ep_show(struct seq_file *seq, void *v) 259 { 260 struct dwc2_hsotg_ep *ep = seq->private; 261 struct dwc2_hsotg *hsotg = ep->parent; 262 struct dwc2_hsotg_req *req; 263 void __iomem *regs = hsotg->regs; 264 int index = ep->index; 265 int show_limit = 15; 266 unsigned long flags; 267 268 seq_printf(seq, "Endpoint index %d, named %s, dir %s:\n", 269 ep->index, ep->ep.name, decode_direction(ep->dir_in)); 270 271 /* first show the register state */ 272 273 seq_printf(seq, "\tDIEPCTL=0x%08x, DOEPCTL=0x%08x\n", 274 dwc2_readl(regs + DIEPCTL(index)), 275 dwc2_readl(regs + DOEPCTL(index))); 276 277 seq_printf(seq, "\tDIEPDMA=0x%08x, DOEPDMA=0x%08x\n", 278 dwc2_readl(regs + DIEPDMA(index)), 279 dwc2_readl(regs + DOEPDMA(index))); 280 281 seq_printf(seq, "\tDIEPINT=0x%08x, DOEPINT=0x%08x\n", 282 dwc2_readl(regs + DIEPINT(index)), 283 dwc2_readl(regs + DOEPINT(index))); 284 285 seq_printf(seq, "\tDIEPTSIZ=0x%08x, DOEPTSIZ=0x%08x\n", 286 dwc2_readl(regs + DIEPTSIZ(index)), 287 dwc2_readl(regs + DOEPTSIZ(index))); 288 289 seq_puts(seq, "\n"); 290 seq_printf(seq, "mps %d\n", ep->ep.maxpacket); 291 seq_printf(seq, "total_data=%ld\n", ep->total_data); 292 293 seq_printf(seq, "request list (%p,%p):\n", 294 ep->queue.next, ep->queue.prev); 295 296 spin_lock_irqsave(&hsotg->lock, flags); 297 298 list_for_each_entry(req, &ep->queue, queue) { 299 if (--show_limit < 0) { 300 seq_puts(seq, "not showing more requests...\n"); 301 break; 302 } 303 304 seq_printf(seq, "%c req %p: %d bytes @%p, ", 305 req == ep->req ? '*' : ' ', 306 req, req->req.length, req->req.buf); 307 seq_printf(seq, "%d done, res %d\n", 308 req->req.actual, req->req.status); 309 } 310 311 spin_unlock_irqrestore(&hsotg->lock, flags); 312 313 return 0; 314 } 315 316 static int ep_open(struct inode *inode, struct file *file) 317 { 318 return single_open(file, ep_show, inode->i_private); 319 } 320 321 static const struct file_operations ep_fops = { 322 .owner = THIS_MODULE, 323 .open = ep_open, 324 .read = seq_read, 325 .llseek = seq_lseek, 326 .release = single_release, 327 }; 328 329 /** 330 * dwc2_hsotg_create_debug - create debugfs directory and files 331 * @hsotg: The driver state 332 * 333 * Create the debugfs files to allow the user to get information 334 * about the state of the system. The directory name is created 335 * with the same name as the device itself, in case we end up 336 * with multiple blocks in future systems. 337 */ 338 static void dwc2_hsotg_create_debug(struct dwc2_hsotg *hsotg) 339 { 340 struct dentry *root; 341 struct dentry *file; 342 unsigned int epidx; 343 344 root = hsotg->debug_root; 345 346 /* create general state file */ 347 348 file = debugfs_create_file("state", 0444, root, hsotg, &state_fops); 349 if (IS_ERR(file)) 350 dev_err(hsotg->dev, "%s: failed to create state\n", __func__); 351 352 file = debugfs_create_file("testmode", 0644, root, hsotg, 353 &testmode_fops); 354 if (IS_ERR(file)) 355 dev_err(hsotg->dev, "%s: failed to create testmode\n", 356 __func__); 357 358 file = debugfs_create_file("fifo", 0444, root, hsotg, &fifo_fops); 359 if (IS_ERR(file)) 360 dev_err(hsotg->dev, "%s: failed to create fifo\n", __func__); 361 362 /* Create one file for each out endpoint */ 363 for (epidx = 0; epidx < hsotg->num_of_eps; epidx++) { 364 struct dwc2_hsotg_ep *ep; 365 366 ep = hsotg->eps_out[epidx]; 367 if (ep) { 368 file = debugfs_create_file(ep->name, 0444, 369 root, ep, &ep_fops); 370 if (IS_ERR(file)) 371 dev_err(hsotg->dev, "failed to create %s debug file\n", 372 ep->name); 373 } 374 } 375 /* Create one file for each in endpoint. EP0 is handled with out eps */ 376 for (epidx = 1; epidx < hsotg->num_of_eps; epidx++) { 377 struct dwc2_hsotg_ep *ep; 378 379 ep = hsotg->eps_in[epidx]; 380 if (ep) { 381 file = debugfs_create_file(ep->name, 0444, 382 root, ep, &ep_fops); 383 if (IS_ERR(file)) 384 dev_err(hsotg->dev, "failed to create %s debug file\n", 385 ep->name); 386 } 387 } 388 } 389 #else 390 static inline void dwc2_hsotg_create_debug(struct dwc2_hsotg *hsotg) {} 391 #endif 392 393 /* dwc2_hsotg_delete_debug is removed as cleanup in done in dwc2_debugfs_exit */ 394 395 #define dump_register(nm) \ 396 { \ 397 .name = #nm, \ 398 .offset = nm, \ 399 } 400 401 static const struct debugfs_reg32 dwc2_regs[] = { 402 /* 403 * Accessing registers like this can trigger mode mismatch interrupt. 404 * However, according to dwc2 databook, the register access, in this 405 * case, is completed on the processor bus but is ignored by the core 406 * and does not affect its operation. 407 */ 408 dump_register(GOTGCTL), 409 dump_register(GOTGINT), 410 dump_register(GAHBCFG), 411 dump_register(GUSBCFG), 412 dump_register(GRSTCTL), 413 dump_register(GINTSTS), 414 dump_register(GINTMSK), 415 dump_register(GRXSTSR), 416 dump_register(GRXSTSP), 417 dump_register(GRXFSIZ), 418 dump_register(GNPTXFSIZ), 419 dump_register(GNPTXSTS), 420 dump_register(GI2CCTL), 421 dump_register(GPVNDCTL), 422 dump_register(GGPIO), 423 dump_register(GUID), 424 dump_register(GSNPSID), 425 dump_register(GHWCFG1), 426 dump_register(GHWCFG2), 427 dump_register(GHWCFG3), 428 dump_register(GHWCFG4), 429 dump_register(GLPMCFG), 430 dump_register(GPWRDN), 431 dump_register(GDFIFOCFG), 432 dump_register(ADPCTL), 433 dump_register(HPTXFSIZ), 434 dump_register(DPTXFSIZN(1)), 435 dump_register(DPTXFSIZN(2)), 436 dump_register(DPTXFSIZN(3)), 437 dump_register(DPTXFSIZN(4)), 438 dump_register(DPTXFSIZN(5)), 439 dump_register(DPTXFSIZN(6)), 440 dump_register(DPTXFSIZN(7)), 441 dump_register(DPTXFSIZN(8)), 442 dump_register(DPTXFSIZN(9)), 443 dump_register(DPTXFSIZN(10)), 444 dump_register(DPTXFSIZN(11)), 445 dump_register(DPTXFSIZN(12)), 446 dump_register(DPTXFSIZN(13)), 447 dump_register(DPTXFSIZN(14)), 448 dump_register(DPTXFSIZN(15)), 449 dump_register(DCFG), 450 dump_register(DCTL), 451 dump_register(DSTS), 452 dump_register(DIEPMSK), 453 dump_register(DOEPMSK), 454 dump_register(DAINT), 455 dump_register(DAINTMSK), 456 dump_register(DTKNQR1), 457 dump_register(DTKNQR2), 458 dump_register(DTKNQR3), 459 dump_register(DTKNQR4), 460 dump_register(DVBUSDIS), 461 dump_register(DVBUSPULSE), 462 dump_register(DIEPCTL(0)), 463 dump_register(DIEPCTL(1)), 464 dump_register(DIEPCTL(2)), 465 dump_register(DIEPCTL(3)), 466 dump_register(DIEPCTL(4)), 467 dump_register(DIEPCTL(5)), 468 dump_register(DIEPCTL(6)), 469 dump_register(DIEPCTL(7)), 470 dump_register(DIEPCTL(8)), 471 dump_register(DIEPCTL(9)), 472 dump_register(DIEPCTL(10)), 473 dump_register(DIEPCTL(11)), 474 dump_register(DIEPCTL(12)), 475 dump_register(DIEPCTL(13)), 476 dump_register(DIEPCTL(14)), 477 dump_register(DIEPCTL(15)), 478 dump_register(DOEPCTL(0)), 479 dump_register(DOEPCTL(1)), 480 dump_register(DOEPCTL(2)), 481 dump_register(DOEPCTL(3)), 482 dump_register(DOEPCTL(4)), 483 dump_register(DOEPCTL(5)), 484 dump_register(DOEPCTL(6)), 485 dump_register(DOEPCTL(7)), 486 dump_register(DOEPCTL(8)), 487 dump_register(DOEPCTL(9)), 488 dump_register(DOEPCTL(10)), 489 dump_register(DOEPCTL(11)), 490 dump_register(DOEPCTL(12)), 491 dump_register(DOEPCTL(13)), 492 dump_register(DOEPCTL(14)), 493 dump_register(DOEPCTL(15)), 494 dump_register(DIEPINT(0)), 495 dump_register(DIEPINT(1)), 496 dump_register(DIEPINT(2)), 497 dump_register(DIEPINT(3)), 498 dump_register(DIEPINT(4)), 499 dump_register(DIEPINT(5)), 500 dump_register(DIEPINT(6)), 501 dump_register(DIEPINT(7)), 502 dump_register(DIEPINT(8)), 503 dump_register(DIEPINT(9)), 504 dump_register(DIEPINT(10)), 505 dump_register(DIEPINT(11)), 506 dump_register(DIEPINT(12)), 507 dump_register(DIEPINT(13)), 508 dump_register(DIEPINT(14)), 509 dump_register(DIEPINT(15)), 510 dump_register(DOEPINT(0)), 511 dump_register(DOEPINT(1)), 512 dump_register(DOEPINT(2)), 513 dump_register(DOEPINT(3)), 514 dump_register(DOEPINT(4)), 515 dump_register(DOEPINT(5)), 516 dump_register(DOEPINT(6)), 517 dump_register(DOEPINT(7)), 518 dump_register(DOEPINT(8)), 519 dump_register(DOEPINT(9)), 520 dump_register(DOEPINT(10)), 521 dump_register(DOEPINT(11)), 522 dump_register(DOEPINT(12)), 523 dump_register(DOEPINT(13)), 524 dump_register(DOEPINT(14)), 525 dump_register(DOEPINT(15)), 526 dump_register(DIEPTSIZ(0)), 527 dump_register(DIEPTSIZ(1)), 528 dump_register(DIEPTSIZ(2)), 529 dump_register(DIEPTSIZ(3)), 530 dump_register(DIEPTSIZ(4)), 531 dump_register(DIEPTSIZ(5)), 532 dump_register(DIEPTSIZ(6)), 533 dump_register(DIEPTSIZ(7)), 534 dump_register(DIEPTSIZ(8)), 535 dump_register(DIEPTSIZ(9)), 536 dump_register(DIEPTSIZ(10)), 537 dump_register(DIEPTSIZ(11)), 538 dump_register(DIEPTSIZ(12)), 539 dump_register(DIEPTSIZ(13)), 540 dump_register(DIEPTSIZ(14)), 541 dump_register(DIEPTSIZ(15)), 542 dump_register(DOEPTSIZ(0)), 543 dump_register(DOEPTSIZ(1)), 544 dump_register(DOEPTSIZ(2)), 545 dump_register(DOEPTSIZ(3)), 546 dump_register(DOEPTSIZ(4)), 547 dump_register(DOEPTSIZ(5)), 548 dump_register(DOEPTSIZ(6)), 549 dump_register(DOEPTSIZ(7)), 550 dump_register(DOEPTSIZ(8)), 551 dump_register(DOEPTSIZ(9)), 552 dump_register(DOEPTSIZ(10)), 553 dump_register(DOEPTSIZ(11)), 554 dump_register(DOEPTSIZ(12)), 555 dump_register(DOEPTSIZ(13)), 556 dump_register(DOEPTSIZ(14)), 557 dump_register(DOEPTSIZ(15)), 558 dump_register(DIEPDMA(0)), 559 dump_register(DIEPDMA(1)), 560 dump_register(DIEPDMA(2)), 561 dump_register(DIEPDMA(3)), 562 dump_register(DIEPDMA(4)), 563 dump_register(DIEPDMA(5)), 564 dump_register(DIEPDMA(6)), 565 dump_register(DIEPDMA(7)), 566 dump_register(DIEPDMA(8)), 567 dump_register(DIEPDMA(9)), 568 dump_register(DIEPDMA(10)), 569 dump_register(DIEPDMA(11)), 570 dump_register(DIEPDMA(12)), 571 dump_register(DIEPDMA(13)), 572 dump_register(DIEPDMA(14)), 573 dump_register(DIEPDMA(15)), 574 dump_register(DOEPDMA(0)), 575 dump_register(DOEPDMA(1)), 576 dump_register(DOEPDMA(2)), 577 dump_register(DOEPDMA(3)), 578 dump_register(DOEPDMA(4)), 579 dump_register(DOEPDMA(5)), 580 dump_register(DOEPDMA(6)), 581 dump_register(DOEPDMA(7)), 582 dump_register(DOEPDMA(8)), 583 dump_register(DOEPDMA(9)), 584 dump_register(DOEPDMA(10)), 585 dump_register(DOEPDMA(11)), 586 dump_register(DOEPDMA(12)), 587 dump_register(DOEPDMA(13)), 588 dump_register(DOEPDMA(14)), 589 dump_register(DOEPDMA(15)), 590 dump_register(DTXFSTS(0)), 591 dump_register(DTXFSTS(1)), 592 dump_register(DTXFSTS(2)), 593 dump_register(DTXFSTS(3)), 594 dump_register(DTXFSTS(4)), 595 dump_register(DTXFSTS(5)), 596 dump_register(DTXFSTS(6)), 597 dump_register(DTXFSTS(7)), 598 dump_register(DTXFSTS(8)), 599 dump_register(DTXFSTS(9)), 600 dump_register(DTXFSTS(10)), 601 dump_register(DTXFSTS(11)), 602 dump_register(DTXFSTS(12)), 603 dump_register(DTXFSTS(13)), 604 dump_register(DTXFSTS(14)), 605 dump_register(DTXFSTS(15)), 606 dump_register(PCGCTL), 607 dump_register(HCFG), 608 dump_register(HFIR), 609 dump_register(HFNUM), 610 dump_register(HPTXSTS), 611 dump_register(HAINT), 612 dump_register(HAINTMSK), 613 dump_register(HFLBADDR), 614 dump_register(HPRT0), 615 dump_register(HCCHAR(0)), 616 dump_register(HCCHAR(1)), 617 dump_register(HCCHAR(2)), 618 dump_register(HCCHAR(3)), 619 dump_register(HCCHAR(4)), 620 dump_register(HCCHAR(5)), 621 dump_register(HCCHAR(6)), 622 dump_register(HCCHAR(7)), 623 dump_register(HCCHAR(8)), 624 dump_register(HCCHAR(9)), 625 dump_register(HCCHAR(10)), 626 dump_register(HCCHAR(11)), 627 dump_register(HCCHAR(12)), 628 dump_register(HCCHAR(13)), 629 dump_register(HCCHAR(14)), 630 dump_register(HCCHAR(15)), 631 dump_register(HCSPLT(0)), 632 dump_register(HCSPLT(1)), 633 dump_register(HCSPLT(2)), 634 dump_register(HCSPLT(3)), 635 dump_register(HCSPLT(4)), 636 dump_register(HCSPLT(5)), 637 dump_register(HCSPLT(6)), 638 dump_register(HCSPLT(7)), 639 dump_register(HCSPLT(8)), 640 dump_register(HCSPLT(9)), 641 dump_register(HCSPLT(10)), 642 dump_register(HCSPLT(11)), 643 dump_register(HCSPLT(12)), 644 dump_register(HCSPLT(13)), 645 dump_register(HCSPLT(14)), 646 dump_register(HCSPLT(15)), 647 dump_register(HCINT(0)), 648 dump_register(HCINT(1)), 649 dump_register(HCINT(2)), 650 dump_register(HCINT(3)), 651 dump_register(HCINT(4)), 652 dump_register(HCINT(5)), 653 dump_register(HCINT(6)), 654 dump_register(HCINT(7)), 655 dump_register(HCINT(8)), 656 dump_register(HCINT(9)), 657 dump_register(HCINT(10)), 658 dump_register(HCINT(11)), 659 dump_register(HCINT(12)), 660 dump_register(HCINT(13)), 661 dump_register(HCINT(14)), 662 dump_register(HCINT(15)), 663 dump_register(HCINTMSK(0)), 664 dump_register(HCINTMSK(1)), 665 dump_register(HCINTMSK(2)), 666 dump_register(HCINTMSK(3)), 667 dump_register(HCINTMSK(4)), 668 dump_register(HCINTMSK(5)), 669 dump_register(HCINTMSK(6)), 670 dump_register(HCINTMSK(7)), 671 dump_register(HCINTMSK(8)), 672 dump_register(HCINTMSK(9)), 673 dump_register(HCINTMSK(10)), 674 dump_register(HCINTMSK(11)), 675 dump_register(HCINTMSK(12)), 676 dump_register(HCINTMSK(13)), 677 dump_register(HCINTMSK(14)), 678 dump_register(HCINTMSK(15)), 679 dump_register(HCTSIZ(0)), 680 dump_register(HCTSIZ(1)), 681 dump_register(HCTSIZ(2)), 682 dump_register(HCTSIZ(3)), 683 dump_register(HCTSIZ(4)), 684 dump_register(HCTSIZ(5)), 685 dump_register(HCTSIZ(6)), 686 dump_register(HCTSIZ(7)), 687 dump_register(HCTSIZ(8)), 688 dump_register(HCTSIZ(9)), 689 dump_register(HCTSIZ(10)), 690 dump_register(HCTSIZ(11)), 691 dump_register(HCTSIZ(12)), 692 dump_register(HCTSIZ(13)), 693 dump_register(HCTSIZ(14)), 694 dump_register(HCTSIZ(15)), 695 dump_register(HCDMA(0)), 696 dump_register(HCDMA(1)), 697 dump_register(HCDMA(2)), 698 dump_register(HCDMA(3)), 699 dump_register(HCDMA(4)), 700 dump_register(HCDMA(5)), 701 dump_register(HCDMA(6)), 702 dump_register(HCDMA(7)), 703 dump_register(HCDMA(8)), 704 dump_register(HCDMA(9)), 705 dump_register(HCDMA(10)), 706 dump_register(HCDMA(11)), 707 dump_register(HCDMA(12)), 708 dump_register(HCDMA(13)), 709 dump_register(HCDMA(14)), 710 dump_register(HCDMA(15)), 711 dump_register(HCDMAB(0)), 712 dump_register(HCDMAB(1)), 713 dump_register(HCDMAB(2)), 714 dump_register(HCDMAB(3)), 715 dump_register(HCDMAB(4)), 716 dump_register(HCDMAB(5)), 717 dump_register(HCDMAB(6)), 718 dump_register(HCDMAB(7)), 719 dump_register(HCDMAB(8)), 720 dump_register(HCDMAB(9)), 721 dump_register(HCDMAB(10)), 722 dump_register(HCDMAB(11)), 723 dump_register(HCDMAB(12)), 724 dump_register(HCDMAB(13)), 725 dump_register(HCDMAB(14)), 726 dump_register(HCDMAB(15)), 727 }; 728 729 #define print_param(_seq, _ptr, _param) \ 730 seq_printf((_seq), "%-30s: %d\n", #_param, (_ptr)->_param) 731 732 #define print_param_hex(_seq, _ptr, _param) \ 733 seq_printf((_seq), "%-30s: 0x%x\n", #_param, (_ptr)->_param) 734 735 static int params_show(struct seq_file *seq, void *v) 736 { 737 struct dwc2_hsotg *hsotg = seq->private; 738 struct dwc2_core_params *p = &hsotg->params; 739 int i; 740 741 print_param(seq, p, otg_cap); 742 print_param(seq, p, dma_desc_enable); 743 print_param(seq, p, dma_desc_fs_enable); 744 print_param(seq, p, speed); 745 print_param(seq, p, enable_dynamic_fifo); 746 print_param(seq, p, en_multiple_tx_fifo); 747 print_param(seq, p, host_rx_fifo_size); 748 print_param(seq, p, host_nperio_tx_fifo_size); 749 print_param(seq, p, host_perio_tx_fifo_size); 750 print_param(seq, p, max_transfer_size); 751 print_param(seq, p, max_packet_count); 752 print_param(seq, p, host_channels); 753 print_param(seq, p, phy_type); 754 print_param(seq, p, phy_utmi_width); 755 print_param(seq, p, phy_ulpi_ddr); 756 print_param(seq, p, phy_ulpi_ext_vbus); 757 print_param(seq, p, i2c_enable); 758 print_param(seq, p, ulpi_fs_ls); 759 print_param(seq, p, host_support_fs_ls_low_power); 760 print_param(seq, p, host_ls_low_power_phy_clk); 761 print_param(seq, p, ts_dline); 762 print_param(seq, p, reload_ctl); 763 print_param_hex(seq, p, ahbcfg); 764 print_param(seq, p, uframe_sched); 765 print_param(seq, p, external_id_pin_ctl); 766 print_param(seq, p, hibernation); 767 print_param(seq, p, host_dma); 768 print_param(seq, p, g_dma); 769 print_param(seq, p, g_dma_desc); 770 print_param(seq, p, g_rx_fifo_size); 771 print_param(seq, p, g_np_tx_fifo_size); 772 773 for (i = 0; i < MAX_EPS_CHANNELS; i++) { 774 char str[32]; 775 776 snprintf(str, 32, "g_tx_fifo_size[%d]", i); 777 seq_printf(seq, "%-30s: %d\n", str, p->g_tx_fifo_size[i]); 778 } 779 780 return 0; 781 } 782 783 static int params_open(struct inode *inode, struct file *file) 784 { 785 return single_open(file, params_show, inode->i_private); 786 } 787 788 static const struct file_operations params_fops = { 789 .owner = THIS_MODULE, 790 .open = params_open, 791 .read = seq_read, 792 .llseek = seq_lseek, 793 .release = single_release, 794 }; 795 796 static int hw_params_show(struct seq_file *seq, void *v) 797 { 798 struct dwc2_hsotg *hsotg = seq->private; 799 struct dwc2_hw_params *hw = &hsotg->hw_params; 800 801 print_param(seq, hw, op_mode); 802 print_param(seq, hw, arch); 803 print_param(seq, hw, dma_desc_enable); 804 print_param(seq, hw, enable_dynamic_fifo); 805 print_param(seq, hw, en_multiple_tx_fifo); 806 print_param(seq, hw, rx_fifo_size); 807 print_param(seq, hw, host_nperio_tx_fifo_size); 808 print_param(seq, hw, dev_nperio_tx_fifo_size); 809 print_param(seq, hw, host_perio_tx_fifo_size); 810 print_param(seq, hw, nperio_tx_q_depth); 811 print_param(seq, hw, host_perio_tx_q_depth); 812 print_param(seq, hw, dev_token_q_depth); 813 print_param(seq, hw, max_transfer_size); 814 print_param(seq, hw, max_packet_count); 815 print_param(seq, hw, host_channels); 816 print_param(seq, hw, hs_phy_type); 817 print_param(seq, hw, fs_phy_type); 818 print_param(seq, hw, i2c_enable); 819 print_param(seq, hw, num_dev_ep); 820 print_param(seq, hw, num_dev_perio_in_ep); 821 print_param(seq, hw, total_fifo_size); 822 print_param(seq, hw, power_optimized); 823 print_param(seq, hw, utmi_phy_data_width); 824 print_param_hex(seq, hw, snpsid); 825 print_param_hex(seq, hw, dev_ep_dirs); 826 827 return 0; 828 } 829 830 static int hw_params_open(struct inode *inode, struct file *file) 831 { 832 return single_open(file, hw_params_show, inode->i_private); 833 } 834 835 static const struct file_operations hw_params_fops = { 836 .owner = THIS_MODULE, 837 .open = hw_params_open, 838 .read = seq_read, 839 .llseek = seq_lseek, 840 .release = single_release, 841 }; 842 843 static int dr_mode_show(struct seq_file *seq, void *v) 844 { 845 struct dwc2_hsotg *hsotg = seq->private; 846 const char *dr_mode = ""; 847 848 device_property_read_string(hsotg->dev, "dr_mode", &dr_mode); 849 seq_printf(seq, "%s\n", dr_mode); 850 return 0; 851 } 852 853 static int dr_mode_open(struct inode *inode, struct file *file) 854 { 855 return single_open(file, dr_mode_show, inode->i_private); 856 } 857 858 static const struct file_operations dr_mode_fops = { 859 .owner = THIS_MODULE, 860 .open = dr_mode_open, 861 .read = seq_read, 862 .llseek = seq_lseek, 863 .release = single_release, 864 }; 865 866 int dwc2_debugfs_init(struct dwc2_hsotg *hsotg) 867 { 868 int ret; 869 struct dentry *file; 870 871 hsotg->debug_root = debugfs_create_dir(dev_name(hsotg->dev), NULL); 872 if (!hsotg->debug_root) { 873 ret = -ENOMEM; 874 goto err0; 875 } 876 877 file = debugfs_create_file("params", 0444, 878 hsotg->debug_root, 879 hsotg, ¶ms_fops); 880 if (IS_ERR(file)) 881 dev_err(hsotg->dev, "%s: failed to create params\n", __func__); 882 883 file = debugfs_create_file("hw_params", 0444, 884 hsotg->debug_root, 885 hsotg, &hw_params_fops); 886 if (IS_ERR(file)) 887 dev_err(hsotg->dev, "%s: failed to create hw_params\n", 888 __func__); 889 890 file = debugfs_create_file("dr_mode", 0444, 891 hsotg->debug_root, 892 hsotg, &dr_mode_fops); 893 if (IS_ERR(file)) 894 dev_err(hsotg->dev, "%s: failed to create dr_mode\n", __func__); 895 896 /* Add gadget debugfs nodes */ 897 dwc2_hsotg_create_debug(hsotg); 898 899 hsotg->regset = devm_kzalloc(hsotg->dev, sizeof(*hsotg->regset), 900 GFP_KERNEL); 901 if (!hsotg->regset) { 902 ret = -ENOMEM; 903 goto err1; 904 } 905 906 hsotg->regset->regs = dwc2_regs; 907 hsotg->regset->nregs = ARRAY_SIZE(dwc2_regs); 908 hsotg->regset->base = hsotg->regs; 909 910 file = debugfs_create_regset32("regdump", 0444, hsotg->debug_root, 911 hsotg->regset); 912 if (!file) { 913 ret = -ENOMEM; 914 goto err1; 915 } 916 917 return 0; 918 err1: 919 debugfs_remove_recursive(hsotg->debug_root); 920 err0: 921 return ret; 922 } 923 924 void dwc2_debugfs_exit(struct dwc2_hsotg *hsotg) 925 { 926 debugfs_remove_recursive(hsotg->debug_root); 927 hsotg->debug_root = NULL; 928 } 929