drivers/usb/mtu3/mtu3_debugfs.c

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