xref: /openbmc/linux/drivers/usb/mtu3/mtu3_debugfs.c (revision d56b699d) 
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 }
541