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(m: sf, fmt: "opstate: %#x, ltssm: %#x\n" , |
85 | mtu3_readl(base: 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(m: sf, fmt: "%s - type: %s\n" , mep->name, usb_ep_type_string(ep_type: mep->type)); |
105 | used++; |
106 | } |
107 | |
108 | mep = mtu->out_eps + i; |
109 | if (mep->flags & MTU3_EP_ENABLED) { |
110 | seq_printf(m: sf, fmt: "%s - type: %s\n" , mep->name, usb_ep_type_string(ep_type: mep->type)); |
111 | used++; |
112 | } |
113 | } |
114 | seq_printf(m: sf, fmt: "total used: %d eps\n" , used); |
115 | |
116 | spin_unlock_irqrestore(lock: &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(dev: mtu->dev, size: sizeof(*mregs), GFP_KERNEL); |
132 | if (!mregs) |
133 | return; |
134 | |
135 | sprintf(buf: mregs->name, fmt: "%s" , name); |
136 | regset = &mregs->regset; |
137 | regset->regs = regs; |
138 | regset->nregs = nregs; |
139 | regset->base = base; |
140 | |
141 | debugfs_create_regset32(name: mregs->name, mode: 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(dev: mtu->dev, n: 7, size: 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, base: mtu->mac_base, regs, nregs: 7, name: "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(m: sf, fmt: "ep - type:%s, maxp:%d, slot:%d, flags:%x\n" , |
181 | usb_ep_type_string(ep_type: mep->type), mep->maxp, mep->slot, mep->flags); |
182 | spin_unlock_irqrestore(lock: &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(m: sf, fmt: "fifo - seg_size:%d, addr:%d, size:%d\n" , |
195 | mep->fifo_seg_size, mep->fifo_addr, mep->fifo_size); |
196 | spin_unlock_irqrestore(lock: &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(m: sf, |
211 | fmt: "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(lock: &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(m: sf, s: "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(m: sf, fmt: "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(lock: &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(file: 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(m: sf, fmt: "0x%04x - 0x%08x\n" , (u32)regs->offset, |
304 | mtu3_readl(base: mtu->ippc_base, offset: (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(to: &buf, from: ubuf, min_t(size_t, sizeof(buf) - 1, count))) |
326 | return -EFAULT; |
327 | |
328 | if (kstrtou32(s: buf, base: 0, res: &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(base: mtu->ippc_base, offset: (u32)regs->offset, data: 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(name: "probe" , parent: 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(name: regs->name, mode: 0644, parent: dir_prb, |
362 | data: mtu, fops: &mtu3_probe_fops); |
363 | } |
364 | |
365 | mtu3_debugfs_regset(mtu, base: mtu->ippc_base, regs: mtu3_prb_regs, |
366 | ARRAY_SIZE(mtu3_prb_regs), name: "regs" , parent: 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(name: mep->name, parent); |
377 | mtu3_debugfs_ep_regset(mtu: mep->mtu, mep, parent: 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(name: files->name, mode: 0444, parent: dir_ep, |
383 | data: mep, fops: &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(name: "eps" , parent: ssusb->dbgfs_root); |
394 | |
395 | for (i = 1; i < mtu->num_eps; i++) { |
396 | mtu3_debugfs_create_ep_dir(mep: mtu->in_eps + i, parent: dir_eps); |
397 | mtu3_debugfs_create_ep_dir(mep: mtu->out_eps + i, parent: 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(name: "regs" , parent: ssusb->dbgfs_root); |
407 | |
408 | mtu3_debugfs_regset(mtu, base: mtu->ippc_base, |
409 | regs: mtu3_ippc_regs, ARRAY_SIZE(mtu3_ippc_regs), |
410 | name: "reg-ippc" , parent: dir_regs); |
411 | |
412 | mtu3_debugfs_regset(mtu, base: mtu->mac_base, |
413 | regs: mtu3_dev_regs, ARRAY_SIZE(mtu3_dev_regs), |
414 | name: "reg-dev" , parent: dir_regs); |
415 | |
416 | mtu3_debugfs_regset(mtu, base: mtu->mac_base, |
417 | regs: mtu3_csr_regs, ARRAY_SIZE(mtu3_csr_regs), |
418 | name: "reg-csr" , parent: dir_regs); |
419 | |
420 | mtu3_debugfs_create_ep_dirs(mtu); |
421 | |
422 | mtu3_debugfs_create_prb_files(mtu); |
423 | |
424 | debugfs_create_file(name: "link-state" , mode: 0444, parent: ssusb->dbgfs_root, |
425 | data: mtu, fops: &mtu3_link_state_fops); |
426 | debugfs_create_file(name: "ep-used" , mode: 0444, parent: ssusb->dbgfs_root, |
427 | data: mtu, fops: &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(m: sf, fmt: "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(to: &buf, from: 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, to_host: 1); |
458 | } else if (!strncmp(buf, "device" , 6) && ssusb->is_host) { |
459 | ssusb_mode_switch(ssusb, to_host: 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(m: sf, fmt: "vbus state: %s\n(echo on/off)\n" , |
482 | regulator_is_enabled(regulator: 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(to: &buf, from: ubuf, min_t(size_t, sizeof(buf) - 1, count))) |
502 | return -EFAULT; |
503 | |
504 | if (kstrtobool(s: buf, res: &enable)) { |
505 | dev_err(ssusb->dev, "wrong setting\n" ); |
506 | return -EINVAL; |
507 | } |
508 | |
509 | ssusb_set_vbus(otg_sx, is_on: 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(name: "mode" , mode: 0644, parent: root, data: ssusb, fops: &ssusb_mode_fops); |
527 | debugfs_create_file(name: "vbus" , mode: 0644, parent: root, data: ssusb, fops: &ssusb_vbus_fops); |
528 | } |
529 | |
530 | void ssusb_debugfs_create_root(struct ssusb_mtk *ssusb) |
531 | { |
532 | ssusb->dbgfs_root = |
533 | debugfs_create_dir(name: dev_name(dev: ssusb->dev), parent: usb_debug_root); |
534 | } |
535 | |
536 | void ssusb_debugfs_remove_root(struct ssusb_mtk *ssusb) |
537 | { |
538 | debugfs_remove_recursive(dentry: ssusb->dbgfs_root); |
539 | ssusb->dbgfs_root = NULL; |
540 | } |
541 | |