Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * mtu3_debugfs.c - debugfs interface
0004  *
0005  * Copyright (C) 2019 MediaTek Inc.
0006  *
0007  * Author: Chunfeng Yun <chunfeng.yun@mediatek.com>
0008  */
0009 
0010 #include <linux/uaccess.h>
0011 
0012 #include "mtu3.h"
0013 #include "mtu3_dr.h"
0014 #include "mtu3_debug.h"
0015 
0016 #define dump_register(nm)       \
0017 {                   \
0018     .name = __stringify(nm),    \
0019     .offset = U3D_ ##nm,        \
0020 }
0021 
0022 #define dump_prb_reg(nm, os)    \
0023 {               \
0024     .name = nm,     \
0025     .offset = os,       \
0026 }
0027 
0028 static const struct debugfs_reg32 mtu3_ippc_regs[] = {
0029     dump_register(SSUSB_IP_PW_CTRL0),
0030     dump_register(SSUSB_IP_PW_CTRL1),
0031     dump_register(SSUSB_IP_PW_CTRL2),
0032     dump_register(SSUSB_IP_PW_CTRL3),
0033     dump_register(SSUSB_IP_PW_STS1),
0034     dump_register(SSUSB_OTG_STS),
0035     dump_register(SSUSB_IP_XHCI_CAP),
0036     dump_register(SSUSB_IP_DEV_CAP),
0037     dump_register(SSUSB_U3_CTRL_0P),
0038     dump_register(SSUSB_U2_CTRL_0P),
0039     dump_register(SSUSB_HW_ID),
0040     dump_register(SSUSB_HW_SUB_ID),
0041     dump_register(SSUSB_IP_SPARE0),
0042 };
0043 
0044 static const struct debugfs_reg32 mtu3_dev_regs[] = {
0045     dump_register(LV1ISR),
0046     dump_register(LV1IER),
0047     dump_register(EPISR),
0048     dump_register(EPIER),
0049     dump_register(EP0CSR),
0050     dump_register(RXCOUNT0),
0051     dump_register(QISAR0),
0052     dump_register(QIER0),
0053     dump_register(QISAR1),
0054     dump_register(QIER1),
0055     dump_register(CAP_EPNTXFFSZ),
0056     dump_register(CAP_EPNRXFFSZ),
0057     dump_register(CAP_EPINFO),
0058     dump_register(MISC_CTRL),
0059 };
0060 
0061 static const struct debugfs_reg32 mtu3_csr_regs[] = {
0062     dump_register(DEVICE_CONF),
0063     dump_register(DEV_LINK_INTR_ENABLE),
0064     dump_register(DEV_LINK_INTR),
0065     dump_register(LTSSM_CTRL),
0066     dump_register(USB3_CONFIG),
0067     dump_register(LINK_STATE_MACHINE),
0068     dump_register(LTSSM_INTR_ENABLE),
0069     dump_register(LTSSM_INTR),
0070     dump_register(U3U2_SWITCH_CTRL),
0071     dump_register(POWER_MANAGEMENT),
0072     dump_register(DEVICE_CONTROL),
0073     dump_register(COMMON_USB_INTR_ENABLE),
0074     dump_register(COMMON_USB_INTR),
0075     dump_register(USB20_MISC_CONTROL),
0076     dump_register(USB20_OPSTATE),
0077 };
0078 
0079 static int mtu3_link_state_show(struct seq_file *sf, void *unused)
0080 {
0081     struct mtu3 *mtu = sf->private;
0082     void __iomem *mbase = mtu->mac_base;
0083 
0084     seq_printf(sf, "opstate: %#x, ltssm: %#x\n",
0085            mtu3_readl(mbase, U3D_USB20_OPSTATE),
0086            LTSSM_STATE(mtu3_readl(mbase, U3D_LINK_STATE_MACHINE)));
0087 
0088     return 0;
0089 }
0090 
0091 static int mtu3_ep_used_show(struct seq_file *sf, void *unused)
0092 {
0093     struct mtu3 *mtu = sf->private;
0094     struct mtu3_ep *mep;
0095     unsigned long flags;
0096     int used = 0;
0097     int i;
0098 
0099     spin_lock_irqsave(&mtu->lock, flags);
0100 
0101     for (i = 0; i < mtu->num_eps; i++) {
0102         mep = mtu->in_eps + i;
0103         if (mep->flags & MTU3_EP_ENABLED) {
0104             seq_printf(sf, "%s - type: %s\n", mep->name, usb_ep_type_string(mep->type));
0105             used++;
0106         }
0107 
0108         mep = mtu->out_eps + i;
0109         if (mep->flags & MTU3_EP_ENABLED) {
0110             seq_printf(sf, "%s - type: %s\n", mep->name, usb_ep_type_string(mep->type));
0111             used++;
0112         }
0113     }
0114     seq_printf(sf, "total used: %d eps\n", used);
0115 
0116     spin_unlock_irqrestore(&mtu->lock, flags);
0117 
0118     return 0;
0119 }
0120 
0121 DEFINE_SHOW_ATTRIBUTE(mtu3_link_state);
0122 DEFINE_SHOW_ATTRIBUTE(mtu3_ep_used);
0123 
0124 static void mtu3_debugfs_regset(struct mtu3 *mtu, void __iomem *base,
0125                 const struct debugfs_reg32 *regs, size_t nregs,
0126                 const char *name, struct dentry *parent)
0127 {
0128     struct debugfs_regset32 *regset;
0129     struct mtu3_regset *mregs;
0130 
0131     mregs = devm_kzalloc(mtu->dev, sizeof(*mregs), GFP_KERNEL);
0132     if (!mregs)
0133         return;
0134 
0135     sprintf(mregs->name, "%s", name);
0136     regset = &mregs->regset;
0137     regset->regs = regs;
0138     regset->nregs = nregs;
0139     regset->base = base;
0140 
0141     debugfs_create_regset32(mregs->name, 0444, parent, regset);
0142 }
0143 
0144 static void mtu3_debugfs_ep_regset(struct mtu3 *mtu, struct mtu3_ep *mep,
0145                    struct dentry *parent)
0146 {
0147     struct debugfs_reg32 *regs;
0148     int epnum = mep->epnum;
0149     int in = mep->is_in;
0150 
0151     regs = devm_kcalloc(mtu->dev, 7, sizeof(*regs), GFP_KERNEL);
0152     if (!regs)
0153         return;
0154 
0155     regs[0].name = in ? "TCR0" : "RCR0";
0156     regs[0].offset = in ? MU3D_EP_TXCR0(epnum) : MU3D_EP_RXCR0(epnum);
0157     regs[1].name = in ? "TCR1" : "RCR1";
0158     regs[1].offset = in ? MU3D_EP_TXCR1(epnum) : MU3D_EP_RXCR1(epnum);
0159     regs[2].name = in ? "TCR2" : "RCR2";
0160     regs[2].offset = in ? MU3D_EP_TXCR2(epnum) : MU3D_EP_RXCR2(epnum);
0161     regs[3].name = in ? "TQHIAR" : "RQHIAR";
0162     regs[3].offset = in ? USB_QMU_TQHIAR(epnum) : USB_QMU_RQHIAR(epnum);
0163     regs[4].name = in ? "TQCSR" : "RQCSR";
0164     regs[4].offset = in ? USB_QMU_TQCSR(epnum) : USB_QMU_RQCSR(epnum);
0165     regs[5].name = in ? "TQSAR" : "RQSAR";
0166     regs[5].offset = in ? USB_QMU_TQSAR(epnum) : USB_QMU_RQSAR(epnum);
0167     regs[6].name = in ? "TQCPR" : "RQCPR";
0168     regs[6].offset = in ? USB_QMU_TQCPR(epnum) : USB_QMU_RQCPR(epnum);
0169 
0170     mtu3_debugfs_regset(mtu, mtu->mac_base, regs, 7, "ep-regs", parent);
0171 }
0172 
0173 static int mtu3_ep_info_show(struct seq_file *sf, void *unused)
0174 {
0175     struct mtu3_ep *mep = sf->private;
0176     struct mtu3 *mtu = mep->mtu;
0177     unsigned long flags;
0178 
0179     spin_lock_irqsave(&mtu->lock, flags);
0180     seq_printf(sf, "ep - type:%s, maxp:%d, slot:%d, flags:%x\n",
0181            usb_ep_type_string(mep->type), mep->maxp, mep->slot, mep->flags);
0182     spin_unlock_irqrestore(&mtu->lock, flags);
0183 
0184     return 0;
0185 }
0186 
0187 static int mtu3_fifo_show(struct seq_file *sf, void *unused)
0188 {
0189     struct mtu3_ep *mep = sf->private;
0190     struct mtu3 *mtu = mep->mtu;
0191     unsigned long flags;
0192 
0193     spin_lock_irqsave(&mtu->lock, flags);
0194     seq_printf(sf, "fifo - seg_size:%d, addr:%d, size:%d\n",
0195            mep->fifo_seg_size, mep->fifo_addr, mep->fifo_size);
0196     spin_unlock_irqrestore(&mtu->lock, flags);
0197 
0198     return 0;
0199 }
0200 
0201 static int mtu3_qmu_ring_show(struct seq_file *sf, void *unused)
0202 {
0203     struct mtu3_ep *mep = sf->private;
0204     struct mtu3 *mtu = mep->mtu;
0205     struct mtu3_gpd_ring *ring;
0206     unsigned long flags;
0207 
0208     ring = &mep->gpd_ring;
0209     spin_lock_irqsave(&mtu->lock, flags);
0210     seq_printf(sf,
0211            "qmu-ring - dma:%pad, start:%p, end:%p, enq:%p, dep:%p\n",
0212            &ring->dma, ring->start, ring->end,
0213            ring->enqueue, ring->dequeue);
0214     spin_unlock_irqrestore(&mtu->lock, flags);
0215 
0216     return 0;
0217 }
0218 
0219 static int mtu3_qmu_gpd_show(struct seq_file *sf, void *unused)
0220 {
0221     struct mtu3_ep *mep = sf->private;
0222     struct mtu3 *mtu = mep->mtu;
0223     struct mtu3_gpd_ring *ring;
0224     struct qmu_gpd *gpd;
0225     dma_addr_t dma;
0226     unsigned long flags;
0227     int i;
0228 
0229     spin_lock_irqsave(&mtu->lock, flags);
0230     ring = &mep->gpd_ring;
0231     gpd = ring->start;
0232     if (!gpd || !(mep->flags & MTU3_EP_ENABLED)) {
0233         seq_puts(sf, "empty!\n");
0234         goto out;
0235     }
0236 
0237     for (i = 0; i < MAX_GPD_NUM; i++, gpd++) {
0238         dma = ring->dma + i * sizeof(*gpd);
0239         seq_printf(sf, "gpd.%03d -> %pad, %p: %08x %08x %08x %08x\n",
0240                i, &dma, gpd, gpd->dw0_info, gpd->next_gpd,
0241                gpd->buffer, gpd->dw3_info);
0242     }
0243 
0244 out:
0245     spin_unlock_irqrestore(&mtu->lock, flags);
0246 
0247     return 0;
0248 }
0249 
0250 static const struct mtu3_file_map mtu3_ep_files[] = {
0251     {"ep-info", mtu3_ep_info_show, },
0252     {"fifo", mtu3_fifo_show, },
0253     {"qmu-ring", mtu3_qmu_ring_show, },
0254     {"qmu-gpd", mtu3_qmu_gpd_show, },
0255 };
0256 
0257 static int mtu3_ep_open(struct inode *inode, struct file *file)
0258 {
0259     const char *file_name = file_dentry(file)->d_iname;
0260     const struct mtu3_file_map *f_map;
0261     int i;
0262 
0263     for (i = 0; i < ARRAY_SIZE(mtu3_ep_files); i++) {
0264         f_map = &mtu3_ep_files[i];
0265 
0266         if (strcmp(f_map->name, file_name) == 0)
0267             break;
0268     }
0269 
0270     return single_open(file, f_map->show, inode->i_private);
0271 }
0272 
0273 static const struct file_operations mtu3_ep_fops = {
0274     .open = mtu3_ep_open,
0275     .read = seq_read,
0276     .llseek = seq_lseek,
0277     .release = single_release,
0278 };
0279 
0280 static const struct debugfs_reg32 mtu3_prb_regs[] = {
0281     dump_prb_reg("enable", U3D_SSUSB_PRB_CTRL0),
0282     dump_prb_reg("byte-sell", U3D_SSUSB_PRB_CTRL1),
0283     dump_prb_reg("byte-selh", U3D_SSUSB_PRB_CTRL2),
0284     dump_prb_reg("module-sel", U3D_SSUSB_PRB_CTRL3),
0285     dump_prb_reg("sw-out", U3D_SSUSB_PRB_CTRL4),
0286     dump_prb_reg("data", U3D_SSUSB_PRB_CTRL5),
0287 };
0288 
0289 static int mtu3_probe_show(struct seq_file *sf, void *unused)
0290 {
0291     const char *file_name = file_dentry(sf->file)->d_iname;
0292     struct mtu3 *mtu = sf->private;
0293     const struct debugfs_reg32 *regs;
0294     int i;
0295 
0296     for (i = 0; i < ARRAY_SIZE(mtu3_prb_regs); i++) {
0297         regs = &mtu3_prb_regs[i];
0298 
0299         if (strcmp(regs->name, file_name) == 0)
0300             break;
0301     }
0302 
0303     seq_printf(sf, "0x%04x - 0x%08x\n", (u32)regs->offset,
0304            mtu3_readl(mtu->ippc_base, (u32)regs->offset));
0305 
0306     return 0;
0307 }
0308 
0309 static int mtu3_probe_open(struct inode *inode, struct file *file)
0310 {
0311     return single_open(file, mtu3_probe_show, inode->i_private);
0312 }
0313 
0314 static ssize_t mtu3_probe_write(struct file *file, const char __user *ubuf,
0315                 size_t count, loff_t *ppos)
0316 {
0317     const char *file_name = file_dentry(file)->d_iname;
0318     struct seq_file *sf = file->private_data;
0319     struct mtu3 *mtu = sf->private;
0320     const struct debugfs_reg32 *regs;
0321     char buf[32];
0322     u32 val;
0323     int i;
0324 
0325     if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
0326         return -EFAULT;
0327 
0328     if (kstrtou32(buf, 0, &val))
0329         return -EINVAL;
0330 
0331     for (i = 0; i < ARRAY_SIZE(mtu3_prb_regs); i++) {
0332         regs = &mtu3_prb_regs[i];
0333 
0334         if (strcmp(regs->name, file_name) == 0)
0335             break;
0336     }
0337     mtu3_writel(mtu->ippc_base, (u32)regs->offset, val);
0338 
0339     return count;
0340 }
0341 
0342 static const struct file_operations mtu3_probe_fops = {
0343     .open = mtu3_probe_open,
0344     .write = mtu3_probe_write,
0345     .read = seq_read,
0346     .llseek = seq_lseek,
0347     .release = single_release,
0348 };
0349 
0350 static void mtu3_debugfs_create_prb_files(struct mtu3 *mtu)
0351 {
0352     struct ssusb_mtk *ssusb = mtu->ssusb;
0353     const struct debugfs_reg32 *regs;
0354     struct dentry *dir_prb;
0355     int i;
0356 
0357     dir_prb = debugfs_create_dir("probe", ssusb->dbgfs_root);
0358 
0359     for (i = 0; i < ARRAY_SIZE(mtu3_prb_regs); i++) {
0360         regs = &mtu3_prb_regs[i];
0361         debugfs_create_file(regs->name, 0644, dir_prb,
0362                     mtu, &mtu3_probe_fops);
0363     }
0364 
0365     mtu3_debugfs_regset(mtu, mtu->ippc_base, mtu3_prb_regs,
0366                 ARRAY_SIZE(mtu3_prb_regs), "regs", dir_prb);
0367 }
0368 
0369 static void mtu3_debugfs_create_ep_dir(struct mtu3_ep *mep,
0370                        struct dentry *parent)
0371 {
0372     const struct mtu3_file_map *files;
0373     struct dentry *dir_ep;
0374     int i;
0375 
0376     dir_ep = debugfs_create_dir(mep->name, parent);
0377     mtu3_debugfs_ep_regset(mep->mtu, mep, dir_ep);
0378 
0379     for (i = 0; i < ARRAY_SIZE(mtu3_ep_files); i++) {
0380         files = &mtu3_ep_files[i];
0381 
0382         debugfs_create_file(files->name, 0444, dir_ep,
0383                     mep, &mtu3_ep_fops);
0384     }
0385 }
0386 
0387 static void mtu3_debugfs_create_ep_dirs(struct mtu3 *mtu)
0388 {
0389     struct ssusb_mtk *ssusb = mtu->ssusb;
0390     struct dentry *dir_eps;
0391     int i;
0392 
0393     dir_eps = debugfs_create_dir("eps", ssusb->dbgfs_root);
0394 
0395     for (i = 1; i < mtu->num_eps; i++) {
0396         mtu3_debugfs_create_ep_dir(mtu->in_eps + i, dir_eps);
0397         mtu3_debugfs_create_ep_dir(mtu->out_eps + i, dir_eps);
0398     }
0399 }
0400 
0401 void ssusb_dev_debugfs_init(struct ssusb_mtk *ssusb)
0402 {
0403     struct mtu3 *mtu = ssusb->u3d;
0404     struct dentry *dir_regs;
0405 
0406     dir_regs = debugfs_create_dir("regs", ssusb->dbgfs_root);
0407 
0408     mtu3_debugfs_regset(mtu, mtu->ippc_base,
0409                 mtu3_ippc_regs, ARRAY_SIZE(mtu3_ippc_regs),
0410                 "reg-ippc", dir_regs);
0411 
0412     mtu3_debugfs_regset(mtu, mtu->mac_base,
0413                 mtu3_dev_regs, ARRAY_SIZE(mtu3_dev_regs),
0414                 "reg-dev", dir_regs);
0415 
0416     mtu3_debugfs_regset(mtu, mtu->mac_base,
0417                 mtu3_csr_regs, ARRAY_SIZE(mtu3_csr_regs),
0418                 "reg-csr", dir_regs);
0419 
0420     mtu3_debugfs_create_ep_dirs(mtu);
0421 
0422     mtu3_debugfs_create_prb_files(mtu);
0423 
0424     debugfs_create_file("link-state", 0444, ssusb->dbgfs_root,
0425                 mtu, &mtu3_link_state_fops);
0426     debugfs_create_file("ep-used", 0444, ssusb->dbgfs_root,
0427                 mtu, &mtu3_ep_used_fops);
0428 }
0429 
0430 static int ssusb_mode_show(struct seq_file *sf, void *unused)
0431 {
0432     struct ssusb_mtk *ssusb = sf->private;
0433 
0434     seq_printf(sf, "current mode: %s(%s drd)\n(echo device/host)\n",
0435            ssusb->is_host ? "host" : "device",
0436            ssusb->otg_switch.manual_drd_enabled ? "manual" : "auto");
0437 
0438     return 0;
0439 }
0440 
0441 static int ssusb_mode_open(struct inode *inode, struct file *file)
0442 {
0443     return single_open(file, ssusb_mode_show, inode->i_private);
0444 }
0445 
0446 static ssize_t ssusb_mode_write(struct file *file, const char __user *ubuf,
0447                 size_t count, loff_t *ppos)
0448 {
0449     struct seq_file *sf = file->private_data;
0450     struct ssusb_mtk *ssusb = sf->private;
0451     char buf[16];
0452 
0453     if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
0454         return -EFAULT;
0455 
0456     if (!strncmp(buf, "host", 4) && !ssusb->is_host) {
0457         ssusb_mode_switch(ssusb, 1);
0458     } else if (!strncmp(buf, "device", 6) && ssusb->is_host) {
0459         ssusb_mode_switch(ssusb, 0);
0460     } else {
0461         dev_err(ssusb->dev, "wrong or duplicated setting\n");
0462         return -EINVAL;
0463     }
0464 
0465     return count;
0466 }
0467 
0468 static const struct file_operations ssusb_mode_fops = {
0469     .open = ssusb_mode_open,
0470     .write = ssusb_mode_write,
0471     .read = seq_read,
0472     .llseek = seq_lseek,
0473     .release = single_release,
0474 };
0475 
0476 static int ssusb_vbus_show(struct seq_file *sf, void *unused)
0477 {
0478     struct ssusb_mtk *ssusb = sf->private;
0479     struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
0480 
0481     seq_printf(sf, "vbus state: %s\n(echo on/off)\n",
0482            regulator_is_enabled(otg_sx->vbus) ? "on" : "off");
0483 
0484     return 0;
0485 }
0486 
0487 static int ssusb_vbus_open(struct inode *inode, struct file *file)
0488 {
0489     return single_open(file, ssusb_vbus_show, inode->i_private);
0490 }
0491 
0492 static ssize_t ssusb_vbus_write(struct file *file, const char __user *ubuf,
0493                 size_t count, loff_t *ppos)
0494 {
0495     struct seq_file *sf = file->private_data;
0496     struct ssusb_mtk *ssusb = sf->private;
0497     struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
0498     char buf[16];
0499     bool enable;
0500 
0501     if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
0502         return -EFAULT;
0503 
0504     if (kstrtobool(buf, &enable)) {
0505         dev_err(ssusb->dev, "wrong setting\n");
0506         return -EINVAL;
0507     }
0508 
0509     ssusb_set_vbus(otg_sx, enable);
0510 
0511     return count;
0512 }
0513 
0514 static const struct file_operations ssusb_vbus_fops = {
0515     .open = ssusb_vbus_open,
0516     .write = ssusb_vbus_write,
0517     .read = seq_read,
0518     .llseek = seq_lseek,
0519     .release = single_release,
0520 };
0521 
0522 void ssusb_dr_debugfs_init(struct ssusb_mtk *ssusb)
0523 {
0524     struct dentry *root = ssusb->dbgfs_root;
0525 
0526     debugfs_create_file("mode", 0644, root, ssusb, &ssusb_mode_fops);
0527     debugfs_create_file("vbus", 0644, root, ssusb, &ssusb_vbus_fops);
0528 }
0529 
0530 void ssusb_debugfs_create_root(struct ssusb_mtk *ssusb)
0531 {
0532     ssusb->dbgfs_root =
0533         debugfs_create_dir(dev_name(ssusb->dev), usb_debug_root);
0534 }
0535 
0536 void ssusb_debugfs_remove_root(struct ssusb_mtk *ssusb)
0537 {
0538     debugfs_remove_recursive(ssusb->dbgfs_root);
0539     ssusb->dbgfs_root = NULL;
0540 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!