1 #include <linux/kernel.h>
2 #include <linux/device.h>
3 #include <linux/types.h>
4 #include <linux/spinlock.h>
5 #include <linux/debugfs.h>
6 #include <linux/seq_file.h>
7 #include <linux/uaccess.h>
8 #include <linux/usb/ch9.h>
9 #include <linux/usb/gadget.h>
10 #include <linux/usb/phy.h>
11 #include <linux/usb/otg.h>
12 #include <linux/usb/otg-fsm.h>
13 #include <linux/usb/chipidea.h>
22 * ci_device_show: prints information about device capabilities and status
24 static int ci_device_show(struct seq_file *s, void *data)
26 struct ci_hdrc *ci = s->private;
27 struct usb_gadget *gadget = &ci->gadget;
29 seq_printf(s, "speed = %d\n", gadget->speed);
30 seq_printf(s, "max_speed = %d\n", gadget->max_speed);
31 seq_printf(s, "is_otg = %d\n", gadget->is_otg);
32 seq_printf(s, "is_a_peripheral = %d\n", gadget->is_a_peripheral);
33 seq_printf(s, "b_hnp_enable = %d\n", gadget->b_hnp_enable);
34 seq_printf(s, "a_hnp_support = %d\n", gadget->a_hnp_support);
35 seq_printf(s, "a_alt_hnp_support = %d\n", gadget->a_alt_hnp_support);
36 seq_printf(s, "name = %s\n",
37 (gadget->name ? gadget->name : ""));
42 seq_printf(s, "gadget function = %s\n",
43 (ci->driver->function ? ci->driver->function : ""));
44 seq_printf(s, "gadget max speed = %d\n", ci->driver->max_speed);
49 static int ci_device_open(struct inode *inode, struct file *file)
51 return single_open(file, ci_device_show, inode->i_private);
54 static const struct file_operations ci_device_fops = {
55 .open = ci_device_open,
58 .release = single_release,
62 * ci_port_test_show: reads port test mode
64 static int ci_port_test_show(struct seq_file *s, void *data)
66 struct ci_hdrc *ci = s->private;
70 pm_runtime_get_sync(ci->dev);
71 spin_lock_irqsave(&ci->lock, flags);
72 mode = hw_port_test_get(ci);
73 spin_unlock_irqrestore(&ci->lock, flags);
74 pm_runtime_put_sync(ci->dev);
76 seq_printf(s, "mode = %u\n", mode);
82 * ci_port_test_write: writes port test mode
84 static ssize_t ci_port_test_write(struct file *file, const char __user *ubuf,
85 size_t count, loff_t *ppos)
87 struct seq_file *s = file->private_data;
88 struct ci_hdrc *ci = s->private;
94 count = min_t(size_t, sizeof(buf) - 1, count);
95 if (copy_from_user(buf, ubuf, count))
98 /* sscanf requires a zero terminated string */
101 if (sscanf(buf, "%u", &mode) != 1)
104 pm_runtime_get_sync(ci->dev);
105 spin_lock_irqsave(&ci->lock, flags);
106 ret = hw_port_test_set(ci, mode);
107 spin_unlock_irqrestore(&ci->lock, flags);
108 pm_runtime_put_sync(ci->dev);
110 return ret ? ret : count;
113 static int ci_port_test_open(struct inode *inode, struct file *file)
115 return single_open(file, ci_port_test_show, inode->i_private);
118 static const struct file_operations ci_port_test_fops = {
119 .open = ci_port_test_open,
120 .write = ci_port_test_write,
123 .release = single_release,
127 * ci_qheads_show: DMA contents of all queue heads
129 static int ci_qheads_show(struct seq_file *s, void *data)
131 struct ci_hdrc *ci = s->private;
135 if (ci->role != CI_ROLE_GADGET) {
136 seq_printf(s, "not in gadget mode\n");
140 spin_lock_irqsave(&ci->lock, flags);
141 for (i = 0; i < ci->hw_ep_max/2; i++) {
142 struct ci_hw_ep *hweprx = &ci->ci_hw_ep[i];
143 struct ci_hw_ep *hweptx =
144 &ci->ci_hw_ep[i + ci->hw_ep_max/2];
145 seq_printf(s, "EP=%02i: RX=%08X TX=%08X\n",
146 i, (u32)hweprx->qh.dma, (u32)hweptx->qh.dma);
147 for (j = 0; j < (sizeof(struct ci_hw_qh)/sizeof(u32)); j++)
148 seq_printf(s, " %04X: %08X %08X\n", j,
149 *((u32 *)hweprx->qh.ptr + j),
150 *((u32 *)hweptx->qh.ptr + j));
152 spin_unlock_irqrestore(&ci->lock, flags);
157 static int ci_qheads_open(struct inode *inode, struct file *file)
159 return single_open(file, ci_qheads_show, inode->i_private);
162 static const struct file_operations ci_qheads_fops = {
163 .open = ci_qheads_open,
166 .release = single_release,
170 * ci_requests_show: DMA contents of all requests currently queued (all endpts)
172 static int ci_requests_show(struct seq_file *s, void *data)
174 struct ci_hdrc *ci = s->private;
176 struct list_head *ptr = NULL;
177 struct ci_hw_req *req = NULL;
178 struct td_node *node, *tmpnode;
179 unsigned i, j, qsize = sizeof(struct ci_hw_td)/sizeof(u32);
181 if (ci->role != CI_ROLE_GADGET) {
182 seq_printf(s, "not in gadget mode\n");
186 spin_lock_irqsave(&ci->lock, flags);
187 for (i = 0; i < ci->hw_ep_max; i++)
188 list_for_each(ptr, &ci->ci_hw_ep[i].qh.queue) {
189 req = list_entry(ptr, struct ci_hw_req, queue);
191 list_for_each_entry_safe(node, tmpnode, &req->tds, td) {
192 seq_printf(s, "EP=%02i: TD=%08X %s\n",
193 i % (ci->hw_ep_max / 2),
195 ((i < ci->hw_ep_max/2) ?
198 for (j = 0; j < qsize; j++)
199 seq_printf(s, " %04X: %08X\n", j,
200 *((u32 *)node->ptr + j));
203 spin_unlock_irqrestore(&ci->lock, flags);
208 static int ci_requests_open(struct inode *inode, struct file *file)
210 return single_open(file, ci_requests_show, inode->i_private);
213 static const struct file_operations ci_requests_fops = {
214 .open = ci_requests_open,
217 .release = single_release,
220 static int ci_otg_show(struct seq_file *s, void *unused)
222 struct ci_hdrc *ci = s->private;
225 if (!ci || !ci_otg_is_fsm_mode(ci))
230 /* ------ State ----- */
231 seq_printf(s, "OTG state: %s\n\n",
232 usb_otg_state_string(ci->otg.state));
234 /* ------ State Machine Variables ----- */
235 seq_printf(s, "a_bus_drop: %d\n", fsm->a_bus_drop);
237 seq_printf(s, "a_bus_req: %d\n", fsm->a_bus_req);
239 seq_printf(s, "a_srp_det: %d\n", fsm->a_srp_det);
241 seq_printf(s, "a_vbus_vld: %d\n", fsm->a_vbus_vld);
243 seq_printf(s, "b_conn: %d\n", fsm->b_conn);
245 seq_printf(s, "adp_change: %d\n", fsm->adp_change);
247 seq_printf(s, "power_up: %d\n", fsm->power_up);
249 seq_printf(s, "a_bus_resume: %d\n", fsm->a_bus_resume);
251 seq_printf(s, "a_bus_suspend: %d\n", fsm->a_bus_suspend);
253 seq_printf(s, "a_conn: %d\n", fsm->a_conn);
255 seq_printf(s, "b_bus_req: %d\n", fsm->b_bus_req);
257 seq_printf(s, "b_bus_suspend: %d\n", fsm->b_bus_suspend);
259 seq_printf(s, "b_se0_srp: %d\n", fsm->b_se0_srp);
261 seq_printf(s, "b_ssend_srp: %d\n", fsm->b_ssend_srp);
263 seq_printf(s, "b_sess_vld: %d\n", fsm->b_sess_vld);
265 seq_printf(s, "b_srp_done: %d\n", fsm->b_srp_done);
267 seq_printf(s, "drv_vbus: %d\n", fsm->drv_vbus);
269 seq_printf(s, "loc_conn: %d\n", fsm->loc_conn);
271 seq_printf(s, "loc_sof: %d\n", fsm->loc_sof);
273 seq_printf(s, "adp_prb: %d\n", fsm->adp_prb);
275 seq_printf(s, "id: %d\n", fsm->id);
277 seq_printf(s, "protocol: %d\n", fsm->protocol);
282 static int ci_otg_open(struct inode *inode, struct file *file)
284 return single_open(file, ci_otg_show, inode->i_private);
287 static const struct file_operations ci_otg_fops = {
291 .release = single_release,
294 static int ci_role_show(struct seq_file *s, void *data)
296 struct ci_hdrc *ci = s->private;
298 seq_printf(s, "%s\n", ci_role(ci)->name);
303 static ssize_t ci_role_write(struct file *file, const char __user *ubuf,
304 size_t count, loff_t *ppos)
306 struct seq_file *s = file->private_data;
307 struct ci_hdrc *ci = s->private;
312 if (copy_from_user(buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
315 for (role = CI_ROLE_HOST; role < CI_ROLE_END; role++)
316 if (ci->roles[role] &&
317 !strncmp(buf, ci->roles[role]->name,
318 strlen(ci->roles[role]->name)))
321 if (role == CI_ROLE_END || role == ci->role)
324 pm_runtime_get_sync(ci->dev);
326 ret = ci_role_start(ci, role);
327 pm_runtime_put_sync(ci->dev);
329 return ret ? ret : count;
332 static int ci_role_open(struct inode *inode, struct file *file)
334 return single_open(file, ci_role_show, inode->i_private);
337 static const struct file_operations ci_role_fops = {
338 .open = ci_role_open,
339 .write = ci_role_write,
342 .release = single_release,
345 static int ci_registers_show(struct seq_file *s, void *unused)
347 struct ci_hdrc *ci = s->private;
350 if (!ci || ci->in_lpm)
353 /* ------ Registers ----- */
354 tmp_reg = hw_read_intr_enable(ci);
355 seq_printf(s, "USBINTR reg: %08x\n", tmp_reg);
357 tmp_reg = hw_read_intr_status(ci);
358 seq_printf(s, "USBSTS reg: %08x\n", tmp_reg);
360 tmp_reg = hw_read(ci, OP_USBMODE, ~0);
361 seq_printf(s, "USBMODE reg: %08x\n", tmp_reg);
363 tmp_reg = hw_read(ci, OP_USBCMD, ~0);
364 seq_printf(s, "USBCMD reg: %08x\n", tmp_reg);
366 tmp_reg = hw_read(ci, OP_PORTSC, ~0);
367 seq_printf(s, "PORTSC reg: %08x\n", tmp_reg);
370 tmp_reg = hw_read_otgsc(ci, ~0);
371 seq_printf(s, "OTGSC reg: %08x\n", tmp_reg);
377 static int ci_registers_open(struct inode *inode, struct file *file)
379 return single_open(file, ci_registers_show, inode->i_private);
382 static const struct file_operations ci_registers_fops = {
383 .open = ci_registers_open,
386 .release = single_release,
390 * dbg_create_files: initializes the attribute interface
393 * This function returns an error code
395 int dbg_create_files(struct ci_hdrc *ci)
399 ci->debugfs = debugfs_create_dir(dev_name(ci->dev), NULL);
403 dent = debugfs_create_file("device", S_IRUGO, ci->debugfs, ci,
408 dent = debugfs_create_file("port_test", S_IRUGO | S_IWUSR, ci->debugfs,
409 ci, &ci_port_test_fops);
413 dent = debugfs_create_file("qheads", S_IRUGO, ci->debugfs, ci,
418 dent = debugfs_create_file("requests", S_IRUGO, ci->debugfs, ci,
423 if (ci_otg_is_fsm_mode(ci)) {
424 dent = debugfs_create_file("otg", S_IRUGO, ci->debugfs, ci,
430 dent = debugfs_create_file("role", S_IRUGO | S_IWUSR, ci->debugfs, ci,
435 dent = debugfs_create_file("registers", S_IRUGO, ci->debugfs, ci,
441 debugfs_remove_recursive(ci->debugfs);
446 * dbg_remove_files: destroys the attribute interface
449 void dbg_remove_files(struct ci_hdrc *ci)
451 debugfs_remove_recursive(ci->debugfs);