1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * mtu3_debugfs.c - debugfs interface 4 * 5 * Copyright (C) 2019 MediaTek Inc. 6 * 7 * Author: Chunfeng Yun <chunfeng.yun@mediatek.com> 8 */ 9 10 #include <linux/uaccess.h> 11 12 #include "mtu3.h" 13 #include "mtu3_dr.h" 14 #include "mtu3_debug.h" 15 16 #define dump_register(nm) \ 17 { \ 18 .name = __stringify(nm), \ 19 .offset = U3D_ ##nm, \ 20 } 21 22 #define dump_prb_reg(nm, os) \ 23 { \ 24 .name = nm, \ 25 .offset = os, \ 26 } 27 28 static const struct debugfs_reg32 mtu3_ippc_regs[] = { 29 dump_register(SSUSB_IP_PW_CTRL0), 30 dump_register(SSUSB_IP_PW_CTRL1), 31 dump_register(SSUSB_IP_PW_CTRL2), 32 dump_register(SSUSB_IP_PW_CTRL3), 33 dump_register(SSUSB_OTG_STS), 34 dump_register(SSUSB_IP_XHCI_CAP), 35 dump_register(SSUSB_IP_DEV_CAP), 36 dump_register(SSUSB_U3_CTRL_0P), 37 dump_register(SSUSB_U2_CTRL_0P), 38 dump_register(SSUSB_HW_ID), 39 dump_register(SSUSB_HW_SUB_ID), 40 dump_register(SSUSB_IP_SPARE0), 41 }; 42 43 static const struct debugfs_reg32 mtu3_dev_regs[] = { 44 dump_register(LV1ISR), 45 dump_register(LV1IER), 46 dump_register(EPISR), 47 dump_register(EPIER), 48 dump_register(EP0CSR), 49 dump_register(RXCOUNT0), 50 dump_register(QISAR0), 51 dump_register(QIER0), 52 dump_register(QISAR1), 53 dump_register(QIER1), 54 dump_register(CAP_EPNTXFFSZ), 55 dump_register(CAP_EPNRXFFSZ), 56 dump_register(CAP_EPINFO), 57 dump_register(MISC_CTRL), 58 }; 59 60 static const struct debugfs_reg32 mtu3_csr_regs[] = { 61 dump_register(DEVICE_CONF), 62 dump_register(DEV_LINK_INTR_ENABLE), 63 dump_register(DEV_LINK_INTR), 64 dump_register(LTSSM_CTRL), 65 dump_register(USB3_CONFIG), 66 dump_register(LINK_STATE_MACHINE), 67 dump_register(LTSSM_INTR_ENABLE), 68 dump_register(LTSSM_INTR), 69 dump_register(U3U2_SWITCH_CTRL), 70 dump_register(POWER_MANAGEMENT), 71 dump_register(DEVICE_CONTROL), 72 dump_register(COMMON_USB_INTR_ENABLE), 73 dump_register(COMMON_USB_INTR), 74 dump_register(USB20_MISC_CONTROL), 75 dump_register(USB20_OPSTATE), 76 }; 77 78 static int mtu3_link_state_show(struct seq_file *sf, void *unused) 79 { 80 struct mtu3 *mtu = sf->private; 81 void __iomem *mbase = mtu->mac_base; 82 83 seq_printf(sf, "opstate: %#x, ltssm: %#x\n", 84 mtu3_readl(mbase, U3D_USB20_OPSTATE), 85 LTSSM_STATE(mtu3_readl(mbase, U3D_LINK_STATE_MACHINE))); 86 87 return 0; 88 } 89 90 static int mtu3_ep_used_show(struct seq_file *sf, void *unused) 91 { 92 struct mtu3 *mtu = sf->private; 93 struct mtu3_ep *mep; 94 unsigned long flags; 95 int used = 0; 96 int i; 97 98 spin_lock_irqsave(&mtu->lock, flags); 99 100 for (i = 0; i < mtu->num_eps; i++) { 101 mep = mtu->in_eps + i; 102 if (mep->flags & MTU3_EP_ENABLED) { 103 seq_printf(sf, "%s - type: %d\n", mep->name, mep->type); 104 used++; 105 } 106 107 mep = mtu->out_eps + i; 108 if (mep->flags & MTU3_EP_ENABLED) { 109 seq_printf(sf, "%s - type: %d\n", mep->name, mep->type); 110 used++; 111 } 112 } 113 seq_printf(sf, "total used: %d eps\n", used); 114 115 spin_unlock_irqrestore(&mtu->lock, flags); 116 117 return 0; 118 } 119 120 DEFINE_SHOW_ATTRIBUTE(mtu3_link_state); 121 DEFINE_SHOW_ATTRIBUTE(mtu3_ep_used); 122 123 static void mtu3_debugfs_regset(struct mtu3 *mtu, void __iomem *base, 124 const struct debugfs_reg32 *regs, size_t nregs, 125 const char *name, struct dentry *parent) 126 { 127 struct debugfs_regset32 *regset; 128 struct mtu3_regset *mregs; 129 130 mregs = devm_kzalloc(mtu->dev, sizeof(*regset), GFP_KERNEL); 131 if (!mregs) 132 return; 133 134 sprintf(mregs->name, "%s", name); 135 regset = &mregs->regset; 136 regset->regs = regs; 137 regset->nregs = nregs; 138 regset->base = base; 139 140 debugfs_create_regset32(mregs->name, 0444, parent, regset); 141 } 142 143 static void mtu3_debugfs_ep_regset(struct mtu3 *mtu, struct mtu3_ep *mep, 144 struct dentry *parent) 145 { 146 struct debugfs_reg32 *regs; 147 int epnum = mep->epnum; 148 int in = mep->is_in; 149 150 regs = devm_kcalloc(mtu->dev, 7, sizeof(*regs), GFP_KERNEL); 151 if (!regs) 152 return; 153 154 regs[0].name = in ? "TCR0" : "RCR0"; 155 regs[0].offset = in ? MU3D_EP_TXCR0(epnum) : MU3D_EP_RXCR0(epnum); 156 regs[1].name = in ? "TCR1" : "RCR1"; 157 regs[1].offset = in ? MU3D_EP_TXCR1(epnum) : MU3D_EP_RXCR1(epnum); 158 regs[2].name = in ? "TCR2" : "RCR2"; 159 regs[2].offset = in ? MU3D_EP_TXCR2(epnum) : MU3D_EP_RXCR2(epnum); 160 regs[3].name = in ? "TQHIAR" : "RQHIAR"; 161 regs[3].offset = in ? USB_QMU_TQHIAR(epnum) : USB_QMU_RQHIAR(epnum); 162 regs[4].name = in ? "TQCSR" : "RQCSR"; 163 regs[4].offset = in ? USB_QMU_TQCSR(epnum) : USB_QMU_RQCSR(epnum); 164 regs[5].name = in ? "TQSAR" : "RQSAR"; 165 regs[5].offset = in ? USB_QMU_TQSAR(epnum) : USB_QMU_RQSAR(epnum); 166 regs[6].name = in ? "TQCPR" : "RQCPR"; 167 regs[6].offset = in ? USB_QMU_TQCPR(epnum) : USB_QMU_RQCPR(epnum); 168 169 mtu3_debugfs_regset(mtu, mtu->mac_base, regs, 7, "ep-regs", parent); 170 } 171 172 static int mtu3_ep_info_show(struct seq_file *sf, void *unused) 173 { 174 struct mtu3_ep *mep = sf->private; 175 struct mtu3 *mtu = mep->mtu; 176 unsigned long flags; 177 178 spin_lock_irqsave(&mtu->lock, flags); 179 seq_printf(sf, "ep - type:%d, maxp:%d, slot:%d, flags:%x\n", 180 mep->type, mep->maxp, mep->slot, mep->flags); 181 spin_unlock_irqrestore(&mtu->lock, flags); 182 183 return 0; 184 } 185 186 static int mtu3_fifo_show(struct seq_file *sf, void *unused) 187 { 188 struct mtu3_ep *mep = sf->private; 189 struct mtu3 *mtu = mep->mtu; 190 unsigned long flags; 191 192 spin_lock_irqsave(&mtu->lock, flags); 193 seq_printf(sf, "fifo - seg_size:%d, addr:%d, size:%d\n", 194 mep->fifo_seg_size, mep->fifo_addr, mep->fifo_size); 195 spin_unlock_irqrestore(&mtu->lock, flags); 196 197 return 0; 198 } 199 200 static int mtu3_qmu_ring_show(struct seq_file *sf, void *unused) 201 { 202 struct mtu3_ep *mep = sf->private; 203 struct mtu3 *mtu = mep->mtu; 204 struct mtu3_gpd_ring *ring; 205 unsigned long flags; 206 207 ring = &mep->gpd_ring; 208 spin_lock_irqsave(&mtu->lock, flags); 209 seq_printf(sf, 210 "qmu-ring - dma:%pad, start:%p, end:%p, enq:%p, dep:%p\n", 211 &ring->dma, ring->start, ring->end, 212 ring->enqueue, ring->dequeue); 213 spin_unlock_irqrestore(&mtu->lock, flags); 214 215 return 0; 216 } 217 218 static int mtu3_qmu_gpd_show(struct seq_file *sf, void *unused) 219 { 220 struct mtu3_ep *mep = sf->private; 221 struct mtu3 *mtu = mep->mtu; 222 struct mtu3_gpd_ring *ring; 223 struct qmu_gpd *gpd; 224 dma_addr_t dma; 225 unsigned long flags; 226 int i; 227 228 spin_lock_irqsave(&mtu->lock, flags); 229 ring = &mep->gpd_ring; 230 gpd = ring->start; 231 if (!gpd || !(mep->flags & MTU3_EP_ENABLED)) { 232 seq_puts(sf, "empty!\n"); 233 goto out; 234 } 235 236 for (i = 0; i < MAX_GPD_NUM; i++, gpd++) { 237 dma = ring->dma + i * sizeof(*gpd); 238 seq_printf(sf, "gpd.%03d -> %pad, %p: %08x %08x %08x %08x\n", 239 i, &dma, gpd, gpd->dw0_info, gpd->next_gpd, 240 gpd->buffer, gpd->dw3_info); 241 } 242 243 out: 244 spin_unlock_irqrestore(&mtu->lock, flags); 245 246 return 0; 247 } 248 249 static const struct mtu3_file_map mtu3_ep_files[] = { 250 {"ep-info", mtu3_ep_info_show, }, 251 {"fifo", mtu3_fifo_show, }, 252 {"qmu-ring", mtu3_qmu_ring_show, }, 253 {"qmu-gpd", mtu3_qmu_gpd_show, }, 254 }; 255 256 static int mtu3_ep_open(struct inode *inode, struct file *file) 257 { 258 const char *file_name = file_dentry(file)->d_iname; 259 const struct mtu3_file_map *f_map; 260 int i; 261 262 for (i = 0; i < ARRAY_SIZE(mtu3_ep_files); i++) { 263 f_map = &mtu3_ep_files[i]; 264 265 if (strcmp(f_map->name, file_name) == 0) 266 break; 267 } 268 269 return single_open(file, f_map->show, inode->i_private); 270 } 271 272 static const struct file_operations mtu3_ep_fops = { 273 .open = mtu3_ep_open, 274 .read = seq_read, 275 .llseek = seq_lseek, 276 .release = single_release, 277 }; 278 279 static struct debugfs_reg32 mtu3_prb_regs[] = { 280 dump_prb_reg("enable", U3D_SSUSB_PRB_CTRL0), 281 dump_prb_reg("byte-sell", U3D_SSUSB_PRB_CTRL1), 282 dump_prb_reg("byte-selh", U3D_SSUSB_PRB_CTRL2), 283 dump_prb_reg("module-sel", U3D_SSUSB_PRB_CTRL3), 284 dump_prb_reg("sw-out", U3D_SSUSB_PRB_CTRL4), 285 dump_prb_reg("data", U3D_SSUSB_PRB_CTRL5), 286 }; 287 288 static int mtu3_probe_show(struct seq_file *sf, void *unused) 289 { 290 const char *file_name = file_dentry(sf->file)->d_iname; 291 struct mtu3 *mtu = sf->private; 292 const struct debugfs_reg32 *regs; 293 int i; 294 295 for (i = 0; i < ARRAY_SIZE(mtu3_prb_regs); i++) { 296 regs = &mtu3_prb_regs[i]; 297 298 if (strcmp(regs->name, file_name) == 0) 299 break; 300 } 301 302 seq_printf(sf, "0x%04x - 0x%08x\n", (u32)regs->offset, 303 mtu3_readl(mtu->ippc_base, (u32)regs->offset)); 304 305 return 0; 306 } 307 308 static int mtu3_probe_open(struct inode *inode, struct file *file) 309 { 310 return single_open(file, mtu3_probe_show, inode->i_private); 311 } 312 313 static ssize_t mtu3_probe_write(struct file *file, const char __user *ubuf, 314 size_t count, loff_t *ppos) 315 { 316 const char *file_name = file_dentry(file)->d_iname; 317 struct seq_file *sf = file->private_data; 318 struct mtu3 *mtu = sf->private; 319 const struct debugfs_reg32 *regs; 320 char buf[32]; 321 u32 val; 322 int i; 323 324 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 325 return -EFAULT; 326 327 if (kstrtou32(buf, 0, &val)) 328 return -EINVAL; 329 330 for (i = 0; i < ARRAY_SIZE(mtu3_prb_regs); i++) { 331 regs = &mtu3_prb_regs[i]; 332 333 if (strcmp(regs->name, file_name) == 0) 334 break; 335 } 336 mtu3_writel(mtu->ippc_base, (u32)regs->offset, val); 337 338 return count; 339 } 340 341 static const struct file_operations mtu3_probe_fops = { 342 .open = mtu3_probe_open, 343 .write = mtu3_probe_write, 344 .read = seq_read, 345 .llseek = seq_lseek, 346 .release = single_release, 347 }; 348 349 static void mtu3_debugfs_create_prb_files(struct mtu3 *mtu) 350 { 351 struct ssusb_mtk *ssusb = mtu->ssusb; 352 struct debugfs_reg32 *regs; 353 struct dentry *dir_prb; 354 int i; 355 356 dir_prb = debugfs_create_dir("probe", ssusb->dbgfs_root); 357 358 for (i = 0; i < ARRAY_SIZE(mtu3_prb_regs); i++) { 359 regs = &mtu3_prb_regs[i]; 360 debugfs_create_file(regs->name, 0644, dir_prb, 361 mtu, &mtu3_probe_fops); 362 } 363 364 mtu3_debugfs_regset(mtu, mtu->ippc_base, mtu3_prb_regs, 365 ARRAY_SIZE(mtu3_prb_regs), "regs", dir_prb); 366 } 367 368 static void mtu3_debugfs_create_ep_dir(struct mtu3_ep *mep, 369 struct dentry *parent) 370 { 371 const struct mtu3_file_map *files; 372 struct dentry *dir_ep; 373 int i; 374 375 dir_ep = debugfs_create_dir(mep->name, parent); 376 mtu3_debugfs_ep_regset(mep->mtu, mep, dir_ep); 377 378 for (i = 0; i < ARRAY_SIZE(mtu3_ep_files); i++) { 379 files = &mtu3_ep_files[i]; 380 381 debugfs_create_file(files->name, 0444, dir_ep, 382 mep, &mtu3_ep_fops); 383 } 384 } 385 386 static void mtu3_debugfs_create_ep_dirs(struct mtu3 *mtu) 387 { 388 struct ssusb_mtk *ssusb = mtu->ssusb; 389 struct dentry *dir_eps; 390 int i; 391 392 dir_eps = debugfs_create_dir("eps", ssusb->dbgfs_root); 393 394 for (i = 1; i < mtu->num_eps; i++) { 395 mtu3_debugfs_create_ep_dir(mtu->in_eps + i, dir_eps); 396 mtu3_debugfs_create_ep_dir(mtu->out_eps + i, dir_eps); 397 } 398 } 399 400 void ssusb_dev_debugfs_init(struct ssusb_mtk *ssusb) 401 { 402 struct mtu3 *mtu = ssusb->u3d; 403 struct dentry *dir_regs; 404 405 dir_regs = debugfs_create_dir("regs", ssusb->dbgfs_root); 406 407 mtu3_debugfs_regset(mtu, mtu->ippc_base, 408 mtu3_ippc_regs, ARRAY_SIZE(mtu3_ippc_regs), 409 "reg-ippc", dir_regs); 410 411 mtu3_debugfs_regset(mtu, mtu->mac_base, 412 mtu3_dev_regs, ARRAY_SIZE(mtu3_dev_regs), 413 "reg-dev", dir_regs); 414 415 mtu3_debugfs_regset(mtu, mtu->mac_base, 416 mtu3_csr_regs, ARRAY_SIZE(mtu3_csr_regs), 417 "reg-csr", dir_regs); 418 419 mtu3_debugfs_create_ep_dirs(mtu); 420 421 mtu3_debugfs_create_prb_files(mtu); 422 423 debugfs_create_file("link-state", 0444, ssusb->dbgfs_root, 424 mtu, &mtu3_link_state_fops); 425 debugfs_create_file("ep-used", 0444, ssusb->dbgfs_root, 426 mtu, &mtu3_ep_used_fops); 427 } 428 429 static int ssusb_mode_show(struct seq_file *sf, void *unused) 430 { 431 struct ssusb_mtk *ssusb = sf->private; 432 433 seq_printf(sf, "current mode: %s(%s drd)\n(echo device/host)\n", 434 ssusb->is_host ? "host" : "device", 435 ssusb->otg_switch.manual_drd_enabled ? "manual" : "auto"); 436 437 return 0; 438 } 439 440 static int ssusb_mode_open(struct inode *inode, struct file *file) 441 { 442 return single_open(file, ssusb_mode_show, inode->i_private); 443 } 444 445 static ssize_t ssusb_mode_write(struct file *file, const char __user *ubuf, 446 size_t count, loff_t *ppos) 447 { 448 struct seq_file *sf = file->private_data; 449 struct ssusb_mtk *ssusb = sf->private; 450 char buf[16]; 451 452 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 453 return -EFAULT; 454 455 if (!strncmp(buf, "host", 4) && !ssusb->is_host) { 456 ssusb_mode_switch(ssusb, 1); 457 } else if (!strncmp(buf, "device", 6) && ssusb->is_host) { 458 ssusb_mode_switch(ssusb, 0); 459 } else { 460 dev_err(ssusb->dev, "wrong or duplicated setting\n"); 461 return -EINVAL; 462 } 463 464 return count; 465 } 466 467 static const struct file_operations ssusb_mode_fops = { 468 .open = ssusb_mode_open, 469 .write = ssusb_mode_write, 470 .read = seq_read, 471 .llseek = seq_lseek, 472 .release = single_release, 473 }; 474 475 static int ssusb_vbus_show(struct seq_file *sf, void *unused) 476 { 477 struct ssusb_mtk *ssusb = sf->private; 478 struct otg_switch_mtk *otg_sx = &ssusb->otg_switch; 479 480 seq_printf(sf, "vbus state: %s\n(echo on/off)\n", 481 regulator_is_enabled(otg_sx->vbus) ? "on" : "off"); 482 483 return 0; 484 } 485 486 static int ssusb_vbus_open(struct inode *inode, struct file *file) 487 { 488 return single_open(file, ssusb_vbus_show, inode->i_private); 489 } 490 491 static ssize_t ssusb_vbus_write(struct file *file, const char __user *ubuf, 492 size_t count, loff_t *ppos) 493 { 494 struct seq_file *sf = file->private_data; 495 struct ssusb_mtk *ssusb = sf->private; 496 struct otg_switch_mtk *otg_sx = &ssusb->otg_switch; 497 char buf[16]; 498 bool enable; 499 500 if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count))) 501 return -EFAULT; 502 503 if (kstrtobool(buf, &enable)) { 504 dev_err(ssusb->dev, "wrong setting\n"); 505 return -EINVAL; 506 } 507 508 ssusb_set_vbus(otg_sx, enable); 509 510 return count; 511 } 512 513 static const struct file_operations ssusb_vbus_fops = { 514 .open = ssusb_vbus_open, 515 .write = ssusb_vbus_write, 516 .read = seq_read, 517 .llseek = seq_lseek, 518 .release = single_release, 519 }; 520 521 void ssusb_dr_debugfs_init(struct ssusb_mtk *ssusb) 522 { 523 struct dentry *root = ssusb->dbgfs_root; 524 525 debugfs_create_file("mode", 0644, root, ssusb, &ssusb_mode_fops); 526 debugfs_create_file("vbus", 0644, root, ssusb, &ssusb_vbus_fops); 527 } 528 529 void ssusb_debugfs_create_root(struct ssusb_mtk *ssusb) 530 { 531 ssusb->dbgfs_root = 532 debugfs_create_dir(dev_name(ssusb->dev), usb_debug_root); 533 } 534 535 void ssusb_debugfs_remove_root(struct ssusb_mtk *ssusb) 536 { 537 debugfs_remove_recursive(ssusb->dbgfs_root); 538 ssusb->dbgfs_root = NULL; 539 } 540